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

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

    getRootContainer() {
        return this._root;
    }

    getParent() {
        return this._parent;
    }

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

        if (d.isInstanceCreated())
            return d.getInstance() as T;

        const context = new ActivationContext(this, this._services);

        try {
            return d.activate(context, name) as T;
        } catch (error) {
            throw new ActivationError(name, context.getStack(), error);
        }
    }

    register(nameOrCollection, service?) {
        if (arguments.length === 1) {
            const data = nameOrCollection;
            for (const name in data)
                this.register(name, data[name]);
        } else {
            if (!(isDescriptor(service)))
                service = new ValueDescriptor(service);
            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") {
            const resolver = await this._resolver.createResolver(config, opts);
            const data = await this._resolver.loadModule(config);
            return this._configure(data, { resolver });
        } else {
            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: ServiceMap = {};

        resolver.beginBatch();

        async function parse(k) {
            services[k] = await this._parse(data[k], resolver);
        }

        const batch = Object.keys(data).map(parse);

        resolver.completeBatch();

        await Promise.all(batch);

        this.register(services);
    }

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

        if (isDependencyRegistration(registration)) {

            return new ReferenceDescriptor(
                registration.$dependency,
                registration.lazy,
                registration.optional,
                registration["default"],
                registration.services && this._parseObject(registration.services, resolver)
            );

        } else if (isValueRegistration(registration)) {

            return !registration.parse ?
                new ValueDescriptor(registration.$value) :
                new AggregateDescriptor(this._parse(registration.$value, resolver));

        } else if (registration.$type || registration.$factory) {
            return this._parseService(registration, resolver);
        } else if (registration instanceof Array) {
            return this._parseArray(registration, resolver);
        }

        return this._parseObject(registration, resolver);
    }

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

        function guard<T>(fn: () => PromiseLike<T>) {
            return fn();
        }

        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._parseObject(data.services, resolver);

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

        if (data.params)
            opts.params = 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);
    }

    _parseObject(data: any, typemap) {
        if (data.constructor &&
            data.constructor.prototype !== Object.prototype)
            return new ValueDescriptor(data);

        const o = {};

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

        return o;
    }

    _parseArray(data, typemap) {
        if (data.constructor &&
            data.constructor.prototype !== Array.prototype)
            return new ValueDescriptor(data);

        return data.map(x => this._parse(x, typemap));
    }
}