/**
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.core.mapper;

import aermicioi.aedi_property_reader.core.exception;
import aermicioi.aedi_property_reader.core.convertor;
import aermicioi.aedi_property_reader.core.inspector;
import aermicioi.aedi_property_reader.core.setter;
import aermicioi.aedi_property_reader.core.accessor;
import aermicioi.aedi_property_reader.core.placeholder;
import std.experimental.allocator;
import std.experimental.logger;
import std.exception;
import std.algorithm;
import std.conv;

/**
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);

    @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) convertors(Convertor[] convertors) @safe nothrow pure;

        /**
        Get convertors

        Returns:
            Convertor[]
        **/
        inout(Convertor[]) convertors() @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(bool force) @safe nothrow pure;

        /**
        Get force

        Returns:
            bool
        **/
        inout(bool) 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(bool conversion) @safe nothrow pure;

        /**
        Get conversion

        Returns:
            bool
        **/
        inout(bool) 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(bool skip) @safe nothrow pure;

        /**
        Get skip

        Returns:
            bool
        **/
        inout(bool) 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.
**/
class CompositeMapper(To, From) : Mapper!(To, From) {

    private {
        import std.typecons : Rebindable;
        bool conversion_;
        bool force_;
        bool skip_;

        Convertor[] convertors_;

        Rebindable!(const PropertySetter!(To, Object)) setter_;
        Rebindable!(const PropertyAccessor!(From, Object)) accessor_;
        Rebindable!(const Inspector!From) fromInspector_;
        Rebindable!(const Inspector!To) toInspector_;
    }

    public {

        @property {
            /**
            Set convertors

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

            Returns:
                typeof(this)
            **/
            typeof(this) convertors(Convertor[] convertors) @safe nothrow pure {
                this.convertors_ = convertors;

                return this;
            }

            /**
            Get convertors

            Returns:
                Convertor[]
            **/
            inout(Convertor[]) convertors() @safe nothrow pure inout {
                return this.convertors_;
            }

            /**
            Set conversion

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

            Returns:
                typeof(this)
            **/
            typeof(this) conversion(bool conversion) @safe nothrow pure {
                this.conversion_ = conversion;

                return this;
            }

            /**
            Get conversion

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

            /**
            Set setter

            Params:
                setter = setter used to pass values to component.

            Returns:
                typeof(this)
            **/
            typeof(this) setter(in PropertySetter!(To, Object) setter) @safe nothrow pure {
                this.setter_ = setter;

                return this;
            }

            /**
            Get setter

            Returns:
                PropertySetter!(To, Object)
            **/
            inout(const PropertySetter!(To, Object)) setter() @safe nothrow pure inout {
                return this.setter_.get;
            }

            /**
            Set accessor

            Params:
                accessor = property accessor used to extract values from mapped component

            Returns:
                typeof(this)
            **/
            typeof(this) accessor(in PropertyAccessor!(From, Object) accessor) @safe nothrow pure {
                this.accessor_ = accessor;

                return this;
            }

            /**
            Get accessor

            Returns:
                PropertyAccessor!(From, Object)
            **/
            inout(const PropertyAccessor!(From, Object)) accessor() @safe nothrow pure inout {
                return this.accessor_.get;
            }

            /**
            Set fromInspector

            Params:
                fromInspector = inspector providing information about mapped component

            Returns:
                typeof(this)
            **/
            typeof(this) fromInspector(in Inspector!From fromInspector) @safe nothrow pure {
                this.fromInspector_ = fromInspector;

                return this;
            }

            /**
            Get fromInspector

            Returns:
                Inspector!From
            **/
            inout(const Inspector!From) fromInspector() @safe nothrow pure inout {
                return this.fromInspector_.get;
            }

            /**
            Set toInspector

            Params:
                toInspector = inspector used to provide information about component that will store mapped data

            Returns:
                typeof(this)
            **/
            typeof(this) toInspector(in Inspector!To toInspector) @safe nothrow pure {
                this.toInspector_ = toInspector;

                return this;
            }

            /**
            Get toInspector

            Returns:
                Inspector!To
            **/
            inout(const Inspector!To) toInspector() @safe nothrow pure inout {
                return this.toInspector_.get;
            }

            /**
            Set force

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

            Returns:
                typeof(this)
            **/
            typeof(this) force(bool force) @safe nothrow pure {
                this.force_ = force;

                return this;
            }

            /**
            Get force

            Returns:
                bool
            **/
            inout(bool) 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)
            **/
            typeof(this) skip(bool skip) @safe nothrow pure {
                this.skip_ = skip;

                return this;
            }

            /**
            Get skip

            Returns:
                bool
            **/
            inout(bool) 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) {

            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);
                    import std.stdio;

                    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)
                            );

                            auto compatible = convertors.filter!(c =>
                                c.convertsFrom(this.fromInspector.typeOf(from, property)) &&
                                c.convertsTo(this.toInspector.typeOf(to, property))
                            );

                            enforce!ConvertorException(!compatible.empty, text(
                                "Could not find convertor to convert \"", property, "\" from ", this.fromInspector.typeOf(from, property),
                                " to ", this.toInspector.typeOf(to, property)
                            ));

                            debug(trace) trace("Found convertor for \"", property, "\" from ", compatible.front.from, " to ", compatible.front.to);

                            value = compatible.front.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.
**/
class CompositeConvertor(To, From) : CombinedConvertor {
    import std.algorithm;
    import std.array;

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

    public {
        /**
        Set used convertors

        Params:
            convertors = list of convertors to be used.

        Returns:
            typeof(this)
        **/
        typeof(this) convertors(Convertor[] convertors) @safe nothrow {
            this.mapper.convertors = convertors;

            return this;
        }

        /**
        Add a convertor to existing list

        Params:
            convertor = convertor to be added to

        Returns:
            typeof(this)
        **/
        typeof(this) add(Convertor convertor) @safe nothrow {
            this.mapper.convertors = this.mapper.convertors ~ convertor;

            return this;
        }

        /**
        Remove a convertor from existing list

        Params:
            convertor = convertor to be removed

        Returns:
            typeof(this)
        **/
        typeof(this) remove(Convertor convertor) @trusted nothrow {
            try {
                this.mapper.convertors = this.mapper.convertors.filter!(c => c != convertor).array;

            } catch (Exception e) {
                assert(false, text("Failed to remove convertor due to ", e));
            }

            return this;
        }

        @property {
            /**
            Set mapper

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

            Returns:
                typeof(this)
            **/
            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_;
            }

            /**
            Get the type info of component that convertor can convert from.

            Get the type info of component that convertor can convert from.
            The method is returning the default type that it is able to convert,
            though it is not necessarily limited to this type only. More generalistic
            checks should be done by convertsFrom method.

            Returns:
                type info of component that convertor is able to convert.
            **/
            TypeInfo from() const {
                return typeid(From);
            }

            /**
            Get the type info of component that convertor is able to convert to.

            Get the type info of component that convertor is able to convert to.
            The method is returning the default type that is able to convert,
            though it is not necessarily limited to this type only. More generalistic
            checks should be done by convertsTo method.

            Returns:
                type info of component that can be converted to.
            **/
            TypeInfo to() const {
                return typeid(To);
            }
        }

        /**
        Check whether convertor is able to convert from.

        Check whether convertor is able to convert from.
        The intent of method is to implement customized type checking
        is not limited immediatly to supported default from component.

        Params:
            from = the type info of component that could potentially be converted by convertor.
        Returns:
            true if it is able to convert from, or false otherwise.
        **/
        bool convertsFrom(TypeInfo from) const {
            return this.from is from;
        }

        /**
        Check whether convertor is able to convert from.

        Check whether convertor is able to convert from.
        The method will try to extract type info out of from
        object and use for subsequent type checking.
        The intent of method is to implement customized type checking
        is not limited immediatly to supported default from component.

        Params:
            from = the type info of component that could potentially be converted by convertor.
        Returns:
            true if it is able to convert from, or false otherwise.
        **/
        bool convertsFrom(in Object from) const {
            return this.convertsFrom(from.identify);
        }

        /**
        Check whether convertor is able to convert to.

        Check whether convertor is able to convert to.
        The intent of the method is to implement customized type checking
        that is not limited immediatly to supported default to component.

        Params:
            to = type info of component that convertor could potentially convert to.

        Returns:
            true if it is able to convert to, false otherwise.
        **/
        bool convertsTo(TypeInfo to) const nothrow {
            return this.to is to;
        }

        /**
        Check whether convertor is able to convert to.

        Check whether convertor is able to convert to.
        The method will try to extract type info out of to object and use
        for subsequent type checking.
        The intent of the method is to implement customized type checking
        that is not limited immediatly to supported default to component.

        Params:
            to = type info of component that convertor could potentially convert to.

        Returns:
            true if it is able to convert to, false otherwise.
        **/
        bool convertsTo(in Object to) const nothrow {
            return this.convertsTo(to.identify);
        }

        /**
        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, TypeInfo to, RCIAllocator allocator = theAllocator) {
            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)
            ));

            static if (is(To : Object)) {
                To placeholder = allocator.make!To;
                this.mapper.map(from.unwrap!From, placeholder, allocator);
            } else {
                auto placeholder = allocator.make!(PlaceholderImpl!To)(To.init);
                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(ref Object converted, RCIAllocator allocator = theAllocator) {
            enforce!InvalidArgumentException(this.convertsFrom(from), text(
                "Cannot destruct ", from.identify, " to ", typeid(To), " not supported by ", typeid(this)
            ));

            allocator.dispose(converted);
            converted = Object.init;
        }
    }
}

/**
An implementation of mapper, that works solely with components that have their type erased.

An implementation of mapper, that works solely with components that have their type erased.
At runtime it will attempt to match inspectors, accessor and setter for original component and
destination, then use them to create a specific mapper for that configuration and use it to
transfer data from origin component to destination one. If no matches are found, no transfer is performed
and an exception should be thrown.
**/
class RuntimeMapper : Mapper!(Object, Object) {

    private {
        bool conversion_;
        bool force_;
        bool skip_;

        Convertor[] convertors_;

        PropertyAccessor!Object[] accessors_;
        PropertySetter!Object[] setters_;
        Inspector!Object[] inspectors_;
        Mapper!Object delegate (
            in PropertyAccessor!Object,
            in PropertySetter!Object,
            in Inspector!Object,
            in Inspector!Object
        ) factory_;

        void delegate(Mapper!Object) destructor_;
    }

    public {
        @property {
            /**
            Set convertors

            Params:
                convertors = a list of convertors that could optionally be used to convert mapped fields

            Returns:
                typeof(this)
            **/
            typeof(this) convertors(Convertor[] convertors) @safe nothrow pure {
                this.convertors_ = convertors;

                return this;
            }

            /**
            Get convertors

            Returns:
                Convertor[]
            **/
            inout(Convertor[]) convertors() @safe nothrow pure inout {
                return this.convertors_;
            }

            /**
            Set conversion

            Params:
                conversion = whether to automatically convert or not mapped fields to desired type

            Returns:
                typeof(this)
            **/
            typeof(this) conversion(bool conversion) @safe nothrow pure {
                this.conversion_ = conversion;

                return this;
            }

            /**
            Get conversion

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

            /**
            Set force

            Params:
                force = whether force or not an attempt to set an inexistent field.

            Returns:
                typeof(this)
            **/
            typeof(this) force(bool force) @safe nothrow pure {
                this.force_ = force;

                return this;
            }

            /**
            Get force

            Returns:
                bool
            **/
            inout(bool) 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)
            **/
            typeof(this) skip(bool skip) @safe nothrow pure {
                this.skip_ = skip;

                return this;
            }

            /**
            Get skip

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

            /**
            Set factory

            Params:
                factory = factory used to create a mapper

            Returns:
                typeof(this)
            **/
            typeof(this) factory(Mapper!Object delegate (
                    in PropertyAccessor!Object,
                    in PropertySetter!Object,
                    in Inspector!Object,
                    in Inspector!Object
                ) factory) @safe nothrow pure {
                this.factory_ = factory;

                return this;
            }

            /**
            Get factory

            Returns:
                Mapper!Object delegate ()
            **/
            inout(Mapper!Object delegate (
                in PropertyAccessor!Object,
                in PropertySetter!Object,
                in Inspector!Object,
                in Inspector!Object
            )) factory() @safe nothrow pure inout {
                return this.factory_;
            }

            /**
            Set destructor

            Params:
                destructor = destructor used to destroy created mapper

            Returns:
                typeof(this)
            **/
            typeof(this) destructor(void delegate(Mapper!Object) destructor) @safe nothrow pure {
                this.destructor_ = destructor;

                return this;
            }

            /**
            Get destructor

            Returns:
                void delegate(Mapper!Object)
            **/
            inout(void delegate(Mapper!Object)) destructor() @safe nothrow pure inout {
                return this.destructor_;
            }

            /**
            Set accessors

            Params:
                accessors = list of runtime accessors used to access data

            Returns:
                typeof(this)
            **/
            typeof(this) accessors(PropertyAccessor!Object[] accessors) @safe nothrow pure {
                this.accessors_ = accessors;

                return this;
            }

            /**
            Get accessors

            Returns:
                PropertyAccessor!Object[]
            **/
            inout(PropertyAccessor!Object[]) accessors() @safe nothrow pure inout {
                return this.accessors_;
            }

            /**
            Set setters

            Params:
                setters = list of runtime setters used to map from one to another

            Returns:
                typeof(this)
            **/
            typeof(this) setters(PropertySetter!Object[] setters) @safe nothrow pure {
                this.setters_ = setters;

                return this;
            }

            /**
            Get setters

            Returns:
                PropertySetter!Object[]
            **/
            inout(PropertySetter!Object[]) setters() @safe nothrow pure inout {
                return this.setters_;
            }

            /**
            Set inspectors

            Params:
                inspectors = list of runtime inspectors used to inspect various components

            Returns:
                typeof(this)
            **/
            typeof(this) inspectors(Inspector!Object[] inspectors) @safe nothrow pure {
                this.inspectors_ = inspectors;

                return this;
            }

            /**
            Get inspectors

            Returns:
                Inspector!Object[]
            **/
            inout(Inspector!Object[]) inspectors() @safe nothrow pure inout {
                return this.inspectors_;
            }

        }

        /**
        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
        Throws:
            InvalidArgumentException when no either accessor, setter, or inspector is found.
        **/
        void map(Object from, ref Object to, RCIAllocator allocator = theAllocator) {
            auto accessors = this.accessors.filter!(accessor => accessor.componentType(from) is from.identify);
            auto setters = this.setters.filter!(setter => setter.componentType(to) is to.identify);
            auto fromInspectors = this.inspectors.filter!(inspector => inspector.typeOf(from) is from.identify);
            auto toInspectors = this.inspectors.filter!(inspector => inspector.typeOf(to) is to.identify);

            enforce!InvalidArgumentException(!accessors.empty, text("No field accessor for ", from.identify, " has been provided, cannot map to ", to.identify));
            enforce!InvalidArgumentException(!setters.empty, text("No field setter for ", to.identify, " has been provided, cannot map from ", from.identify));
            enforce!InvalidArgumentException(!fromInspectors.empty, text("No inspector for ", from.identify, " has been provided, cannot map to ", to.identify));
            enforce!InvalidArgumentException(!toInspectors.empty, text("No inspector for ", to.identify, " has been provided, cannot map from ", to.identify));

            import std.stdio;
            writeln(to.identify);
            auto mapper = this.factory()(
                accessors.front,
                setters.front,
                fromInspectors.front,
                toInspectors.front
            );
            mapper.force = this.force;
            mapper.conversion = this.conversion;
            mapper.skip = this.skip;
            mapper.convertors = this.convertors;

            mapper.map(from, to, allocator);

            this.destructor()(mapper);
        }

    }
}