Mapeate.Vistas = function(mapeate, entradas){

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

    const constructor = () => {

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

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

    this.iniciar = callback => {

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

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

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

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

        mapeate.ejecutar_array_asincrono([
            "archivos_de_vistas_por_defecto", 
            "archivos_de_vistas"
        ], (clave, callback) => self.cargar(mapeate.configuracion(clave), true, callback), () => {
            mapeate.print("ok", "mapeate_vistas_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(typeof entradas[i] == "string" && (sobreescribir || vistas[clave] === undefined))
                        vistas[clave] = entradas[i];
                terminar();
            };
        }else if(typeof entradas[i] == "string"){
            if(!(entradas[i] = entradas[i].trim())){
                terminar();
                return;
            };

            if(/^(\/|[a-z0-9]{3,5}\:\/{2})[^\r\n]*$/i.test(entradas[i]))
                mapeate.leer_archivo(entradas[i], salida => cargar([salida], sobreescribir, terminar, 0));
            else{

                if(/^(\[(.|[\r|\n])*\]|\{(.|[\n\n])*\})$/.test(entradas[i]) && mapeate.procesar_json(
                    entradas[i], 
                    json => cargar(json instanceof Array ? json : [json], sobreescribir, terminar, 0), 
                    terminar
                ))
                    return;

                while(entradas[i].length){
                    
                    const matches = entradas[i].match(/<\!\-{2} *\[{2}([^\[\]]+)\]{2} *\-{2}>/);

                    if(!matches)
                        break;

                    const l = (entradas[i] = entradas[i].substring(matches.index + matches[0].length)).indexOf(matches[0]);

                    if(l == -1)
                        continue;
                    
                    if(sobreescribir || vistas[matches[1]] === undefined)
                        vistas[matches[1]] = entradas[i].substring(0, l);
                    entradas[i] = entradas[i].substring(l + matches[0].length);

                };

                terminar();

            };

        }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.crear_elementos_de_menu = (vista, opciones) => opciones.map(opcion => mapeate.string_variables(vistas[vista], {
        ...opcion, 
        nombre_texto : mapeate.i18n(opcion.nombre, opcion)
    })).join("");

    this.establecer = (posicion, vista, entradas, callback) => mapeate.precargar(posicion, posicion => {
        
        const precarga_hash = mapeate.hash();

        posicion.innerHTML = mapeate.string_variables(
            (vistas[vista] || vista) + '<div data-precarga="' + precarga_hash + '"></div>', 
            entradas
        );

        mapeate.precargar("div[data-precarga=" + precarga_hash + "]", elemento => {
            elemento.remove();
            typeof callback == "function" && callback();
        });

    });

    this.coger = claves => {

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

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

};