import { ActivationContext } from "./ActivationContext";
import { ValueDescriptor } from "./ValueDescriptor";
import { ActivationError } from "./ActivationError";
import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration, DependencyRegistration, ValueRegistration } from "./interfaces";
import { AggregateDescriptor } from "./AggregateDescriptor";
import { isPrimitive, pmap } from "../safe";
import { ReferenceDescriptor } from "./ReferenceDescriptor";
import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
import { ModuleResolverBase } from "./ModuleResolverBase";
import format = require("../text/format");
import { TraceSource } from "../log/TraceSource";
import { RequireJsResolver } from "./RequireJsResolver";

const trace = TraceSource.get("@implab/core/di/ActivationContext");

export class Container {
    _services: ServiceMap;

    _cache: object;

    _cleanup: (() => void)[];

    _root: Container;

    _parent: Container;

    _resolver: ModuleResolverBase;

    constructor(parent?: Container) {
        this._parent = parent;
        this._services = parent ? Object.create(parent._services) : {};
        this._cache = {};
        this._cleanup = [];
        this._root = parent ? parent.getRootContainer() : this;
        this._services.container = new ValueDescriptor(this);
        this._resolver = new RequireJsResolver();
    }

    getRootContainer() {
        return this._root;
    }

    getParent() {
        return this._parent;
    }

    resolve(name: string, def?) {
        const d = this._services[name];
        if (d === undefined) {
            if (arguments.length > 1)
                return def;
            else
                throw new Error("Service '" + name + "' isn't found");
        }

        const context = new ActivationContext(this, this._services);
        try {
            return context.activate(d, name);
        } catch (error) {
            throw new ActivationError(name, context.getStack(), error);
        }
    }

    /**
     * @deprecated use resolve() method
     */
    getService(name: string, def?) {
        return this.resolve.apply(this, arguments);
    }

    register(nameOrCollection, service?) {
        if (arguments.length === 1) {
            const data = nameOrCollection;
            for (const name in data)
                this.register(name, data[name]);
        } else {
            if (!isDescriptor(service))
                throw new Error("The service parameter must be a descriptor");

            this._services[nameOrCollection] = service;
        }
        return this;
    }

    onDispose(callback) {
        if (!(callback instanceof Function))
            throw new Error("The callback must be a function");
        this._cleanup.push(callback);
    }

    dispose() {
        if (this._cleanup) {
            for (const f of this._cleanup)
                f();
            this._cleanup = null;
        }
    }

    /**
     * @param{String|Object} config
     *  The configuration of the contaier. Can be either a string or an object,
     *  if the configuration is an object it's treated as a collection of
     *  services which will be registed in the contaier.
     *
     * @param{Function} opts.contextRequire
     *  The function which will be used to load a configuration or types for services.
     *
     */
    async configure(config: string | object, opts?: object) {
        if (typeof (config) === "string") {
            trace.log(`load configuration '${config}'`);
            const resolver = await this._resolver.createResolver(config, opts);
            const data = await this._resolver.loadModule(config);
            return this._configure(data, { resolver });
        } else {
            trace.log(`json configuration`);
            return this._configure(config);
        }
    }

    createChildContainer() {
        return new Container(this);
    }

    has(id) {
        return id in this._cache;
    }

    get(id) {
        return this._cache[id];
    }

    store(id, value) {
        return (this._cache[id] = value);
    }

    async _configure(data: object, opts?: { resolver: ModuleResolverBase }) {
        const resolver = (opts && opts.resolver) || this._resolver;

        const services = await this._parseRegistrations(data, resolver);

        this.register(services);
    }

    async _parse(data: any, resolver: ModuleResolverBase) {
        if (isPrimitive(data) || isDescriptor(data))
            return data;

        if (isDependencyRegistration(data)) {
            return this._makeReferenceDescriptor(data, resolver);
        } else if (isValueRegistration(data)) {
            return this._makeValueDescriptor(data, resolver);
        } else if (data.$type || data.$factory) {
            return this._makeServiceDescriptor(data, resolver);
        } else if (data instanceof Array) {
            return this._parseArray(data, resolver);
        }

        return this._parseObject(data, resolver);
    }

    async _makeValueDescriptor(data: ValueRegistration, resolver: ModuleResolverBase) {
        return !data.parse ?
            new ValueDescriptor(data.$value) :
            new AggregateDescriptor(this._parse(data.$value, resolver));
    }

    async _makeReferenceDescriptor(registration: DependencyRegistration, resolver: ModuleResolverBase) {
        return new ReferenceDescriptor({
            name: registration.$dependency,
            lazy: registration.lazy,
            optional: registration.optional,
            default: registration.default,
            services: registration.services && await this._parseRegistrations(registration.services, resolver)
        });
    }

    async _makeServiceDescriptor(data: ServiceRegistration, resolver: ModuleResolverBase) {
        const opts: ServiceDescriptorParams = {
            owner: this
        };

        if (data.$type) {
            if (data.$type instanceof Function)
                opts.type = data.$type;
            else if (typeof data.$type === "string")
                opts.type = await resolver.resolve(data.$type);
            else
                throw new Error(format("Unsupported type specification: {0:json}", data.$type));
        } else {
            if (data.$factory instanceof Function)
                opts.factory = data.$factory;
            else if (typeof data.$factory === "string")
                opts.factory = await resolver.resolve(data.$factory);
            else
                throw new Error(format("Unsupported factory specification: {0:json}", data.$factory));
        }

        if (data.services)
            opts.services = await this._parseRegistrations(data.services, resolver);

        if (data.inject) {
            if (data.inject instanceof Array)
                opts.inject = await Promise.all(data.inject.map(x => this._parseObject(x, resolver)));
            else
                opts.inject = [await this._parseObject(data.inject, resolver)];
        }

        if (data.params)
            opts.params = await this._parse(data.params, resolver);

        if (data.activation) {
            if (typeof (data.activation) === "string") {
                switch (data.activation.toLowerCase()) {
                    case "singleton":
                        opts.activation = ActivationType.Singleton;
                        break;
                    case "container":
                        opts.activation = ActivationType.Container;
                        break;
                    case "hierarchy":
                        opts.activation = ActivationType.Hierarchy;
                        break;
                    case "context":
                        opts.activation = ActivationType.Context;
                        break;
                    case "call":
                        opts.activation = ActivationType.Call;
                        break;
                    default:
                        throw new Error("Unknown activation type: " +
                            data.activation);
                }
            } else {
                opts.activation = Number(data.activation);
            }
        }

        if (data.cleanup)
            opts.cleanup = data.cleanup;

        return new ServiceDescriptor(opts);
    }

    async _parseObject(data: object, resolver: ModuleResolverBase) {
        if (data.constructor &&
            data.constructor.prototype !== Object.prototype)
            return new ValueDescriptor(data);

        const o = {};

        for (const p in data)
            o[p] = await this._parse(data[p], resolver);

        // TODO: handle inline descriptors properly
        // const ex = {
        //     activate(ctx) {
        //         const value = ctx.activate(this.prop, "prop");
        //         // some code
        //     },

        //     // will be turned to ReferenceDescriptor
        //     prop: { $dependency: "depName" }
        // };

        return o;
    }

    async _parseArray(data: Array<any>, resolver: ModuleResolverBase) {
        if (data.constructor &&
            data.constructor.prototype !== Array.prototype)
            return new ValueDescriptor(data);

        return pmap(data, x => this._parse(x, resolver));
    }

    async _parseRegistrations(data: object, resolver: ModuleResolverBase) {
        if (data.constructor &&
            data.constructor.prototype !== Object.prototype)
            throw new Error("Registrations must be a simple object");

        const o: ServiceMap = {};

        for (const p of Object.keys(data)) {
            const v = await this._parse(data[p], resolver);
            o[p] = isDescriptor(v) ? v : new AggregateDescriptor(v);
        }

        return o;
    }
}