/**
 * This module contains instance factory facilities
 *
 * Authors:
 *  Mike Bierlee, m.bierlee@lostmoment.com
 * Copyright: 2014-2022 Mike Bierlee
 * License:
 *  This software is licensed under the terms of the MIT license.
 *  The full terms of the license can be found in the LICENSE file.
 */

module poodinis.factory;

import poodinis.container : DependencyContainer;
import poodinis.imports : createImportsString;

import std.typecons : Flag;
import std.exception : enforce;
import std.traits : Parameters, isBuiltinType, fullyQualifiedName;
import std.string : format;

debug
{
    import std.stdio : writeln;
}

alias CreatesSingleton = Flag!"CreatesSingleton";
alias InstanceFactoryMethod = Object delegate();
alias InstanceEventHandler = void delegate(Object instance);

class InstanceCreationException : Exception
{
    this(string message, string file = __FILE__, size_t line = __LINE__)
    {
        super(message, file, line);
    }
}

struct InstanceFactoryParameters
{
    TypeInfo_Class instanceType;
    CreatesSingleton createsSingleton = CreatesSingleton.yes;
    Object existingInstance;
    InstanceFactoryMethod factoryMethod;
}

class InstanceFactory
{
    private Object instance = null;
    private InstanceFactoryParameters _factoryParameters;
    private InstanceEventHandler _constructionHandler;

    this()
    {
        factoryParameters = InstanceFactoryParameters();
    }

    public @property void factoryParameters(InstanceFactoryParameters factoryParameters)
    {
        if (factoryParameters.factoryMethod is null)
        {
            factoryParameters.factoryMethod = &this.createInstance;
        }

        if (factoryParameters.existingInstance !is null)
        {
            factoryParameters.createsSingleton = CreatesSingleton.yes;
            this.instance = factoryParameters.existingInstance;
        }

        _factoryParameters = factoryParameters;
    }

    public @property InstanceFactoryParameters factoryParameters()
    {
        return _factoryParameters;
    }

    public Object getInstance()
    {
        if (_factoryParameters.createsSingleton && instance !is null)
        {
            debug (poodinisVerbose)
            {
                printDebugUseExistingInstance();
            }

            return instance;
        }

        debug (poodinisVerbose)
        {
            printDebugCreateNewInstance();
        }

        instance = _factoryParameters.factoryMethod();
        if (_constructionHandler !is null)
        {
            _constructionHandler(instance);
        }

        return instance;
    }

    void onConstructed(InstanceEventHandler handler)
    {
        _constructionHandler = handler;
    }

    private void printDebugUseExistingInstance()
    {
        debug
        {
            if (_factoryParameters.instanceType !is null)
            {
                writeln(format("DEBUG: Existing instance returned of type %s",
                        _factoryParameters.instanceType.toString()));
            }
            else
            {
                writeln("DEBUG: Existing instance returned from custom factory method");
            }
        }
    }

    private void printDebugCreateNewInstance()
    {
        debug
        {
            if (_factoryParameters.instanceType !is null)
            {
                writeln(format("DEBUG: Creating new instance of type %s",
                        _factoryParameters.instanceType.toString()));
            }
            else
            {
                writeln("DEBUG: Creating new instance from custom factory method");
            }
        }
    }

    protected Object createInstance()
    {
        enforce!InstanceCreationException(_factoryParameters.instanceType,
                "Instance type is not defined, cannot create instance without knowing its type.");
        return _factoryParameters.instanceType.create();
    }
}

class ConstructorInjectingInstanceFactory(InstanceType) : InstanceFactory
{
    private shared DependencyContainer container;
    private bool isBeingInjected = false;

    this(shared DependencyContainer container)
    {
        this.container = container;
    }

    private static string createArgumentList(Params...)()
    {
        string argumentList = "";
        foreach (param; Params)
        {
            if (argumentList.length > 0)
            {
                argumentList ~= ",";
            }

            argumentList ~= "container.resolve!(" ~ param.stringof ~ ")";
        }
        return argumentList;
    }

    private static string createImportList(Params...)()
    {
        string importList = "";
        foreach (param; Params)
        {
            importList ~= createImportsString!param;
        }
        return importList;
    }

    private static bool parametersAreValid(Params...)()
    {
        bool isValid = true;
        foreach (param; Params)
        {
            if (isBuiltinType!param || is(param == struct))
            {
                isValid = false;
                break;
            }
        }

        return isValid;
    }

    protected override Object createInstance()
    {
        enforce!InstanceCreationException(container,
                "A dependency container is not defined. Cannot perform constructor injection without one.");
        enforce!InstanceCreationException(!isBeingInjected,
                format("%s is already being created and injected; possible circular dependencies in constructors?",
                    InstanceType.stringof));

        Object instance = null;
        static if (__traits(compiles, __traits(getOverloads, InstanceType, `__ctor`)))
        {
            foreach (ctor; __traits(getOverloads, InstanceType, `__ctor`))
            {
                static if (parametersAreValid!(Parameters!ctor))
                {
                    isBeingInjected = true;
                    mixin(createImportsString!InstanceType ~ createImportList!(
                            Parameters!ctor) ~ `
                        instance = new ` ~ fullyQualifiedName!InstanceType ~ `(` ~ createArgumentList!(
                            Parameters!ctor) ~ `);
                    `);
                    isBeingInjected = false;
                    break;
                }
            }
        }

        if (instance is null)
        {
            instance = typeid(InstanceType).create();
        }

        enforce!InstanceCreationException(instance !is null,
                "Unable to create instance of type" ~ InstanceType.stringof
                ~ ", does it have injectable constructors?");

        return instance;
    }
}