Mapeate.Mapas = function(mapeate, entradas){

    const self = this, 
          mapas = {}, 
          cache = {};
    let iniciado = false, 
        sobreescribir_por_defecto;

    let selector = this.selector;

    const constructor = () => {

        mapeate.print("info", "mapeate_mapas_construyendose");

        selector = self.selector = new Mapeate.Mapas.Selector(mapeate, entradas);

        mapeate.print("ok", "mapeate_mapas_construido");
    
    };

    this.iniciar = callback => {

        const terminar = estado => typeof callback == "function" && callback(estado);

        mapeate.print("info", "mapeate_mapas_iniciando");

        if(iniciado){
            mapeate.print("warn", "mapeate_mapas_ya_iniciado");
            terminar(false);
            return false;
        };
        iniciado = true;

        sobreescribir_por_defecto = mapeate.configuracion(["mapas_sobreescribir", "sobreescribir"]);

        mapeate.ejecutar_array_asincrono([
            "archivos_de_mapas_por_defecto", 
            "archivos_de_mapas", 
            "mapas_por_defecto", 
            "mapas"
        ], (clave, callback) => self.cargar(mapeate.configuracion(clave), true, callback), () => {
            selector.iniciar(() => {
                mapeate.print("ok", "mapeate_mapas_iniciado");
                terminar(true);
            });
        });

        return true;
    };

    const cargar = (entradas, sobreescribir, callback, i) => {

        if(!entradas || i >= entradas.length){
            typeof callback == "function" && callback();
            return;
        };

        const terminar = () => cargar(entradas, sobreescribir, callback, i + 1);

        if(!entradas[i]){
            terminar();
            return;
        };

        if(typeof entradas[i] == "object"){
            if(entradas[i] instanceof Array)
                cargar(entradas[i], sobreescribir, terminar, 0);
            else{
                for(const clave in entradas[i])
                    if(sobreescribir || mapas[clave] === undefined)
                        mapas[clave] = entradas[i][clave];
                terminar();
            };
        }else if(typeof entradas[i] == "string"){

            const procesar = string => mapeate.procesar_json(
                string, 
                json => cargar(json instanceof Array ? json : [json], sobreescribir, terminar, 0), 
                terminar
            );

            if(/^(\{(.|[\n\r])*\}|\[(.|[\r\n])*\])$/.test(entradas[i].trim()))
                procesar(entradas[i]);
            else 
                mapeate.leer_archivo(entradas[i], procesar);

        }else 
            terminar();

    };

    this.cargar = (entradas, sobreescribir, callback) => cargar(
        typeof entradas == "object" && entradas instanceof Array ? entradas : [entradas], 
        typeof sobreescribir == "boolean" ? sobreescribir : sobreescribir_por_defecto, 
        callback, 
        0
    );

    this.coger = claves => {

        const l = (claves = mapeate.coger_array_de_strings(claves)).length;

        for(let i = 0; i < l; i ++)
            if(mapas[claves[i]] !== undefined)
                return mapas[claves[i]];
        return claves[0] || null;
    };

    this.coger_todos = () => ({...mapas});

    this.cache = (clave, datos) => datos === undefined ? cache[clave] : (cache[clave] = datos);
 
    constructor();

};