/**
License:
    Boost Software License - Version 1.0 - August 17th, 2003

    Permission is hereby granted, free of charge, to any person or organization
    obtaining a copy of the software and accompanying documentation covered by
    this license (the "Software") to use, reproduce, display, distribute,
    execute, and transmit the Software, and to prepare derivative works of the
    Software, and to permit third-parties to whom the Software is furnished to
    do so, all subject to the following:

    The copyright notices in the Software and this entire statement, including
    the above license grant, this restriction and the following disclaimer,
    must be included in all copies of the Software, in whole or in part, and
    all derivative works of the Software, unless such copies or derivative
    works are solely in the form of machine-executable object code generated by
    a source language processor.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
    SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
    FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.

Authors:
    Alexandru Ermicioi
**/
module aermicioi.aedi_property_reader.convertor.mapper;

import aermicioi.aedi.configurer.annotation.annotation;
import aermicioi.aedi_property_reader.convertor.exception;
import aermicioi.aedi_property_reader.convertor.convertor :
    CombinedConvertor,
    ConvertsFromToMixin,
    Convertor,
    EqualToHashToStringOpCmpMixin;
import aermicioi.aedi_property_reader.convertor.inspector;
import aermicioi.aedi_property_reader.convertor.setter;
import aermicioi.aedi_property_reader.convertor.accessor;
import aermicioi.aedi_property_reader.convertor.placeholder;
import std.experimental.allocator;
import std.experimental.logger;
import std.exception;
import std.algorithm;
import std.conv;
import std.traits : fullyQualifiedName;
import std.typecons : Flag;

/**
Interface for components that are able to map from one type to another one.
**/
interface Mapper(To, From = To) {

    /**
    Map from component to component.

    Map from component to component, or transfer data from component to component
    with optional conversion of data along the way.

    Params:
        from = original component that has it's data transferred
        to = destination component that receives transferred data
        allocator = optional allocator that could be used by convertors when doing field conversion
    **/
    void map(From from, ref To to, RCIAllocator allocator = theAllocator) const;

    @property {
        /**
        Set convertors

        Params:
            convertors = set a list of convertors to be used by mapper to automatically convert a mapped field to designated type
        Returns:
            typeof(this)
        **/
        typeof(this) convertor(Convertor convertor) @safe nothrow pure;

        /**
        Get convertors

        Returns:
            Convertor[]
        **/
        inout(Convertor) convertor() @safe nothrow pure inout;

        /**
        Set force

        Params:
            force = forces mapper to try and set a field even if it is not existent

        Returns:
            typeof(this)
        **/
        typeof(this) force(Flag!"force" force) @safe nothrow pure;

        /**
        Get force

        Returns:
            Flag!"force"
        **/
        inout(Flag!"force") force() @safe nothrow pure inout;

        /**
        Set conversion

        Params:
            conversion = whether to enable or not automatic conversion of fields using convertors.

        Returns:
            typeof(this)
        **/
        typeof(this) conversion(Flag!"conversion" conversion) @safe nothrow pure;

        /**
        Get conversion

        Returns:
            Flag!"conversion"
        **/
        inout(Flag!"conversion") conversion() @safe nothrow pure inout;

        /**
        Set skip

        Params:
            skip = whether to skip mapping of fields that have their type not identifiable in destination component

        Returns:
            typeof(this)
        **/
        typeof(this) skip(Flag!"skip" skip) @safe nothrow pure;

        /**
        Get skip

        Returns:
            Flag!"skip"
        **/
        inout(Flag!"skip") skip() @safe nothrow pure inout;
    }
}

/**
An implementation of a mapper that specifically converts From component To component.

An implementation of a mapper that specifically converts From component To component.
It will use inspectors for From and To component to get information about component fields
at runtime, and then use accessor and setter implementations to transfer data from one
component to another, with optional conversion of data using passed convertors.
**/
@component
class CompositeMapper(To, From) : Mapper!(To, From) {

    private {
        Flag!"conversion" conversion_;
        Flag!"force" force_;
        Flag!"skip" skip_;

        Convertor convertor_;

        const PropertySetter!(To, Object) setter;
        const PropertyAccessor!(From, Object) accessor;
        const Inspector!From fromInspector;
        const Inspector!To toInspector;
    }

    public {

        @autowired
        this(
            PropertySetter!(To, Object) setter,
            PropertyAccessor!(From, Object) accessor,
            Inspector!From fromInspector,
            Inspector!To toInspector
        ) {
            this.setter = setter;
            this.accessor = accessor;
            this.fromInspector = fromInspector;
            this.toInspector = toInspector;
        }

        @property {
            /**
            Set convertors

            Params:
                convertors = a list of optional convertors used to convert from one format to another one

            Returns:
                typeof(this)
            **/
            @autowired
            typeof(this) convertor(Convertor convertor) @safe nothrow pure
                in (convertor !is null, "Expected convertor, not null value") {
                this.convertor_ = convertor;

                return this;
            }

            /**
            Get convertors

            Returns:
                Convertor[]
            **/
            inout(Convertor) convertor() @safe nothrow pure inout
                out(conv; conv !is null, "Expected to have a proper convertor available not null") {
                return this.convertor_;
            }

            /**
            Set conversion

            Params:
                conversion = wether to convert or not values using convertors.

            Returns:
                typeof(this)
            **/
            @autowired
            typeof(this) conversion(Flag!"conversion" conversion) @safe nothrow pure {
                this.conversion_ = conversion;

                return this;
            }

            /**
            Get conversion

            Returns:
                Flag!"conversion"
            **/
            inout(Flag!"conversion") conversion() @safe nothrow pure inout {
                return this.conversion_;
            }

            /**
            Set force

            Params:
                force = whether to force attempt in setting a property in a mapped component

            Returns:
                typeof(this)
            **/
            @autowired
            typeof(this) force(Flag!"force" force) @safe nothrow pure {
                this.force_ = force;

                return this;
            }

            /**
            Get force

            Returns:
                Flag!"force"
            **/
            inout(Flag!"force") force() @safe nothrow pure inout {
                return this.force_;
            }

            /**
            Set skip

            Params:
                skip = whether to skip mapping of fields that have their type not identifiable in destination component

            Returns:
                typeof(this)
            **/
            @autowired
            typeof(this) skip(Flag!"skip" skip) @safe nothrow pure {
                this.skip_ = skip;

                return this;
            }

            /**
            Get skip

            Returns:
                Flag!"skip"
            **/
            inout(Flag!"skip") skip() @safe nothrow pure inout {
                return this.skip_;
            }
        }

        /**
        Map from component to component.

        Map from component to component, or transfer data from component to component
        with optional conversion of data along the way.

        Params:
            from = original component that has it's data transferred
            to = destination component that receives transferred data
            allocator = optional allocator that could be used by convertors when doing field conversion
        **/
        void map(From from, ref To to, RCIAllocator allocator = theAllocator) const {

            debug(trace) trace(
                "Mapping ",
                this.fromInspector.properties(from),
                " of ",
                from.identify,
                " to ",
                to.identify
            );

            foreach (property; this.fromInspector.properties(from)) {

                debug(trace) trace("Migrating \"", property, "\" property ");
                if (this.toInspector.has(to, property) || this.force) {

                    Object value = this.accessor.access(from, property, allocator);

                    if (
                        this.fromInspector.typeOf(from, property) != this.toInspector.typeOf(to, property)
                    ) {
                        if (this.conversion) {
                            if (this.toInspector.typeOf(to, property) is typeid(void)) {
                                if (this.skip) {
                                    debug(trace) trace(
                                        "Skipping migration of \"",
                                        property,
                                        "\" due to missing type information in destination component"
                                    );

                                    continue;
                                }

                                throw new ConvertorException(text(
                                        "Cannot identify type of \"", property,
                                        "\" in destination component, probably missing"
                                ));
                            }

                            debug(trace) trace("\"",
                                property,
                                "\"'s type differs in original component and destination component, ",
                                this.fromInspector.typeOf(from, property), " and ",
                                this.toInspector.typeOf(to, property)
                            );

                            enforce!ConvertorException(
                                this.convertor.converts(this.fromInspector.typeOf(from, property), this.toInspector.typeOf(to, property)),
                                text(
                                    "Could not convert \"", property, "\" from ",
                                    this.fromInspector.typeOf(from, property), " to ", this.toInspector.typeOf(to, property), " ",
                                    this.convertor, " does not support it"
                                )
                            );

                            debug(trace) trace(
                                "Converting \"", property, "\" from ",
                                this.fromInspector.typeOf(from, property), " to ",
                                this.toInspector.typeOf(to, property)
                            );

                            value = this.convertor.convert(value, this.toInspector.typeOf(to, property), allocator);
                        } else {

                            throw new InvalidArgumentException(text(
                                "Invalid assignment \"", property, "\" has type of ",
                                this.fromInspector.typeOf(from, property),
                                " in from component while in to component it is ",
                                this.toInspector.typeOf(to, property)
                            ));
                        }
                    }

                    try {

                        this.setter.set(
                            to,
                            value,
                            property
                        );

                        debug(trace) trace("Migrated \"", property, "\" from ", from.identify, " to ", to.identify);
                    } catch (Exception e) {

                        debug(trace) trace(
                            "Couldn't ",
                            this.force ? "forcefully " : "",
                            "set property \"",
                            property,
                            "\" to ",
                            to.identify,
                            " from ",
                            from.identify,
                            " due to ",
                            e
                        );
                    }
                } else {

                    debug(trace) error(to.identify, " element does not have: ", property);
                }
            }
        }

    }
}

/**
An implementation of convertor that is using a mapper to map from component to component.
**/
@component
class CompositeConvertor(To, From) : Convertor {
    import std.algorithm : filter;
    import std.array: array;

    private {
        Mapper!(To, From) mapper_;
    }

    public {
        @property {
            /**
            Set mapper

            Params:
                mapper = mapper used to map from component to component

            Returns:
                typeof(this)
            **/
            @autowired
            typeof(this) mapper(Mapper!(To, From) mapper) @safe nothrow pure {
                this.mapper_ = mapper;

                return this;
            }

            /**
            Get mapper

            Returns:
                Mapper!(To, From)
            **/
            inout(Mapper!(To, From)) mapper() @safe nothrow pure inout {
                return this.mapper_;
            }
        }

        mixin ConvertsFromToMixin!(From, To);

        /**
        Convert from component to component.

        Params:
            from = original component that is to be converted.
            to = destination object that will be constructed out for original one.
            allocator = optional allocator that could be used to construct to component.
        Throws:
            ConvertorException when there is a converting error
            InvalidArgumentException when arguments passed are not of right type or state
        Returns:
            Resulting converted component.
        **/
        Object convert(in Object from, const TypeInfo to, RCIAllocator allocator = theAllocator)  const {
            enforce!InvalidArgumentException(
                this.convertsFrom(from),
                text(
                    "Cannot convert ", from.identify, " to ", typeid(To),
                    ", ", from.identify, " is not supported by ", typeid(this)
                )
            );

            enforce!InvalidArgumentException(
                this.convertsTo(to),
                text(
                    "Cannot convert ", from.identify, " to ", typeid(To),
                    ", ", to, " is not supported by ", typeid(this)
                )
            );


            auto placeholder = To.init.pack(from, this, allocator);

            static if (is(To : Object)) {
                placeholder.value = allocator.make!To;
            }

            this.mapper.map(from.unwrap!From, placeholder.value, allocator);

            return placeholder;
        }

        /**
        Destroy component created using this convertor.

        Destroy component created using this convertor.
        Since convertor could potentially allocate memory for
        converted component, only itself is containing history of allocation,
        and therefore it is responsible as well to destroy and free allocated
        memory with allocator.

        Params:
            converted = component that should be destroyed.
            allocator = allocator used to allocate converted component.
        **/
        void destruct(const TypeInfo from, ref Object converted, RCIAllocator allocator = theAllocator) const {
            enforce!ConvertorException(this.destroys(from, converted), text(
                "Cannot destruct ", converted.identify, " not supported by ", typeid(this), " expected ", this.to
            ));

            static if (is(To : Object)) {
                allocator.dispose(converted.unpack!To);
            } else {
                converted.unpack!To;
            }

            converted = Object.init;
        }

        mixin EqualToHashToStringOpCmpMixin!();
    }
}