/**
This module provides fluent api based configuration of components with custom
configuration errors.

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.configurer.register.factory_configurer;


import aermicioi.aedi.configurer.register.configuration_context_factory;
import aermicioi.aedi.configurer.register.context : ValueRegistrationContext;
import aermicioi.aedi.container.container;
import aermicioi.aedi.container.proxy_container;
import aermicioi.aedi.exception;
import aermicioi.aedi.factory;
import aermicioi.aedi.storage.allocator_aware;
import aermicioi.aedi.storage.decorator;
import aermicioi.aedi.storage.locator;
import aermicioi.aedi.storage.storage;
import aermicioi.aedi.util.traits;
public import aermicioi.aedi.factory.reference : lref, anonymous;

import std.meta;
import std.traits;
import std.algorithm;
import std.range;

@safe:

/**
Construct component using args.

Constructs component using args, that are passed to function.
The function will attempt to find at least one construct that
can accept passed argument list. If it fails, compiler will
produce error, with respective problems.
The argument list can contain beside simple values, references
to other components in locator. Arguments that are references to other components
won't be type checked.

Params:
	factory = the factory which will call constructor with passed arguments.
	args = a list of arguments that will be passed to constructor.

Returns:
	Z.
**/

Z construct(Z : InstanceFactoryAware!T, T, Args...)(Z factory, auto ref Args args) {
    factory.setInstanceFactory(constructorBasedFactory!T(args));

    return factory;
}

/**
Invoke T's method to create component of type X.

Configures component's factory to call method of factoryMethod with args,
in order to create component of type X.
In case when method is not a static member, the function requires to
pass a instance of factoryMethod or a reference to it.
The algorithm will check for args compatiblity with parameters of
factory method. No type check is done for arguments that are references
at compile time.

Params:
    factory = component's factory that is configured to call factoryMethod methods to spawn component
    factoryMethod = instance of factory method that will be used to instantiate component
    args = a list of arguments passed to factory method
    T = type of factoryMethod
    method = the method that is called from T to instantiate component
    W = either LocatorReference or T
    X = the return type of T.method member
**/
Z factoryMethod(T, string method, Z : InstanceFactoryAware!X, X, W, Args...)(Z factory, auto ref W factoryMethod, auto ref Args args)
    if (
        isNonStaticMethodCompatible!(T, method, Args) &&
        (is(W : T) || is(W : RuntimeReference))
    ) {
    factory.setInstanceFactory(factoryMethodBasedFactory!(T, method)(factoryMethod, args));

    return factory;
}

/**
ditto
**/
Z factoryMethod(T, string method, Z : InstanceFactoryAware!X, X, Args...)(Z factory, auto ref Args args)
    if (
        isStaticMethodCompatible!(T, method, Args)
    ) {

    factory.setInstanceFactory(factoryMethodBasedFactory!(T, method)(args));
    return factory;
}

/**
ditto
**/
Z factoryMethod(Dg, Z : InstanceFactoryAware!X, X, Args...)(Z factory, Dg func, auto ref Args args)
    if (isSomeFunction!Dg && is(ReturnType!Dg == X)) {

    factory.setInstanceFactory(functionInstanceFactory(func, args));
    return factory;
}

/**
Invoke component's method with supplied args.

Configures component's factory to call specified method with passed args.
The function will check if the arguments passed to it are compatible with at
least one method from possible overload set.
The args list can contain references to other objects in locator as well, though
no type compatibility checks will be performed at compile time.

Params:
	factory = the factory which will be configured to invoke method.
	args = the arguments that will be used to invoke method on the new object.

Returns:
	Z.
**/
Z set(string property, Z : PropertyConfigurersAware!T, T, Args...)(Z factory, auto ref Args args)
    if (!isField!(T, property)) {
    mixin assertObjectMethodCompatible!(T, property, Args);

    factory.addPropertyConfigurer(methodConfigurer!(property, T)(args));

    return factory;
}

/**
Set component's public field to passed arg.

Configures component's factory to set specified field to passed arg.
The function will check if passed argument is type compatible with specified field.
The argument can be a reference as well. In case of argument being reference to another component
in container, no type compatiblity checking will be done.

Params
    factory = the factory which will be configured to set property.
	arg = the value of property to be set, or reference to component in container.

Returns:
	Z.
**/
Z set(string property, Z : PropertyConfigurersAware!T, T, Arg)(Z factory, auto ref Arg arg)
    if (isField!(T, property)) {
    mixin assertFieldCompatible!(T, property, Arg);

    factory.addPropertyConfigurer(fieldConfigurer!(property, T)(arg));

    return factory;
}

/**
Construct component using a delegate.

Constructs component using a delegate, and a list of arguments passed to delegate.

Params:
	factory = the factory which will use delegate to construct component.
	dg = the delegate that is responsible for creating component, given a list of arguments.
	args = the arguments that will be used by delegate to construct component.

Returns:
	Z.
**/
Z callback(Z : InstanceFactoryAware!T, T, Args...)(Z factory, T delegate(RCIAllocator, Locator!(), Args) dg, auto ref Args args) {
    factory.setInstanceFactory(callbackFactory!T(dg, args));

    return factory;
}

/**
ditto
**/
Z callback(Z : InstanceFactoryAware!T, T, Args...)(Z factory, T function(RCIAllocator, Locator!(), Args) dg, auto ref Args args) {
    factory.setInstanceFactory(callbackFactory!T(dg, args));

    return factory;
}

/**
Call dg on a component that is in configuration phase.

Call dg on component to perform some modifications, using args as input.

Params:
    factory = factory which will call dg with args.
    dg = delegate that will perform some modifications on component using passed args.
    args = a list of arguments passed to dg.

Returns:
    Z
**/
Z callback(Z : PropertyConfigurersAware!T, T, Args...)(Z factory, void delegate(Locator!(), T, Args) dg, auto ref Args args) {
    factory.addPropertyConfigurer(callbackConfigurer!T(dg, args));

    return factory;
}

/**
ditto
**/
Z callback(Z : PropertyConfigurersAware!T, T, Args...)(Z factory, void function(Locator!(), T, Args) dg, auto ref Args args) {
    factory.addPropertyConfigurer(callbackConfigurer!T(dg, args));

    return factory;
}

/**
ditto
**/
Z callback(Z : PropertyConfigurersAware!T, T, Args...)(Z factory, void delegate(Locator!(), ref T, Args) dg, auto ref Args args) {
    factory.addPropertyConfigurer(callbackConfigurer!T(dg, args));

    return factory;
}

/**
ditto
**/
Z callback(Z : PropertyConfigurersAware!T, T, Args...)(Z factory, void function(Locator!(), ref T, Args) dg, auto ref Args args) {
    factory.addPropertyConfigurer(callbackConfigurer!T(dg, args));

    return factory;
}

/**
Autowire a constructor, field or a method.

Autowire a constructor, field or a method.
To autowire a constructor simply call autowire with no template arguments.
For autowiring a field or a method, call autowire with the name of field or argument as first template argument.
Autowiring process will attempt to find all parameters by their name first, and by type afterwards, in order to
inject the dependencies into the component. Failing to find a suitable candidate for injection, will fail in an exception
during container instantiation.
Note: There are no guarantees as of which method or constructor from an overload set will be selected
as such it is advised to use autowire only on members that are not part of an overload set.

Params:
    T = the component type
    member = field or method of component T
    factory = ConfigurationContextFactory where to inject the constructor or method configurer

Returns:
    Z
**/
Z autowire(Z : InstanceFactoryAware!T, T)(Z factory)
    if (getMembersWithProtection!(T, "__ctor", "public").length > 0) {

    alias ctor = getMembersWithProtection!(T, "__ctor", "public")[0];

    return factory.construct(makeFunctionParameterReferences!ctor.expand);
}

/**
ditto
**/
Z autowire(string member, Z : PropertyConfigurersAware!T, T)(Z factory)
    if (getMembersWithProtection!(T, member, "public").length > 0) {
    alias method = getMembersWithProtection!(T, member, "public")[0];

    auto arguments = makeFunctionParameterReferences!method;

    static if (arguments.length == 1) {
        arguments[0] = __traits(identifier, method).lref.alternate(arguments[0]);
    }

    return factory.set!(member)(arguments.expand);
}

/**
ditto
**/
Z autowire(string member, Z : PropertyConfigurersAware!T, T)(Z factory)
    if (isField!(T, member)) {

    alias field = getMember!(T, member);
    RuntimeReference reference = __traits(identifier, field).lref.alternate(lref!(typeof(field)));

    return factory.set!(member)(reference);
}

/**
Instantiates a component using a value as basis.

Instantiates a component using a value as basis.
As a consequence, any reference based type will
point to same content when it is instantiated
multiple times.

Params:
    T = the component type
    factory = ConfigurationContextFactory where to inject the constructor or method configurer
    value = default value used to instantiate component
**/
Z value(Z : InstanceFactoryAware!T, T)(Z factory, auto ref T value) {
    factory.setInstanceFactory(new ValueInstanceFactory!T(value));

    return factory;
}

/**
Instantiates a component using as basis some third party factory.

Params:
    T = the type of component that is to be configured
    factory = factory that uses the parent factory for component instantiation
    delegated = the factory used by factory to instantiate an object.
**/
Z parent(Z : InstanceFactoryAware!T, T, X : Factory!W, W : T)(Z factory, X delegated) {
    factory.setInstanceFactory(new DelegatingInstanceFactory!(T, W)(delegated));

    return factory;
}
/**
Tag constructed component with some information.

Tag constructed component with some information.
Description

Params:
	factory = factory for constructed component
	tag = tag with which to tag factory.

Returns:
	factory
**/
W tag(Z, W : ConfigurableFactory!(T, Policies), T, Policies...)(W factory, auto ref Z tag) {
    static if (ContainsPolicy!(WrapperStorePolicy, Policies)) {
        Taggable!Z taggable;

        import std.range : chain, only;
        import aermicioi.aedi.util.range : filterByInterface;

        auto candidates = factory.wrapper
            .decorators!ObjectFactory
            .filterByInterface!(Taggable!Z)
            .chain(factory.decorated.only.filterByInterface!(Taggable!Z));

        if (candidates.empty) {
            auto taggableDecorator = new TaggableFactoryDecorator!(Object, Z);
            taggableDecorator.decorated = factory.wrapper;
            factory.wrapper = taggableDecorator;

            taggable = taggableDecorator;
            factory.storage.set(factory.wrapper, factory.identity);
        } else {
            taggable = candidates.front;
        }

        taggable.tag(tag);

        return factory;
    } else {
        static assert(false, "Cannot tag component, expected for configurable factory to implement " ~ fullyQualifiedName!WrapperStorePolicy);
    }
}

/**
Register a description for component

Params:
    factory = configuration context for component
    instance = configuration context for comopnent that is already insantiated
    title = title for component
    description = description for component

Returns:
    Configuration context
**/
W describe(W : ConfigurableFactory!(T, Policies), T, Policies...)(W factory, string title, string description = null) {
    static if (ContainsPolicy!(StoragePolicy, Policies)) {
        import aermicioi.aedi.container.describing_container : IdentityDescriber;

        IdentityDescriber!() describer = factory.locator.locate!(IdentityDescriber!());
        describer.register(factory.identity, title, description);

        return factory;
    } else {
        static assert(false, "Cannot describe component, expected for configurable factory to implement " ~ fullyQualifiedName!StoragePolicy);
    }
}

/**
ditto
**/
ValueRegistrationContext.ValueContext describe(ValueRegistrationContext.ValueContext instance, string title, string description = null) {
    import aermicioi.aedi.container.describing_container : IdentityDescriber;

    IdentityDescriber!() describer = instance.locator.locate!(IdentityDescriber!());
    describer.register(instance.identity, title, description);

    return instance;
}

/**
Run annotation processor over a component and scan it for configuration or new components.

Params:
    factory = component factory to run scanning over

Returns:
    factory
**/
W scan(W : GenericFactory!T, T)(W factory) {
    import aermicioi.aedi.configurer.annotation.component_scan : ConfiguratorPolicyImpl;
    ConfiguratorPolicyImpl.configure(factory, factory.locator);

    return factory;
}

/**
ditto
**/
W scan(W : ConfigurableContainer!(T, Policies), T, Policies...)(W factory) {
    static if (ContainsPolicy!(StoragePolicy, Policies)) {
        import aermicioi.aedi.configurer.annotation.component_scan : ContainerAdderImpl, ConfiguratorPolicyImpl;
        ContainerAdderImpl!().scan!T(factory.locator, factory.storage);
        ConfiguratorPolicyImpl.configure(factory, factory.locator);

        return factory;
    } else {
        static assert(false, "Cannot scan component, expected for configurable factory to implement " ~ fullyQualifiedName!StoragePolicy);
    }
}

/**
Mark constructed object to be provided through a proxy instead of directly doing so.
Object will be proxied only in case when the storage where it is stored support
storing of proxy object factories.

Params:
	factory = factory for constructed object

Returns:
	factory
**/
W proxy(W : ConfigurableFactory!(T, Policies), T, Policies...)(W factory) @trusted {
    import aermicioi.aedi.factory.proxy_factory : ProxyFactory, ProxyObjectFactory;
    import aermicioi.aedi.container.proxy_container : ProxyContainer;
    import aermicioi.aedi.util.range : filterByInterface;

    auto candidates = factory.storage.decorators!Container.filterByInterface!ProxyContainer;

    if (!candidates.empty) {
        candidates.front.set(
            new ProxyObjectWrappingFactory!T(
                new ProxyFactory!T(factory.identity, candidates.front.decorated)
            ),
            factory.identity,
        );
    }

    return factory;
}

/**
Use delegate T for destruction of component.

Params:
    factory = component factory which will use delegate to destroy component
    dg = destruction delegate
    args = optional arguments to delegate

Returns:
    factory
**/
Z destructor(Z : InstanceDestructorAware!T, T, Args...)(
    Z factory,
    void delegate(RCIAllocator, ref T, Args) dg,
    Args args
) {
    factory.setInstanceDestructor(callbackInstanceDestructor!T(dg, args));

    return factory;
}

/**
Use method of destructor to destroy component.

Use method of destructor to destroy component. By convention it is assumed that first argument is destroyed compnent followed by
optional arguments.

Params:
    method = destructor's method used to destroy component
    factory = component factory
    destructor = actual destructor that will destroy object
    args = arguments passed to destructor
Returns:
    factory
**/
Z destructor(string method, X, Z : InstanceDestructorAware!T, T, Args...)(
    Z factory,
    X destructor,
    Args args
) {
    factory.setInstanceDestructor(factoryMethodInstanceDestructor!(T, method, X, Args)(destructor, args));

    return factory;
}

/**
ditto
**/
Z destructor(string method, X, Z : InstanceDestructorAware!T, T, Args...)(
    Z factory,
    Args args
) {
    factory.setInstanceDestructor(factoryMethodInstanceDestructor!(T, method, X, Args)(args));

    return factory;
}