<?php

namespace FootyRoom\Support;

use ArrayObject;
use ReflectionClass;
use ReflectionObject;
use ReflectionProperty;
use MongoDB\Model\BSONArray;

class AutoMapper
{
    /**
     * Maps properties from given object to a new instance of specified type.
     *
     * Only public properties of source will be mapped to target. Target
     * properties can still be private. If target contains properties with
     * interal PHP classes then those will not be mapped. Primitive types are
     * mapped without casting.
     *
     * @param mixed $source
     * @param string $name Class name
     * @param array $mappings Mappings in ['to' => 'from'] configuration.
     * @param bool $merge If set to true, AutoMapper will use user defined
     *                    mappings as an addition to automatic same name
     *                    mappings. If set to false then only user defined
     *                    mappings will be performed.
     *
     * @return mixed
     */
    public static function map($source, $name, $mappings = [], $merge = true)
    {
        $targetReflection = new ReflectionClass($name);

        // We don't map PHP internal classes.
        if ($targetReflection->isInternal()) {
            return;
        }

        $target = $targetReflection->newInstanceWithoutConstructor();

        if (empty($mappings) || $merge) {
            $properties = $targetReflection->getProperties();

            foreach ($properties as $prop) {
                if (!isset($mappings[$prop->getName()])) {
                    $mappings[$prop->getName()] = $prop->getName();
                }
            }
        }

        foreach ($mappings as $to => $from) {
            self::mapProperty($source, $target, $targetReflection, $from, $to);
        }

        return $target;
    }

    /**
     * Sets a non-public property to a specified value.
     *
     * @param mixed $target
     * @param string $key
     * @param mixed $value
     */
    public static function setValue($target, $key, $value)
    {
        $targetReflection = new ReflectionObject($target);

        $targetProperty = $targetReflection->getProperty($key);
        $targetProperty->setAccessible(true);
        $targetProperty->setValue($target, $value);
    }

    /**
     * Maps single property from source to target.
     *
     * @param object $source
     * @param mixed $target
     * @param \ReflectionClass $targetReflection
     * @param string $from Property name on source
     * @param string $to Property name on target
     */
    protected static function mapProperty($source, $target, $targetReflection, $from, $to)
    {
        if ($source === null || !property_exists($source, $from)) {
            return;
        }

        $targetProperty = $targetReflection->getProperty($to);
        $targetProperty->setAccessible(true);

        $sourceProperty = $source->{$from};

        $sourceClass = null;
        $targetClass = null;
        $targetArrayClass = null;
        $isPrimitiveType = true;

        // We will only parse type of target if source is an object or array
        // because if it's not then we wont cast premitive type into an object
        // anyway.
        if (is_object($sourceProperty) && !($sourceProperty instanceof BSONArray)) {
            $targetClass = self::parseType($targetProperty);

            if ($targetClass) {
                $isPrimitiveType = self::isPrimitiveType($targetClass);
                $sourceClass = get_class($sourceProperty);
            }
        } elseif (is_array($sourceProperty) || $sourceProperty instanceof ArrayObject) {
            $targetArrayClass = self::parseArrayType($targetProperty);
            $isPrimitiveType = self::isPrimitiveType($targetArrayClass);
        }

        // If a target is an object.
        if ($targetClass && $targetClass !== $sourceClass && !$isPrimitiveType) {
            $targetProperty->setValue(
                $target,
                self::map($sourceProperty, $targetClass)
            );
        }
        // If target is an array of objects.
        elseif ($targetArrayClass && !$isPrimitiveType) {
            $items = [];

            foreach ($sourceProperty as $item) {
                $items[] = self::map($item, $targetArrayClass);
            }

            $targetProperty->setValue($target, $items);
        } else {
            $targetProperty->setValue($target, $sourceProperty);
        }
    }

    /**
     * Returns type of property.
     *
     * @param \ReflectionProperty $property
     *
     * @return string|null
     */
    protected static function parseType(ReflectionProperty $property)
    {
        $result = preg_match('/@var\\s*([^\\s\\|]*)/i', $property->getDocComment(), $matches);

        return isset($matches[1]) ? trim($matches[1], '\\') : null;
    }

    /**
     * Returns type of typed array property.
     *
     * @param \ReflectionProperty $property
     *
     * @return string|null
     */
    protected static function parseArrayType(ReflectionProperty $property)
    {
        $result = preg_match('/@var\\s*([^\\s\\[]*)\\[\\]/i', $property->getDocComment(), $matches);

        return isset($matches[1]) ? trim($matches[1], '\\') : null;
    }

    /**
     * Determines if type is one of PHP's primitive types.
     *
     * @param string $type
     *
     * @return bool
     */
    protected static function isPrimitiveType($type)
    {
        switch (strtolower($type)) {
            case 'int':
            case 'integer':
            case 'bool':
            case 'boolean':
            case 'float':
            case 'double':
            case 'real':
            case 'string':
            case 'array':
            case 'object':
            case 'callable':
            case 'mixed':
                return true;
            default:
                return false;
        }
    }
}