#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include <string.h>
#include <math.h>
#define LimpiaBuffer while(getchar() != '\n')
#define TVECTOR_PUNTOS 100

void primero(int a, int b, int coef[], char coefX, int op){
    int buffer_coeficientes[6]= {0,0,0,0,0,0};
    int i;

    if(coefX=='a'){
        buffer_coeficientes[1]=a;
        buffer_coeficientes[0]=b;
    }
    else{
        buffer_coeficientes[0]=a;
        buffer_coeficientes[1]=b;
    }

    if(op){
        for(i=0;i<2;i++)
            coef[i]+=buffer_coeficientes[i];
    }
    else{
        for(i=0;i<2;i++)
            coef[i]-=buffer_coeficientes[i];
    }
}

void cuadrado(int a, int b, int coef[], char coefX, int op){
    int buffer_coeficientes[6]= {0,0,0,0,0,0};
    int i;

    if(coefX=='a'){ /* Si el binomio es de la forma (x+m) */
        buffer_coeficientes[2]=pow(a,2);
        buffer_coeficientes[1]=(2*b*a);
        buffer_coeficientes[0]=pow(b,2);
    }
    else{
        buffer_coeficientes[0]=pow(a,2);
        buffer_coeficientes[1]=(2*b*a);
        buffer_coeficientes[2]=pow(b,2);
    }

    if(op){
        for(i=0;i<3;i++)
            coef[i]+=buffer_coeficientes[i];
    }
    else{
        for(i=0;i<3;i++)
            coef[i]-=buffer_coeficientes[i];
    }

}

void cubo(int a, int b, int coef[], char coefX, int op){
    int buffer_coeficientes[6]= {0,0,0,0,0,0};
    int i;

    if(coefX=='a'){ /* Si el binomio es de la forma (x+m) */
        buffer_coeficientes[3]=pow(a,3);
        buffer_coeficientes[2]=(3*b*pow(a,2));
        buffer_coeficientes[1]=3*a*pow(b,2);
        buffer_coeficientes[0]=pow(b,3);
    }
    else{
        buffer_coeficientes[0]=pow(a,3);
        buffer_coeficientes[1]=(3*b*pow(a,2));
        buffer_coeficientes[2]=3*a*pow(b,2);
        buffer_coeficientes[3]=pow(b,3);
    }

    if(op){
        for(i=0;i<4;i++)
            coef[i]+=buffer_coeficientes[i];
    }
    else{
        for(i=0;i<4;i++)
            coef[i]-=buffer_coeficientes[i];
    }
}

void cuarto(int a, int b, int coef[], char coefX, int op){
    int buffer_coeficientes[6]= {0,0,0,0,0,0};
    int i;

    if(coefX=='a'){ /* Si el binomio es de la forma (x+m) */
        buffer_coeficientes[4]=pow(a,4);
        buffer_coeficientes[3]=4*pow(a,3)*b;
        buffer_coeficientes[2]=6*pow(a,2)*pow(b,2);
        buffer_coeficientes[1]=4*a*pow(b,3);
        buffer_coeficientes[0]=pow(b,4);
    }
    else{
        buffer_coeficientes[0]=pow(a,4);
        buffer_coeficientes[1]=4*pow(a,3)*b;
        buffer_coeficientes[2]=6*pow(a,2)*pow(b,2);
        buffer_coeficientes[3]=4*a*pow(b,3);
        buffer_coeficientes[4]=pow(b,4);
    }

    if(op){
        for(i=0;i<5;i++)
            coef[i]+=buffer_coeficientes[i];
    }
    else{
        for(i=0;i<5;i++)
            coef[i]-=buffer_coeficientes[i];
    }
}

void quinto(int a, int b, int coef[], char coefX, int op){
    int buffer_coeficientes[6]= {0,0,0,0,0,0};
    int i;

    if(coefX=='a'){ /* Si el binomio es de la forma (x+m) */
        buffer_coeficientes[5]=pow(a,5);
        buffer_coeficientes[4]=5*pow(a,4)*b;
        buffer_coeficientes[3]=10*pow(a,3)*pow(b,2);
        buffer_coeficientes[2]=10*pow(a,2)*pow(b,3);
        buffer_coeficientes[1]=5*a*pow(b,4);
        buffer_coeficientes[0]=pow(b,5);
    }
    else{
        buffer_coeficientes[0]=pow(a,5);
        buffer_coeficientes[1]=5*pow(a,4)*b;
        buffer_coeficientes[2]=10*pow(a,3)*pow(b,2);
        buffer_coeficientes[3]=10*pow(a,2)*pow(b,3);
        buffer_coeficientes[4]=5*a*pow(b,4);
        buffer_coeficientes[5]=pow(b,5);
    }

    if(op){
        for(i=0;i<6;i++)
            coef[i]+=buffer_coeficientes[i];
    }
    else{
        for(i=0;i<6;i++)
            coef[i]-=buffer_coeficientes[i];
    }

}

void desarrollarBinomio(int coef[], int a, int b, int grado, int op, char coefX){
    switch(grado){
    case 1:
        primero(a,b,coef,coefX,op);
        break;
    case 2:
        cuadrado(a,b,coef,coefX,op);
        break;
    case 3:
        cubo(a,b,coef,coefX,op);
        break;
    case 4:
        cuarto(a,b,coef,coefX,op);
        break;
    case 5:
        quinto(a,b,coef,coefX,op);
        break;
    }
}


int esOp(char c){
    if(c=='+')
        return 1;
    else if(c=='-')
        return -1;
    else
        return 0;
}

int ConvAEntero(char** cad){ /* Genera una cadena auxiliar con los caracteres mientras sean numeros */
    char* i; int buf_index=0; char buffer[30];

    i=*cad;

    while(isdigit(*i)){
        buffer[buf_index]=*i;
        buf_index++;
        i++;
    }
    buffer[buf_index]='\0'; /* Se finaliza la cadena con \0 */
    *cad=i; /* Actualiza el puntero a la ultima posicion */

    return atoi(buffer); /* Retorna el resultado de la conversion de la cadena a int */

}



int parser(char* str, int *mayor, int coeficientes[]){
    /* Escribir las ecuaciones sin espacios */
    /* No se permiten las apariciones de x fuera de un binomio. Ej: (x-3)^2+x-1 */
    /* Los operadores unarios (ej: -1) no estan permitidos */
    /* x no puede estar elevada a ninguna potencia dentro de los binomios. Ej: (x^2-1)^3 */
    char* i;
    int esX=0;
    int a,b,grado;
    int op;
    char coefX;

    i=str;

    while(*i!='\0'){
        a=0;b=0;

        if((esOp(*i)==1) || (esOp(*i)==-1)){/* Determina el operador */
            op=esOp(*i);;
            i++;
        }
        else /* Si no hay un operador puede ser que el puntero se encuentre al comienzo de la ecuacion, en ese caso se toma como positivo */
            op=1;



        if(*i=='('){ /* Si empieza un binomio.. */
            i++;
            if(!isdigit(*i)){/* Si no es un numero, el primer operando es x, por lo tanto el coeficiente es 1 */
                a=1;
                esX=1;
                coefX='a';
                i++;
            }
            else{ /* Si en cambio, es un numero, puede tener mas de un digito, por lo tanto se pasa a una cadena auxiliar para luego convertirlo */
                a=ConvAEntero(&i);
            }
            if(*i=='x'){ /* Como el coeficiente de x ya se guardo, aumenta el puntero */
                i++;
                esX=1;
                coefX='a';
            }
            if((b=esOp(*i))==0) /* Se almacena el signo del 2do operando */
                return 0; /* Si lo que sigue no es un operador retorna un error de sintaxis */
            else /* Si es un operador, incrementa el puntero */
                i++;

            if(esX && !isdigit(*i)) /* Si la condicion se cumple, ambos operandos del binomio son variables, lo cual equivale a una sintaxis incorrecta */
                return 0;
            else if(esX && isdigit(*i)){
                b*=ConvAEntero(&i);
                if(*i=='x') /* Si es un numero seguido de x, hay 2 variables y la sintaxis es incorrecta */
                    return 0;
            }
            else if(!esX && !isdigit(*i)){ /* Si el primer operando es un numero */
                b*=1; /* Si el segundo operando es x entonces el coeficiente es 1 */
                coefX='b';
                i++;
            }
            else if(!esX && isdigit(*i)){ /* Si el primer operando es un num */
                b*=ConvAEntero(&i);
                if(*i!='x')
                    return 0; /* Si los dos operandos son numeros (no hay variable) retorna un error */

            }


            /* El caracter actual deberia ser ')' */
            if(*i==')'){
                i++; /* Avanza hacia el signo de exponenciacion */
                if(*i!='^'){
                    grado=1; /* Si no hay signo de exponenciacion, el grado del binomio es 1 */
                    if(grado>(*mayor))
                        *mayor=grado;
                    desarrollarBinomio(coeficientes,a,b,grado,op,coefX);
                }
                else if(isdigit(*++i)){
                    grado=(*i) - '0';
                    i++;/* Se convierte el caracter a un entero y se lo asigna al grado */
                    if(grado>(*mayor))
                        *mayor=grado; /* Determina el grado del polinomio */
                    desarrollarBinomio(coeficientes,a,b,grado,op,coefX);
                }
                else
                    return 0;

            }
            else
                return 0; /* La sintaxis es incorrecta ya que no se cierra el parentesis luego del 2do operando del binomio */
        }
        else if((esOp(*i))!=0){/* Si es un operador, puede estar seguido de una constante */
            op=esOp(*i);
            i++;
            if(isdigit(*i)){ /* Si entra en este bloque, *i deberia equivaler al comienzo del termino independiente */
                coeficientes[0]+=op * (ConvAEntero(&i));
            }
            else /* Si no esta seguido de un numero, puede estar seguido por otro binomio, con lo cual se decrementa y se pasa a la siguiente iteracion del while */
                i--;

        }
        else if(isdigit(*i)){ /* En el caso de que el operador ya se haya recorrido */
            coeficientes[0]+= (op * (ConvAEntero(&i)));
        }
        else if(*i!='\0')
            i++;
    }
    return 1; /* Cuando termina el while retorna que termino sin errores */
}


int CalcImagen(int coef[], int x, int grado){
    int i,img=0;
    for(i=0;i<=grado;i++){
        img+=((pow(x,i)) * (coef[i]));
    }

    return img;
}

void Integral(void){
    int ingreso;
    char cad_ecuacion[50];
    int x1,x2,i,j,grado=0;
    int coeficientes[6]={0,0,0,0,0,0};
    int* imagen;
    int intervalo;
    int PosicionY; /* Posicion en el eje Y, el valor maximo es 50, porque es el valor mas grande que se puede graficar */

    system("cls");

    puts("De que manera desea ingresar los datos?\n(0) Coeficiente a coeficiente\n(1) Toda la ecuacion\n");
    scanf("%d",&ingreso);

    if(!ingreso){

    /* Ingreso y validacion de datos */

    printf("Ingrese el grado del polinomio: ");
    scanf("%d",&grado);
    while(grado>5){
        printf("El grado del polinomio debe ser menor o igual a 5. Ingreselo nuevamente: ");
        scanf("%d",&grado);
    }
    for(i=grado;i>=0;i--){
        printf("Ingrese el coeficiente del grado %d: ",i);
        scanf("%d",&coeficientes[i]);
    }

    }
    else{
        puts("IMPORTANTE: Lea el documento 'analisis_enunciado.doc' para evitar errores de sintaxis\n\nIngrese la ecuacion: ");
        scanf("%s",cad_ecuacion);
        parser(cad_ecuacion,&grado,coeficientes);
    }

    printf("Graficar entre x1= ");scanf("%d",&x1);
    printf("y x2= ");scanf("%d",&x2);LimpiaBuffer;printf("\n");

    while ((x2<=x1)||((x1<0)||(x2<0))){
        if (x2<x1)
            printf("x2 debe ser mayor a x1. Intente nuevamente\n");
        else if (x2==x1)
            printf("x2 es igual a x1. Intente nuevamente\n");
        else
            printf("Alguna de las coordenadas es negativa\n");
        printf("Ingrese x1= ");
        scanf("%d",&x1);
        printf("y x2= ");
        scanf("%d",&x2);
    }

    intervalo=(x2-x1+1);

    imagen=malloc(sizeof(int)*intervalo);

    for(i=x1,j=0;i<=x2;i++,j++)/* Se calcula la imagen para cada punto del intervalo y se almacenan */
        imagen[j]=CalcImagen(coeficientes,i,grado);

    /* Partiendo del maximo valor representable (50), se grafica el area hasta llegar al eje X (es decir, cuand PosicionY==0) */
    for(PosicionY=50;PosicionY>0;PosicionY--){
        for(i=0;i<intervalo;i++){ /* Grafica la imagen por renglones */
            if(imagen[i]>=PosicionY)
                printf("*");
            else
                printf(" ");
        }
        printf("\n");
    }

    free(imagen);

    getchar();

}