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

import aermicioi.aedi : NotFoundException;
import aermicioi.aedi_property_reader.core.exception;
import aermicioi.aedi_property_reader.core.convertor;
import aermicioi.aedi_property_reader.core.placeholder;
import aermicioi.util.traits : isPublic, isField;
import aermicioi.aedi_property_reader.core.traits;
import std.conv;
import std.traits;
import std.meta;
import std.exception;

/**
Provides ability to set a property of FieldType into CompositeType.
**/
interface PropertySetter(CompositeType, FieldType = CompositeType, KeyType = string) {

    /**
    Set a field or property of CompositeType.

    Params:
        composite = composite that will store value
        value = actual value that is assigned to a field in composite
        property = the identity of field in composite
    Throws:
        InvalidArgumentException when value or composite is not what was expected
    **/
    void set(ref CompositeType composite, FieldType value, KeyType property) const;

    /**
     Identify the type of supported component.

     Identify the type of supported component. It returns type info of component
     if it is supported by accessor, otherwise it will return typeid(void) denoting that
     the type isn't supported by accessor. The accessor is not limited to returning the type
     info of passed component, it can actually return type info of super type or any type
     given the returned type is implicitly convertible or castable to ComponentType.

     Params:
         component = the component for which accessor should identify the underlying type

     Returns:
         TypeInfo type information about passed component, or typeid(void) if component is not supported.
     **/
    TypeInfo componentType(ref CompositeType composite) const nothrow;

    /**
     Identify the type of supported component.

     Identify the type of supported component. It returns type info of component
     if it is supported by accessor, otherwise it will return typeid(void) denoting that
     the type isn't supported by accessor. The accessor is not limited to returning the type
     info of passed component, it can actually return type info of super type or any type
     given the returned type is implicitly convertible or castable to ComponentType.

     Params:
         component = the component for which accessor should identify the underlying type

     Returns:
         TypeInfo type information about passed component, or typeid(void) if component is not supported.
     **/
    final TypeInfo componentType(CompositeType composite) const nothrow {
        return this.componentType(composite);
    }
}

/**
Associative array setter.
**/
class AssociativeArraySetter(Type, KeyType = Type) : PropertySetter!(Type[KeyType], Type, KeyType) {

    public {
        /**
        Set a field or property of CompositeType.

        Params:
            composite = composite that will store value
            value = actual value that is assigned to a field in composite
            property = the identity of field in composite
        Throws:
            InvalidArgumentException when value or composite is not what was expected
        **/
        void set(ref Type[KeyType] composite, Type field, KeyType key) const {
            composite[key] = field;
        }

        /**
         Identify the type of supported component.

         Identify the type of supported component. It returns type info of component
         if it is supported by accessor, otherwise it will return typeid(void) denoting that
         the type isn't supported by accessor. The accessor is not limited to returning the type
         info of passed component, it can actually return type info of super type or any type
         given the returned type is implicitly convertible or castable to ComponentType.

         Params:
             component = the component for which accessor should identify the underlying type

         Returns:
             TypeInfo type information about passed component, or typeid(void) if component is not supported.
         **/
        TypeInfo componentType(ref Type[KeyType] composite) const nothrow {
            return typeid(Type[KeyType]);
        }
    }
}

/**
Array setter.
**/
class ArraySetter(Type) : PropertySetter!(Type[], Type, size_t) {

    /**
    Set a field or property of CompositeType.

    Params:
        composite = composite that will store value
        value = actual value that is assigned to a field in composite
        property = the identity of field in composite
    Throws:
        InvalidArgumentException when value or composite is not what was expected
    **/
    void set(ref Type[] composite, Type field, size_t key) const {
        enforce!InvalidArgumentException(key < composite.length, text(
            "Cannot assign ",
            field,
            " to ",
            composite,
            " index ",
            key,
            " out of bounds ",
            composite.length
        ));

        composite[key] = field;
    }

    /**
     Identify the type of supported component.

     Identify the type of supported component. It returns type info of component
     if it is supported by accessor, otherwise it will return typeid(void) denoting that
     the type isn't supported by accessor. The accessor is not limited to returning the type
     info of passed component, it can actually return type info of super type or any type
     given the returned type is implicitly convertible or castable to ComponentType.

     Params:
         component = the component for which accessor should identify the underlying type

     Returns:
         TypeInfo type information about passed component, or typeid(void) if component is not supported.
     **/
    TypeInfo componentType(ref Type[] composite) const nothrow {
        return typeid(Type[]);
    }
}

/**
Composite (object, struct, union) setter.
**/
class CompositeSetter(ComponentType) : PropertySetter!(ComponentType, Object, string)
    if (isAggregateType!ComponentType) {

    /**
    Set a field or property of CompositeType.

    Params:
        composite = composite that will store value
        value = actual value that is assigned to a field in composite
        property = the identity of field in composite
    Throws:
        InvalidArgumentException when value or composite is not what was expected
    **/
    void set(T)(ref ComponentType component, T field, string property) const {
        import std.experimental.allocator : theAllocator, dispose;
        auto wrapped = field.placeholder(theAllocator);
        this.set(component, wrapped, property);

        static if (!is(T : Object)) {
            theAllocator.dispose(wrapped);
        }
    }

    /**
    ditto
    **/
    void set(ref ComponentType component, Object field, string property) const {
        static foreach (member; __traits(allMembers, ComponentType)) {{
            static if (isPublic!(ComponentType, member)) {
                alias m = Alias!(__traits(getMember, component, member));

                if (member == property) {
                    static if (isField!(ComponentType, member)) {
                        alias FieldType = typeof(__traits(getMember, component, member));

                        enforce!InvalidArgumentException(field.identify is typeid(FieldType), text(
                            "Cannot set value of type ", field.identify,
                            " to property ", member,
                            " of type ", typeid(FieldType)
                        ));

                        __traits(getMember, component, member) = field.unwrap!FieldType;
                        return;
                    } else static if (
                        isSomeFunction!m &&
                        anySatisfy!(isPropertyPropertySetter, __traits(getOverloads, ComponentType, member))
                    ) {
                        alias FieldType = Parameters!(
                            match!(
                                isPropertyPropertySetter,
                                __traits(getOverloads, ComponentType, member)
                                )
                            )[0];

                        enforce!InvalidArgumentException(field.identify is typeid(FieldType), text(
                            "Cannot set value of type ", field.identify,
                            " to property ", member,
                            " of type ", typeid(FieldType)
                        ));

                        __traits(getMember, component, member) = field.unwrap!FieldType;
                        return;
                    }
                }
            }
        }}

        throw new NotFoundException(text(
            "Component of type ",
            typeid(ComponentType),
            " does not have ",
            property,
            " property"
        ));
    }

    /**
     Identify the type of supported component.

     Identify the type of supported component. It returns type info of component
     if it is supported by accessor, otherwise it will return typeid(void) denoting that
     the type isn't supported by accessor. The accessor is not limited to returning the type
     info of passed component, it can actually return type info of super type or any type
     given the returned type is implicitly convertible or castable to ComponentType.

     Params:
         component = the component for which accessor should identify the underlying type

     Returns:
         TypeInfo type information about passed component, or typeid(void) if component is not supported.
     **/
    TypeInfo componentType(ref ComponentType composite) const nothrow {
        return typeid(ComponentType);
    }
}

/**
Runtime composite setter that accepts erased Type, restores it's type and sets data in it.
**/
class RuntimeCompositeSetter(Type, FieldType = Type, KeyType = string) : PropertySetter!(Object, FieldType, KeyType) {
    private {
        PropertySetter!(Type, FieldType, KeyType) setter_;
    }

    public {
        /**
        Constructor for runtime composite setter.

        Params:
            setter = underlying setter used for assigning fields to component
        **/
        this(PropertySetter!(Type, FieldType, KeyType) setter) {
            this.setter = setter;
        }

        @property {
            /**
            Set setter

            Params:
                setter = underlying setter used to set data

            Returns:
                typeof(this)
            **/
            typeof(this) setter(PropertySetter!(Type, FieldType, KeyType) setter) @safe nothrow pure {
                this.setter_ = setter;

                return this;
            }

            /**
            Get setter

            Returns:
                PropertySetter!(Type, FieldType, KeyType)
            **/
            inout(PropertySetter!(Type, FieldType, KeyType)) setter() @safe nothrow pure inout {
                return this.setter_;
            }
        }

        /**
        Set a field or property of CompositeType.

        Params:
            composite = composite that will store value
            value = actual value that is assigned to a field in composite
            property = the identity of field in composite
        Throws:
            InvalidArgumentException when value or composite is not what was expected
        **/
        void set(ref Object composite, FieldType field, KeyType key) const {
            auto placeholder = composite.unwrap!Type;
            this.setter.set(placeholder, field, key);
        }

        /**
        Identify the type of supported component.

        Identify the type of supported component. It returns type info of component
        if it is supported by accessor, otherwise it will return typeid(void) denoting that
        the type isn't supported by accessor. The accessor is not limited to returning the type
        info of passed component, it can actually return type info of super type or any type
        given the returned type is implicitly convertible or castable to ComponentType.

        Params:
            component = the component for which accessor should identify the underlying type

        Returns:
            TypeInfo type information about passed component, or typeid(void) if component is not supported.
        **/
        TypeInfo componentType(ref Object composite) const nothrow {
            if (composite.identify is typeid(Type)) {
                return this.setter.componentType(composite.unwrap!Type);
            }

            return typeid(void);
        }
    }
}

/**
Runtime field setter that accepts type erased fields, that are restored and then assigned to component.
**/
class RuntimeFieldSetter(Type, FieldType = Type, KeyType = string) : PropertySetter!(Type, Object, KeyType) {
    private {
        PropertySetter!(Type, FieldType, KeyType) setter_;
    }

    public {
        /**
        Constructor for runtime field setter.

        Params:
            setter = underlying setter that works directly with FieldType values
        **/
        this(PropertySetter!(Type, FieldType, KeyType) setter) {
            this.setter = setter;
        }

        @property {
            /**
            Set setter

            Params:
                setter = underlying setter used to set data

            Returns:
                typeof(this)
            **/
            typeof(this) setter(PropertySetter!(Type, FieldType, KeyType) setter) @safe nothrow pure {
                this.setter_ = setter;

                return this;
            }

            /**
            Get setter

            Returns:
                PropertySetter!(Type, FieldType, KeyType)
            **/
            inout(PropertySetter!(Type, FieldType, KeyType)) setter() @safe nothrow pure inout {
                return this.setter_;
            }
        }

        /**
        Set a field or property of CompositeType.

        Params:
            composite = composite that will store value
            value = actual value that is assigned to a field in composite
            property = the identity of field in composite
        Throws:
            InvalidArgumentException when value or composite is not what was expected
        **/
        void set(ref Type composite, Object field, KeyType key) const {
            this.setter.set(composite, field.unwrap!FieldType, key);
        }

        /**
        Identify the type of supported component.

        Identify the type of supported component. It returns type info of component
        if it is supported by accessor, otherwise it will return typeid(void) denoting that
        the type isn't supported by accessor. The accessor is not limited to returning the type
        info of passed component, it can actually return type info of super type or any type
        given the returned type is implicitly convertible or castable to ComponentType.

        Params:
            component = the component for which accessor should identify the underlying type

        Returns:
            TypeInfo type information about passed component, or typeid(void) if component is not supported.
        **/
        TypeInfo componentType(ref Type composite) const nothrow {
            return typeid(Type);
        }
    }
}