package main;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
 
import net.java.dev.eval.Expression;
 
public class principal {
	//Por cutre que parezca, si he metido el abecedario en una matriz para identificar incognitas...
	//xD
	public static char[] TokensVariables = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H', 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P', 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z', 'Z'};
	public static int cuantasVariables = 0;
	public static Vector<Character> vectorOperandos = new Vector(10, 5);
	public static Vector<Character> vectorVariables = new Vector(10, 5);
 
public static void main(String args[])
{
 
	   String expresion = new String("2*x+b");
 
	   System.out.println("\n"+Procesador(preProcesador(expresion), expresion)); //La recursividad es inutil aqui, o quizas lo soy yo...
 
}
static int[] preProcesador(String argumento)
{
	char[] TokensOperandos = {'+', '-', '*', '/', '^'};
 
	char[] TokensVariables = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H', 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P', 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z', 'Z'};
 
	int countOperandos = 0;
	int countVariables = 0;
	/*BUCLE SEPARADOR DE OPERANDOS*/
 
	/*-NOTA: ESTE ALGORITMO SE PUEDE MEJORAR, PUES EL BUCLE SOBRECARGA*/
	//                                        ^ 
	//                                        |
	//La pereza hace cosas muy malas...  -----|
	//Bucle que busca operandos y los distribuye en memoria
	for(int i = 0; i< argumento.length(); i++)
	{
		//Bucle para recorrer la matriz con los tokens
		for(int j = 0; j < TokensOperandos.length; j++)
		{
			char chVolatil = TokensOperandos[j]; //Un caprichito de programador idiota :P
		if(argumento.charAt(i) == chVolatil)
		{
			vectorOperandos.add(chVolatil);
			countOperandos++;
		}
		}
	}
	/*BUCLE PARA SEPARAR VARIABLES                                    */
	/*-NOTA: ESTE ALGORITMO SE PUEDE MEJORAR, PUES EL BUCLE SOBRECARGA*/
    //                                        ^ 
	//                                        |
	//La pereza hace cosas muy malas...  -----|
	for(int i = 0; i < argumento.length(); i++)
	{
		//Bucle para recorrer la matriz con los tokens
		for(int j = 0; j < TokensVariables.length; j++)
		{
			char varVolatil = TokensVariables[j]; //Un caprichito de programador idiota :P
		if(argumento.charAt(i) == varVolatil)
		{
			vectorVariables.add(varVolatil);
			countVariables++;
		}
		}
	}//Que poco me gusta trabajar, y como se nota el copypaste de este fragmento...
	 //Para que codearlo 2 veces? Es inutil hacerlo :P
	System.out.print("Estos son los " + vectorOperandos.size() + " operandos que hay en la expresion:\n" );
	System.out.print("[");
	for(int i=0; i<vectorOperandos.size(); i++){
		if(i == 0)
		{
        System.out.print(vectorOperandos.elementAt(i));
		}else{
	    System.out.print(","+vectorOperandos.elementAt(i));
		}
    }
	System.out.print("]\n");
    System.out.println("/////////////////////////////////////////////////////////////////////////////// ");
    System.out.println("############################################################################### ");
    System.out.println("/////////////////////////////////////////////////////////////////////////////// ");
	System.out.print("Y aqui estan las " + vectorVariables.size() + " variables o incognitas de la expresion:\n");
	System.out.print("[");
	for(int i=0; i<vectorVariables.size(); i++){
		if(i == 0)
		{
        System.out.print(vectorVariables.elementAt(i));
		}else{
	    System.out.print(","+vectorVariables.elementAt(i));
		}
    }
	System.out.print("]");
	int[] salida = {countOperandos, countVariables};
	return salida;
}
static BigDecimal Procesador(int[] cuantos, String que)
{
 
	 Expression exp = new Expression(que);
	 InputStreamReader isr = new InputStreamReader(System.in);
     BufferedReader br = new BufferedReader(isr);
 
	 Map<String, BigDecimal> variables = new HashMap<String, BigDecimal>();
 
	 for(int j = 0; j < cuantos[1]; j++)
	 {
		 System.out.print("\nDame un valor para la variable " + vectorVariables.elementAt(j) + " :\n");
		 try {
			String expresionVolatil = br.readLine();
            variables.put(String.valueOf(vectorVariables.elementAt(j)), Procesador(preProcesador(expresionVolatil), expresionVolatil));
		} catch (IOException e) {
           e.printStackTrace();
		}
		}
     BigDecimal result = exp.eval(variables);
 
	 return result;
}
}