"use strict";

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

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

/**
 * @callback anp_i18n_settings_default_callback
 * @returns {void}
 */

/**
 * @class
 * @constructor
 * @param {!AnP} anp 
 * @param {?(Object.<string, any|null>|Array.<any|null>)} inputs 
 * @returns {void}
 * @access public
 */
export const I18NManager = (function(){

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

        /** @type {I18NManager} */
        const self = this, 
              /** @type {Object.<string, any|null>} */
              sentences = {};
        /** @type {boolean} */
        let started = false, 
            /** @type {string} */
            default_language = "english", 
            /** @type {string} */
            selected_language = "english";

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

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

            /** @type {!anp_start_callback} */
            const end = ok => {
                Utils.execute(callback, ok);
                return ok;
            };

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

            Utils.execute_items([
                "default_i18n_files", "default_i18n", "i18n_files", "i18n"
            ], (key, next) => {
                self.add(anp.settings.get(key), next, true);
            }, () => {
                end(true);
            });

            return true;
        };

        /**
         * @param {!(string|Object.<string, any|null>|Array.<any|null>)} inputs 
         * @param {?anp_i18n_settings_default_callback} [callback = null] 
         * @param {!boolean} [overwrite = false] 
         * @returns {void}
         * @access public
         */
        this.add = (inputs, callback = null, overwrite = false) => {
            anp.request.load_json(inputs, (data, subcallback) => {
                for(const language in data)
                    if(Check.is_dictionary(data[language])){
                        sentences[language] || (sentences[language] = {});
                        for(const key in data[language])
                            !Check.is_key_mark(key) && 
                            (overwrite || sentences[language][key] === undefined) && 
                            (sentences[language][key] = data[language][key]);
                    };
                Utils.execute(subcallback);
            }, callback);
        };

        /**
         * @param {!(string|Array.<string>)} texts 
         * @param {?(string|Array.<string>)} languages 
         * @returns {string|Array.<string>|null}
         * @access private
         */
        const get_sentence = (texts, languages) => {

            /** @type {Array.<string>} */
            const keys = Utils.get_keys(texts);

            if(keys.length){

                /** @type {number} */
                const l = (languages = Utils.get_keys(Utils.get_keys(languages).concat(
                    [selected_language, default_language], 
                    Object.keys(sentences)
                ))).length;

                for(let i = 0; i < l; i ++)
                    if(sentences[languages[i]])
                        for(let j = 0, m = keys.length; j < m; j ++)
                            if(sentences[languages[i]][keys[j]] !== undefined)
                                return sentences[languages[i]][keys[j]];
            };
            return Utils.get_strings(texts)[0];
        };

        /**
         * @param {!(string|Array.<string>)} texts 
         * @param {?(Object.<string, any|null>|Array.<any|null>)} [inputs = null] 
         * @param {?(string|Array.<string>)} [languages = null] 
         * @returns {string|null}
         * @access public
         */
        this.get = (texts, inputs = null, languages = null) => {

            /** @type {string|Array.<string>|null} */
            const fragments = get_sentence(texts, languages), 
                  /** @type {string|null} */
                  sentence = Check.is_array(fragments) ? fragments.join("") : fragments;

            return inputs ? Utils.string_variables(sentence, inputs) : sentence;
        };

        constructor();

    };

    /** @type {Object.<string, any|null>} */
    I18NManager.DEFAULT_SETTINGS = {};

    return I18NManager;
})()