import { isFunction, isNull, isNotNull, isArray, each, isWidget, extend, init, isEmpty, remove } from "./2.base";
import { OB } from "./3.ob";
import { Widget } from "./4.widget"

let moduleInjection = {}, moduleInjectionMap = {
    components: {},
    constants: {},
    stores: {},
    services: {},
    models: {},
    providers: {}
};

export function module(xtype, cls) {
    if (moduleInjection[xtype] != null) {
        _global.console && console.error("module： [" + xtype + "] 已经注册过了");
    } else {
        if (isFunction(cls)) {
            cls = cls();
        }
        for (const k in moduleInjectionMap) {
            if (cls[k]) {
                for (const key in cls[k]) {
                    if (!moduleInjectionMap[k]) {
                        continue;
                    }
                    if (!moduleInjectionMap[k][key]) {
                        moduleInjectionMap[k][key] = [];
                    }
                    moduleInjectionMap[k][key].push({
                        version: cls[k][key],
                        moduleId: xtype
                    });
                }
            }
        }
        moduleInjection[xtype] = cls;
    }

    return () => Modules.getModule(xtype);
}

let constantInjection = {};
export function constant(xtype, cls) {
    if (constantInjection[xtype] != null) {
        _global.console && console.error("constant: [" + xtype + "]已经注册过了");
    } else {
        constantInjection[xtype] = cls;
    }

    return () => Constants.getConstant(xtype);
}

let modelInjection = {};
export function model(xtype, cls) {
    if (modelInjection[xtype] != null) {
        _global.console && console.error("model: [" + xtype + "] 已经注册过了");
    } else {
        modelInjection[xtype] = cls;
    }

    return (config) => Models.getModel(xtype, config);
}

let storeInjection = {};
export function store(xtype, cls) {
    if (storeInjection[xtype] != null) {
        _global.console && console.error("store: [" + xtype + "] 已经注册过了");
    } else {
        storeInjection[xtype] = cls;
    }

    return (config) => Stores.getStore(xtype, config);
}

let serviceInjection = {};
export function service(xtype, cls) {
    if (serviceInjection[xtype] != null) {
        _global.console && console.error("service: [" + xtype + "] 已经注册过了");
    }

    serviceInjection[xtype] = cls;

    return (config) => Services.getService(xtype, config);
}

let providerInjection = {};
export function provider(xtype, cls) {
    if (providerInjection[xtype] != null) {
        _global.console && console.error("provider: [" + xtype + "] 已经注册过了");
    } else {
        providerInjection[xtype] = cls;
    }

    return (config) => Providers.getProvider(xtype, config);
}

let configFunctions = OB.configFunctions = {};
const runConfigFunction = function (type, configFn) {
    if (!type || !configFunctions[type]) {
        return false;
    }

    let queue = [];
    if (configFn) {
        queue = configFunctions[type].filter((conf) => conf.fn === configFn);
        configFunctions[type] = configFunctions[type].filter((conf) => conf.fn !== configFn);
    } else {
        queue = configFunctions[type];
        delete configFunctions[type];
    }

    const dependencies = Providers.getProvider("bi.provider.system").getDependencies();
    const modules = moduleInjectionMap.components[type]
        || moduleInjectionMap.constants[type]
        || moduleInjectionMap.services[type]
        || moduleInjectionMap.stores[type]
        || moduleInjectionMap.models[type]
        || moduleInjectionMap.providers[type];
    for (let i = 0; i < queue.length; i++) {
        const conf = queue[i];
        const version = conf.opt.version;
        const fn = conf.fn;
        if (modules && version) {
            let findVersion = false;
            let module;
            for (let j = 0; j < modules.length; j++) {
                module = modules[j];
                if (module && dependencies[module.moduleId] && module.version === version) {
                    const minVersion = dependencies[module.moduleId].minVersion,
                        maxVersion = dependencies[module.moduleId].maxVersion;
                    if (minVersion && (moduleInjection[module.moduleId].version || version) < minVersion) {
                        findVersion = true;
                        break;
                    }
                    if (maxVersion && (moduleInjection[module.moduleId].version || version) > maxVersion) {
                        findVersion = true;
                        break;
                    }
                }
            }
            if (findVersion === true) {
                _global.console && console.error("moduleId: [" + module.moduleId + "] 接口: [" + type + "] 接口版本: [" + version + "] 已过期，版本要求为：", dependencies[module.moduleId], "=>", moduleInjection[module.moduleId]);
                continue;
            }
        }
        if (constantInjection[type]) {
            constantInjection[type] = fn(constantInjection[type]);
            continue;
        }
        if (providerInjection[type]) {
            if (!providers[type]) {
                providers[type] = new providerInjection[type]();
            }
            if (providerInstance[type]) {
                delete providerInstance[type];
            }
            fn(providers[type]);
            continue;
        }
        BI.Plugin.configWidget(type, fn, conf.opt);
    }
};

export function config(type, configFn, opt) {
    if (isFunction(type)) {
        opt = configFn;
        configFn = type;
        type = "bi.provider.system";
    }
    opt = opt || {};

    // 系统配置直接执行
    if ("bi.provider.system" === type) {
        if (!providers[type]) {
            providers[type] = new providerInjection[type]();
        }
        // 如果config被重新配置的话，需要删除掉之前的实例
        if (providerInstance[type]) {
            delete providerInstance[type];
        }
        return configFn(providers[type]);
    }

    if (!configFunctions[type]) {
        configFunctions[type] = [];
    }
    configFunctions[type].push({
        fn: configFn,
        opt: opt
    });

    if (opt.immediately) {
        return runConfigFunction(type, configFn);
    }
}

export function getReference(type, fn) {
    return BI.Plugin.registerObject(type, fn);
}

let actions = {};
let globalAction = [];
export function action(type, actionFn) {
    if (isFunction(type)) {
        globalAction.push(type);
        return () => {
            remove(globalAction, (idx) => globalAction.indexOf(actionFn) === idx);
        };
    }
    if (!actions[type]) {
        actions[type] = [];
    }
    actions[type].push(actionFn);
    return () => {
        remove(actions[type], (idx) => actions[type].indexOf(actionFn) === idx);
        if (actions[type].length === 0) {
            delete actions[type];
        }
    };
}

let points = {};
export function point(type, action, pointFn, after) {
    if (!points[type]) {
        points[type] = {};
    }
    if (!points[type][action]) {
        points[type][action] = {};
    }
    if (!points[type][action][after ? "after" : "before"]) {
        points[type][action][after ? "after" : "before"] = [];
    }
    points[type][action][after ? "after" : "before"].push(pointFn);
}

export const Modules = {
    getModule: function (type) {
        if (!moduleInjection[type]) {
            _global.console && console.error("module: [" + type + "] 未定义");
        }
        return moduleInjection[type];
    },
    getAllModules: function () {
        return moduleInjection;
    }
}

export const Constants = {
    getConstant: function (type) {
        if (isNull(constantInjection[type])) {
            _global.console && console.error("constant: [" + type + "] 未定义");
        }
        runConfigFunction(type);
        return isFunction(constantInjection[type]) ? constantInjection[type]() : constantInjection[type];
    }
}

const callPoint = function (inst, types) {
    types = isArray(types) ? types : [types];
    each(types, (idx, type) => {
        if (points[type]) {
            for (const action in points[type]) {
                let bfns = points[type][action].before;
                if (bfns) {
                    BI.aspect.before(inst, action, function (bfns) {
                        return function () {
                            for (let i = 0, len = bfns.length; i < len; i++) {
                                try {
                                    bfns[i].apply(inst, arguments);
                                } catch (e) {
                                    _global.console && console.error(e);
                                }
                            }
                        };
                    }(bfns));
                }
                let afns = points[type][action].after;
                if (afns) {
                    BI.aspect.after(inst, action, function (afns) {
                        return function () {
                            for (let i = 0, len = afns.length; i < len; i++) {
                                try {
                                    afns[i].apply(inst, arguments);
                                } catch (e) {
                                    _global.console && console.error(e);
                                }
                            }
                        };
                    }(afns));
                }
            }
        }
    });
};

export const Models = {
    getModel: function (type, config) {
        if (!modelInjection[type]) {
            _global.console && console.error("model: [" + type + "] 未定义");
        }
        runConfigFunction(type);
        var inst = new modelInjection[type](config);
        inst._constructor && inst._constructor(config);
        inst.mixins && callPoint(inst, inst.mixins);
        callPoint(inst, type);
        return inst;
    }
}

let stores = {};
export const Stores = {
    getStore: function (type, config) {
        if (!storeInjection[type]) {
            _global.console && console.error("store: [" + type + "] 未定义");
        }
        if (stores[type]) {
            return stores[type];
        }
        const inst = stores[type] = new storeInjection[type](config);
        inst._constructor && inst._constructor(config, function () {
            delete stores[type];
        });
        callPoint(inst, type);
        return inst;
    }
}

let services = {};
export const Services = {
    getService: (type, config) => {
        if (!serviceInjection[type]) {
            _global.console && console.error("service: [" + type + "] 未定义");
        }
        if (services[type]) {
            return services[type];
        }
        services[type] = new serviceInjection[type](config);
        callPoint(services[type], type);
        return services[type];
    }
}

let providers = {},
    providerInstance = {};
export const Providers = {
    getProvider: (type, config) => {
        if (!providerInjection[type]) {
            _global.console && console.error("provider: [" + type + "] 未定义");
        }
        runConfigFunction(type);
        if (!providers[type]) {
            providers[type] = new providerInjection[type]();
        }
        if (!providerInstance[type] && providers[type].$get) {
            providerInstance[type] = new (providers[type].$get())(config);
        }
        return providerInstance[type];
    }
}

export const Actions = {
    runAction: function (type, event, config) {
        each(actions[type], (i, act) => {
            try {
                act(event, config);
            } catch (e) {
                _global.console && console.error(e);
            }
        });
    },
    runGlobalAction: function () {
        var args = [].slice.call(arguments);
        each(globalAction, (i, act) => {
            try {
                act.apply(null, args);
            } catch (e) {
                _global.console && console.error(e);
            }
        });
    }
}

let kv = {};
export function shortcut(xtype, cls) {
    if (kv[xtype] != null) {
        _global.console && console.error("组件： [" + xtype + "] 已经注册过了");
    }
    if (cls) {
        cls["xtype"] = xtype;
    }
    kv[xtype] = cls;
}

// 根据配置属性生成widget
const createRealWidget = function (config, context, lazy) {
    const cls = isFunction(config.type) ? config.type : kv[config.type];

    if (!cls) {
        throw new Error("组件： [" + config.type + "] 未定义");
    }
    let pushed = false;
    const widget = new cls();
    widget._context = Widget.context || context;
    if (!Widget.context && context) {
        pushed = true;
        Widget.pushContext(context);
    }
    callPoint(widget, config.type);
    widget._initProps(config);
    widget._initRoot();
    widget._constructed();
    // if (!lazy || config.element || config.root) {
    widget._lazyConstructor();
    // }
    pushed && Widget.popContext();
    return widget;
};

export function createWidget(item, options, context, lazy) {
    item || (item = {});
    if (isWidget(options)) {
        context = options;
        options = {};
    } else {
        options || (options = {});
    }

    var el, w;
    if (item.type || options.type) {
        el = extend({}, options, item);
    } else if (item.el && (item.el.type || options.type)) {
        el = extend({}, options, item.el);
    }

    if (el) {
        var elType = (el.type && el.type.xtype) || el.type;
        runConfigFunction(elType);
    }

    // 先把准备环境准备好
    init();

    if (isEmpty(item) && isEmpty(options)) {
        return createWidget({
            type: "bi.layout"
        });
    }
    if (isWidget(item)) {
        return item;
    }
    if (el) {
        w = BI.Plugin.getWidget(elType, el);
        var wType = (w.type && w.type.xtype) || w.type;
        if (wType === elType) {
            if (BI.Plugin.hasObject(elType)) {
                if (!w.listeners || isArray(w.listeners)) {
                    w.listeners = (w.listeners || []).concat([{
                        eventName: BI.Events.MOUNT,
                        action: () => {
                            BI.Plugin.getObject(elType, this);
                        }
                    }]);
                } else {
                    w.listeners[BI.Events.MOUNT] = [
                        () => {
                            BI.Plugin.getObject(elType, this);
                        }
                    ].concat(w.listeners[BI.Events.MOUNT] || []);
                }
            }
            return createRealWidget(w, context, lazy);
        }
        return createWidget(w, options, context, lazy);
    }
    if (isWidget(item.el)) {
        return item.el;
    }
    throw new Error("组件：无法根据item创建组件", item);
}

export function _lazyCreateWidget (item, options, context) {
    return createWidget(item, options, context, true);
}

export function createElement() {
    const widget = createWidget.apply(this, arguments);
    return widget.element;
}

export function getResource(type, config) {
    if (isNotNull(constantInjection[type])) {
        return Constants.getConstant(type);
    }
    if (modelInjection[type]) {
        return Models.getModel(type, config);
    }
    if (storeInjection[type]) {
        return Stores.getStore(type, config);
    }
    if (serviceInjection[type]) {
        return Services.getService(type, config);
    }
    if (providerInjection[type]) {
        return Providers.getProvider(type, config);
    }
    throw new Error("未知类型: [" + type + "] 未定义");
}