"use strict";

import {Check} from "../Utils/Checks.ecma.js";
import {Common} from "../Utils/Common.ecma.js";

/**
 * @typedef {import("../Application/AnP.ecma.js").AnP} AnP
 */

/**
 * @class ControllersManager
 * @constructor
 * @param {!AnP} anp 
 * @returns {void}
 * @access private
 * @static
 */
export const ControllersManager = (function(){

    /**
     * @callback continue_callback
     * @param {!boolean} ok 
     * @return {boolean}
     */

    /**
     * @callback action_callback
     * @param {...(any|null)} parameters 
     * @return {void}
     */

    /**
     * @constructs ControllersManager
     * @param {!AnP} anp 
     * @returns {void}
     * @access private
     * @static
     */
    const ControllersManager = function(anp){

        /** @type {ControllersManager} */
        const self = this, 
              /** @type {Object.<string, Object.<string, action_callback>>} */
              controllers = {};

        /**
         * @returns {void}
         * @access private
         */
        const constructor = () => {};

        /**
         * @param {?continue_callback} callback 
         * @returns {boolean}
         * @access public
         */
        this.update = (callback = null) => {

            Common.execute(callback);

        };

        /**
         * @param {?continue_callback} callback 
         * @returns {boolean}
         * @access public
         */
        this.reset = (callback = null) => {

            Common.clear_dictionary(controllers);

            self.update(callback);

        };

        /**
         * @param {?continue_callback} callback 
         * @returns {boolean}
         * @access public
         */
        this.start = (callback = null) => {

            /** @type {continue_callback} */
            const end = ok => Common.execute(callback, ok);

            if(started){
                end(false);
                return false;
            };
            started = true;

            self.update(end);

            return true;
        };

        /**
         * @param {?continue_callback} callback 
         * @returns {boolean}
         * @access public
         */
        this.close = (callback = null) => {

            /** @type {continue_callback} */
            const end = ok => Common.execute(callback, ok);

            if(!started){
                end(false);
                return false;
            };
            started = false;

            end(true);

            return true;
        };

        /**
         * 
         * @param {?any} inputs 
         * @param {!boolean} [overwrite = false] 
         * @param {?default_callback} [callback = null] 
         */
        this.add = (inputs, overwrite = false, callback = null) => {
            anp.files.load_json(inputs, data => {
                Object.entries(data).forEach(([key, Controller]) => {
                    if(!Controller || (!overwrite && controllers[key]))
                        return;
                    if(Check.is_function(Controller))
                        controllers[key] = new Controller(anp);
                    else if(Check.is_object(Controller))
                        controllers[key] = Controller;
                    else if(Check.is_string(Controller)){

                        /** @type {Object.<string, any|null>|Function|null} */
                        const Model = anp.models.get(Controller);

                        if(Check.is_object(Model))
                            controllers[key] = Model;
                        else if(Check.is_function(Model))
                            controllers[key] = new Model(anp);

                    };
                });
                Common.execute(callback);
            }, true);
        };

        this.execute = (name, action, ...parameters) => {};

        constructor();

    };

    return ControllersManager;

})();