/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Nodos;

/**
 *
 * @author ABNER
 */
public class Arbol_Expresion<E>   {
    protected ANodo arbol = new ANodo();
    protected ANodo N_actual= arbol;
    int nodos = 0;
    private String cadenaInOrden = "";
    private String cadenaPreOrden ="";
    private String cadenaPostOrden = "";


    /**
     * constructor vacío
     */
    public Arbol_Expresion (){
    }
    public ANodo getArbol(){
        return arbol;
    }
    public void setArbol(ANodo arbol){
        this.arbol = arbol;
    }
    public ANodo getN_actual(){
        return N_actual;
    }
    public void setN_actual(ANodo NodoActual){
        this.N_actual=NodoActual;
    }
     public String getCadenaInOrden() {
        return cadenaInOrden;
    }

    public String getCadenaPreOrden() {
        return cadenaPreOrden;
    }
    /*
     * Separa la cadena en caracter por caracter e envia el caracter hacia el
     * metodo insertar
     */
    public void enviar_caracter(String cadena){
        int long_cadena = 0;
        int x=0;
        char caracter;
        long_cadena = length(cadena);
        for (x=0;x<=long_cadena; x++){
            caracter = charat(cadena,x);
            insertar(caracter);
        }

    }
    /*
     * devuelve la longitud de la cadena
     */
    private int length(String cadena) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    /*
     * Inserta un nuevo nodo al arbol de expresion
     */
    public ANodo insertar(char signo){
        if(equals(signo,'(')){
            ANodo nuevo = new ANodo();
            nuevo.hder = null;
            nuevo.hizq = null;
            nuevo.padre = null;
            //Si el arbol esta vacio
            if(arbol == null){
                arbol = nuevo;
                arbol.padre = null;
                arbol.hder = null;
                arbol.hizq = null;
                arbol.elemento = 0;
                N_actual = arbol;
                nodos++;
                return arbol;
            }
            if(tieneizquierdo(N_actual)){
                N_actual.hizq = nuevo;
                nuevo.padre= N_actual;
                N_actual = nuevo;
                nodos ++;
                return arbol;
            }
            else{
                N_actual.hder = nuevo;
                nuevo.padre = N_actual;
                N_actual = nuevo;
                nodos ++;
                return arbol;
            }

        }


        if((equals(signo,'+'))||(equals(signo,'-'))||(equals(signo,'*')) || (equals(signo,'/'))){
            N_actual.elemento = signo;
            return arbol;
        }

        //si el caracter es parentesis cerrado no hace nada solo retorna
        if (equals(signo,')')){
            return arbol;
        }
        //verifica si el caracter es un digito o una letra
        if (isLetterOrDigit(signo)){
            //si el caracter es una letra
            if(isLetter(signo)) {
                ANodo nuevo = new ANodo();
                nuevo.hder = null;
                nuevo.hizq = null;
                nuevo.padre = null;
                //Creo un puntero hacia el nodo actual
                ANodo auxiliar = N_actual;
                //si no tiene hijo izquierdo se hacen las devidas apuntaciones
                if((tieneizquierdo(N_actual))){
                    N_actual.hizq = nuevo;
                    nuevo.padre = N_actual;
                    nuevo.elemento = signo;
                    return arbol;
                }
                //Si tiene hijo izquierdo se hacen las devidas apuntaciones en el hijo derecho
                else{
                    N_actual.hder = nuevo;
                    nuevo.padre = N_actual;
                    nuevo.elemento = signo;
                    //el nodo acual cambia cuando el Hijo derecho ya tiene una pocision;
                    N_actual = auxiliar.padre;
                    return arbol;
                }
            }
            //Si el caracter es un digito
            if (isDigit(signo)){
                int numero = 0;
                //convierto el caracter a entero
                numero = digit(signo,1);
                //Creo el nodo
                ANodo nuevo = new ANodo();
                nuevo.hder = null;
                nuevo.hizq = null;
                nuevo.padre = null;
                //Creo un puntero hacia el nodo actual
                ANodo auxiliar = N_actual;
                //si no tiene hijo izquierdo se hacen las devidas apuntaciones
                if((tieneizquierdo(N_actual))){
                    N_actual.hizq = nuevo;
                    nuevo.padre = N_actual;
                    nuevo.elemento = signo;
                    return arbol;
                }
                //Si tiene hijo izquierdo se hacen las devidas apuntaciones en el hijo derecho
                else{
                    N_actual.hder = nuevo;
                    nuevo.padre = N_actual;
                    nuevo.elemento = signo;
                    //el nodo acual cambia cuando el Hijo derecho ya tiene una pocision;
                    N_actual = auxiliar.padre;
                    return arbol;
                }
            }
        }

        recorrer();
        return arbol;

    }
    //devuelve el caracter de la posicion dada
    private char charat(String cadena, int x) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private boolean equals(char signo, char c) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private boolean tieneizquierdo(ANodo N_actual) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private boolean tienederecho(ANodo N_actual) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private boolean isDigit(char signo) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private boolean isLetter(char signo) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private int digit(char signo, int i) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    private boolean isLetterOrDigit(char signo) {
        throw new UnsupportedOperationException("Not yet implemented");
    }



    /**
     * Cada vez que se hace un cambio en el árbol se invoca a este método
     * para realizar los recorridos en y pre orden y guardarlos en las
     * cadenas respectivas
     */
     private void recorrer(){
        cadenaInOrden = "";
        cadenaPreOrden = "";
        cadenaPostOrden = "";
        inOrden(arbol);
        preOrden(arbol);

    }

        /**
     * Método privado, auxiliar.
     * Método recursivo para guardar en la variable de instancia cadenaInOrden
     * el orden simétrico de los nodos del árbol
     * @param v nodo a partir del cual se recorrerá el árbol en orden simétrico
     */
    private void inOrden (ANodo v){
        if (!(v.tieneizquierdo()))
            inOrden(v.getHizq());

        if (v.esInterno())
            cadenaInOrden+=(v.toString() + "  ");

        if(!(v.tienederecho()))
            inOrden(v.getHder());


    }
    /**
     * Método privado, auxiliar.
     * Método recursivo para guardar en la variable de instancia cadenaInOrden
     * el orden simétrico de los nodos del árbol
     * @param v nodo a partir del cual se recorrerá el árbol en orden simétrico
     */
    private void postOrden (ANodo v){
        if (!(v.tieneizquierdo()))
            postOrden(v.getHizq());

        if(!(v.tienederecho()))
            cadenaPostOrden+=(v.toString() + "  ");
            postOrden(v.getHder());
    }

    /**
     * Método privado, auxiliar.
     * Método recursivo para guardar en la variable cadenaPreOrden
     * el preorden de los nodos del árbol
     * @param v nodo a partir del cual se recorrerá el árbol en preorden
     */
    private void preOrden (ANodo v){
            cadenaPreOrden+=(v.toString()+" ");

           if (!(v.tieneizquierdo())){
                cadenaPreOrden+=("(");
                preOrden(v.getHizq());
            }

            if(!(v.tienederecho())){
                preOrden(v.getHder());
                cadenaPreOrden+=(")");
            }

    }

    /**
     * Método privado, auxiliar.
     * @param v nodo al que deseamos encontrar el nodo no vacío que le sigue en orden simétrico
     * @return el nodo que sigue a v inorden
     */
    private ANodo getSiguienteInOrden (ANodo v){

        if(v.getHizq().esExterno())
            return v;
        else
            return getSiguienteInOrden(v.getHizq());

     }

}