let queue = [];
let final_queue = [];
let resultado = 0;
let cantidad_nums = 0;
let operation_order = ['+','-','/','*','^'];
let tally = 0;

function q_print(){
    for (k=0; k < queue.length; k++){
        setTimeout(console.log("Índice N°"+k+" es "+queue[k]),500);
    }
    return;
}

function a_print(array){
    for (k=0; k < array.length; k++){
        console.log("Índice N°"+k+" es "+array[k]);
    }
    return;
}

function q_display(q_array) {
    output.innerHTML = '';
    for (i=0; i < q_array.length; i++) {
        output.innerHTML += q_array[i];
    }
    return;
}

function q_manage(type, item){
    if (type == 'add') {
        queue.push(item);
        q_display(queue);
    } else if (type == 'remove') {
        queue.splice(-1,1);
        q_display(queue);
    } else {
        output.innerHTML = 'Entrada inválida';
    }
    return;
}

function a_concatnum(z_array) {
    let a_length = z_array.length;
    var a_concat = [];
    var cont = 0;
    var num = "";
    let j = 0;

    z_array.push(true); // push something other than number or string to trigger last exectuion

    for (i=0; i < a_length; i++){
        if (typeof(z_array[i]) == 'number'){
            cont++;   
        } else {
            for (j=0; j < cont; j++){
                num = num + String(z_array[(j)]);
            }
            if (num != '') {
                a_concat.push(parseInt(num))
            }
            num = "";
            if (typeof(z_array[i] == 'string')) {
                a_concat.push(z_array[i]);
            } 
            z_array.splice(0,cont+1);
            cont = 0;
            i=-1;
            a_length = z_array.length;
        }
    }
    z_array = a_concat;
    z_array.splice(-1,1); // remove that something i put in earlier
    return z_array;
}

function a_split(l_array) {
    function a_search_char(s_array,char, direction_from,excluded_points){
        if (direction_from == 'right') {
            s_array.reverse();
        } else if (direction_from == 'left'){
        } else {
            output.innerHTML = 'Error en la dirección de búsqueda';
        }

        outerLoop: for (i=0; i < s_array.length; i++){
            // Chequea si el punto encontrado está en la exclusión (para evitar repetidos)
            innerLoop: for (j=0; j <= excluded_points.length; j++){
                if (i == excluded_points[j]){
                    continue outerLoop;
                }
            }
            if (s_array[i] == char) {
                    if (direction_from == 'right'){
                        return (s_array.length-i-1);
                    }
                    return i;
            }
        }
        return -1; // No se ha encontrado
    }

    function array_divider(a_array, d_points){
        let start = 0;
        let divided_array = [];
        for (i=0; i <= d_points.length; i++){
            
            divided_array.push(a_array.slice(start,d_points[i]));
            start =+ d_points[i] +1;
        }
        return divided_array;
    }

    /* Búsqueda de paréntesis
    No lo voy a implementar esto, es un montón, intenté pensar 
    en un algoritmo pero no se me occurió, y busqué pero no quiero
    usar un algoritmo tipo Shuning Yard, la idea de este código es
    hacerlo sin ayudas, incluso si es ineficiente (este código tiene
    O^n execution time, más recursión tiene esta cosa. */

    // Buscar puntos dónde se encuentran caracteres en un array 
    function find_location_points(f_array,char) {
        let location_points = [];
        for (i=0; i < f_array.length; i++){
            let search_result = a_search_char(f_array,char,'left',location_points);
            // Break si ya no encuentra más
            if ( search_result == -1 ){
                break;
            } else {
                location_points.push(search_result);
            }
        }
        return location_points;
    }

    function branch(b_array,char) {
        b_array = array_divider(
            b_array,
            find_location_points(b_array,char));
        return b_array;
    }
   
    function branching(b2_array){
        // First
        b2_array = branch(b2_array,'+');

        // Second
        for (l=0; l < b2_array.length; l++) {
            b2_array[l] = branch(b2_array[l],operation_order[1]);
        }

        // Third
        for (k=0; k < b2_array.length; k++) {
            for (m=0; m < b2_array[k].length; m++){
                b2_array[k][m] = branch(b2_array[k][m],operation_order[2]);
            }
        }

        // Fourth
        for (k=0; k < b2_array.length; k++) {
            for (m=0; m < b2_array[k].length; m++){
                for (n=0; n < b2_array[k][m].length; n++){
                    b2_array[k][m][n] = branch(b2_array[k][m][n],operation_order[3]);
                }
            }
        }

        // Fifth
        for (k=0; k < b2_array.length; k++) {
            for (m=0; m < b2_array[k].length; m++){
                for (n=0; n < b2_array[k][m].length; n++){
                    for (o=0; o < b2_array[k][m][n].length; o++){
                        b2_array[k][m][n][o] = branch(b2_array[k][m][n][o],operation_order[4]);
                    }
                }
            }
        }
        return b2_array;

    }
    l_array = branching(l_array);
    return l_array;
}

function a_calculate(array) {
    // Exponenciation
    for (k=0; k < array.length; k++) {
        for (m=0; m < array[k].length; m++){
            for (n=0; n < array[k][m].length; n++){
                outerFor: for (o=0; o < array[k][m][n].length; o++){
                    innerFor: for (z = 0; z < array[k][m][n][o].length; z++){
                        // There is an extra [0] at the end of each exponenciation compensating extra nesting (?)
                        if (array[k][m][n][o].length == 1){
                            array[k][m][n][o] = array[k][m][n][o][0][0];
                            continue outerFor;
                        }
                        array[k][m][n][o][0] = array[k][m][n][o][0][0] ** array[k][m][n][o][1][0];
                        array[k][m][n][o].splice(1,1);
                    }
                    array[k][m][n][o] = array[k][m][n][o][0];
                }
            }
        }
    }

    // Multiplication
    for (k=0; k < array.length; k++) {
        for (m=0; m < array[k].length; m++){
            outerFor: for (n=0; n < array[k][m].length; n++){
                innerFor: for (z = 0; z < array[k][m][n].length; z++){
                    if (array[k][m][n].length == 1){
                        array[k][m][n]= array[k][m][n][0];
                        continue outerFor;
                    }
                    array[k][m][n][0] = array[k][m][n][0] * array[k][m][n][1];
                    array[k][m][n].splice(1,1);
                }
                array[k][m][n] = array[k][m][n][0];
            }
        }
    }

    // Division
    for (k=0; k < array.length; k++) {
        outerFor: for (m=0; m < array[k].length; m++){
            innerFor: for (z = 0; z < array[k][m].length; z++){
                if (array[k][m].length == 1){
                    array[k][m]= array[k][m][0];
                    continue outerFor;
                }
                array[k][m][0] = array[k][m][0] / array[k][m][1];
                array[k][m].splice(1,1);
            }
            array[k][m] = array[k][m][0];
        }
    }

    // Subtraction
    outerFor: for (k=0; k < array.length; k++) {       
        innerFor: for (z = 0; z < array[k].length; z++){
            if (array[k].length == 1){
                array[k]= array[k][0];
                continue outerFor;
            }
            array[k][0] = array[k][0] - array[k][1];
            array[k].splice(1,1);
        }
        array[k] = array[k][0];
    }

    // Addition
    outerFor: for (k=0; k < array.length; k++) {
        innerFor: for (z = 0; z < array.length; z++){
            if (array.length == 1){
                continue outerFor;
            }
            array[0] = array[0] + array[1];
            array.splice(1,1);
        }
    }

    return array;
}


function q_execute() {
    //q_concatnum();
    queue = a_concatnum(queue);
    queue = a_split(queue);
    queue = a_calculate(queue);
    q_display(queue);
    return;
}