<?php

/**
 * @copyright  Vertex. All rights reserved.  https://www.vertexinc.com/
 * @author     Mediotype Development         <diveinto@mediotype.com>
 */

namespace Vertex\Mapper;

use stdClass;
use Vertex\Exception\ValidationException;

/**
 * Contains functional utilities for mapping classes
 */
class MapperUtilities
{
    /**
     * Default maximum value for any string sent to Vertex
     */
    const DEFAULT_MAX = 60;

    /**
     * Default minimum value for any string sent to Vertex
     */
    const DEFAULT_MIN = 1;

    /**
     * Validate and, if valid, add a date to the mapping based on it's key
     *
     * @param stdClass $mapping
     * @param \DateTimeInterface $value
     * @param string $key
     * @param bool $optional
     * @param string $name Human readable name
     * @return stdClass
     * @throws ValidationException
     */
    public function addToMapWithDateValidation(stdClass $mapping, $value, $key, $optional = true, $name = null)
    {
        $name = $name ?: $key;

        if ($this->assertNotNull($value, $optional, $name)
            && $this->assertDate($value, $name)
        ) {
            $mapping->{$key} = $value->format('Y-m-d');
        }

        return $mapping;
    }

    /**
     * Validate and, if valid, add a float to the mapping based on its key
     *
     * @param stdClass $mapping
     * @param float $value
     * @param string $key
     * @param int $min
     * @param int $max
     * @param bool $optional
     * @param string $name Human readable name
     * @return stdClass
     * @throws ValidationException
     */
    public function addToMapWithDecimalValidation(
        stdClass $mapping,
        $value,
        $key,
        $min = PHP_INT_MIN,
        $max = PHP_INT_MAX,
        $optional = true,
        $name = null
    ) {
        $name = $name ?: $key;

        if ($this->assertNotNull($value, $optional, $name)
            && $this->assertDecimal($value, $name)
            && $this->assertBetween($value, $min, $max, $name)
        ) {
            $mapping->{$key} = (float)$value;
        }

        return $mapping;
    }

    /**
     * Validate and, if valid, add an enumeration to the mapping based on its key
     *
     * @param stdClass $mapping
     * @param string $value
     * @param string $key
     * @param string[] $availableValues
     * @param bool $optional
     * @param string $name Human readable name
     * @return stdClass
     * @throws ValidationException
     */
    public function addToMapWithEnumerationValidation(
        stdClass $mapping,
        $value,
        $key,
        array $availableValues,
        $optional = true,
        $name = null
    ) {
        $name = $name ?: $key;

        if ($this->assertNotNull($value, $optional, $name)
            && $this->assertContains($value, $availableValues, $name)
        ) {
            $mapping->{$key} = $value;
        }

        return $mapping;
    }

    /**
     * Validate and, if valid, add an integer to the mapping based on its key
     *
     * @param stdClass $mapping
     * @param int $value
     * @param string $key
     * @param int $min
     * @param int $max
     * @param bool $optional
     * @param string $name Human readable name
     * @return stdClass
     * @throws ValidationException
     */
    public function addToMapWithIntegerValidation(
        stdClass $mapping,
        $value,
        $key,
        $min = PHP_INT_MIN,
        $max = PHP_INT_MAX,
        $optional = true,
        $name = null
    ) {
        $name = $name ?: $key;

        if ($this->assertNotNull($value, $optional, $name)
            && $this->assertInteger($value, $name)
            && $this->assertBetween($value, $min, $max, $name)
        ) {
            $mapping->{$key} = (int)$value;
        }

        return $mapping;
    }

    /**
     * Validate and, if valid, add a string to the mapping based on it's key
     *
     * @param stdClass $mapping
     * @param string $value
     * @param string $key
     * @param int $min
     * @param int $max
     * @param bool $optional
     * @param string $name Human readable name
     * @return stdClass
     * @throws ValidationException
     */
    public function addToMapWithLengthValidation(
        stdClass $mapping,
        $value,
        $key,
        $min = self::DEFAULT_MIN,
        $max = self::DEFAULT_MAX,
        $optional = true,
        $name = null
    ) {
        $name = $name ?: $key;

        if ($this->assertNotNull($value, $optional, $name)
            && $this->assertLength($value, $min, $max, $name)
        ) {
            $mapping->{$key} = (string)$value;
        }

        return $mapping;
    }

    /**
     * Assert that a value is between a minimum and maximum integer
     *
     * @param int|float $value
     * @param int $min
     * @param int $max
     * @param string $exceptionName Name to call the variable in the exception
     * @return true
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @throws ValidationException
     */
    public function assertBetween($value, $min = PHP_INT_MIN, $max = PHP_INT_MAX, $exceptionName = 'Value')
    {
        $failure = $value < $min || $value > $max;
        $message = "{$exceptionName} must be a valid integer";
        if ($failure && $min !== PHP_INT_MIN && $max !== PHP_INT_MAX) {
            $message = "{$exceptionName} must be between {$min} and {$max}, inclusive";
        }
        if ($failure && $min === PHP_INT_MIN && $max !== PHP_INT_MAX) {
            $message = "{$exceptionName} must be less than or equal to {$max}";
        }
        if ($failure && $max === PHP_INT_MAX && $min !== PHP_INT_MIN) {
            $message = "{$exceptionName} must be greater than or equal to {$min}";
        }
        if ($failure) {
            throw new ValidationException($message);
        }
        return true;
    }

    /**
     * Assert that a value is contained in an array
     *
     * @param mixed $value
     * @param array $array
     * @param string $exceptionName Name to call the variable in the exception
     * @param bool $strict Check types as well
     * @return true
     * @throws ValidationException
     */
    public function assertContains($value, array $array, $exceptionName = 'Value', $strict = true)
    {
        if (!in_array($value, $array, $strict)) {
            throw new ValidationException("{$exceptionName} must be one of " . implode(', ', $array));
        }

        return true;
    }

    /**
     * Assert that a value is a \DateTimeInterface
     *
     * @param mixed $value
     * @param string $exceptionName Name to call the variable in the exception
     * @return true
     * @throws ValidationException
     */
    public function assertDate($value, $exceptionName = 'Value')
    {
        $isObject = is_object($value);
        $isDateTime = $value instanceof \DateTime;
        $implementsInterface = $isObject && in_array('DateTimeInterface', class_implements($value), true);
        if (!$isDateTime && !$implementsInterface) {
            throw new ValidationException("{$exceptionName} must be a valid DateTimeInterface");
        }

        return true;
    }

    /**
     * Assert that a value is a float or an integer
     *
     * @param mixed $value
     * @param string $exceptionName Name to call the variable in the exception
     * @return true
     * @throws ValidationException
     */
    public function assertDecimal($value, $exceptionName = 'Value')
    {
        if (!is_numeric($value)) {
            throw new ValidationException("{$exceptionName} must be a float");
        }

        return true;
    }

    /**
     * Assert that a value is an integer
     *
     * @param mixed $value
     * @param string $exceptionName Name to call the variable in the exception
     * @return true
     * @throws ValidationException
     */
    public function assertInteger($value, $exceptionName = 'Value')
    {
        if (!is_numeric($value) || (int)$value != (float)$value) {
            throw new ValidationException("{$exceptionName} must be an integer");
        }

        return true;
    }

    /**
     * Assert that a value's string length is between a minimum and maximum amount of characters
     *
     * @param mixed $value
     * @param int $min
     * @param int $max
     * @param string $exceptionName Name to call the variable in the exception
     * @return true
     * @throws ValidationException
     */
    public function assertLength($value, $min = self::DEFAULT_MIN, $max = self::DEFAULT_MAX, $exceptionName = 'Value')
    {
        $length = mb_strlen($value);
        if ($length < $min || $length > $max) {
            throw new ValidationException(
                "{$exceptionName} length ({$length}) must be between {$min} and {$max} characters, inclusive"
            );
        }

        return true;
    }

    /**
     * Assert that a value is not null
     *
     * @param mixed $value
     * @param bool $optional When set to false, an exception will be thrown
     * @param string $exceptionName Name to call the variable in the exception
     * @return bool Whether or not the value was null
     * @throws ValidationException
     */
    public function assertNotNull($value, $optional = true, $exceptionName = 'Value')
    {
        if (!$optional && $value === null) {
            throw new ValidationException("{$exceptionName} must not be null");
        }

        return $value !== null;
    }
}