int matrizBaseA[2][2];
int matrizBaseB[2][2];
int cambiodeBase[2][2];
int matrizBInver[2][2];
int punto[2];
int puntoBaseB[2];

char plano_cartesiano[39][39];
int vecesDelCiclo = 0;

void bases(int base) {
  Serial.println("Inicializando matriz...");
  if(base == 1) {
    for (int i = 0; i < 4; i++) {
      int valor = pedirCoordenada(i + 1);
      switch(i){
        case 0:
          matrizBaseA[0][0] = valor;
          break;
        case 1:
          matrizBaseA[1][0] = valor;
          break;
        case 2: 
          matrizBaseA[0][1] = valor;
          break;
        case 3:
          matrizBaseA[1][1] = valor;
          break;
      }
    }
  } else if (base == 2) {
    for (int i = 0; i < 4; i++) {
      int valor = pedirCoordenada(i + 1);
      switch(i){
        case 0:
          matrizBaseB[0][0] = valor;
          break;
        case 1:
          matrizBaseB[1][0] = valor;
          break;
        case 2: 
          matrizBaseB[0][1] = valor;
          break;
        case 3:
          matrizBaseB[1][1] = valor;
          break;
      }
    }
  }
}


int pedirCoordenada(int numCoordenada) {
  int valor;
  do {
    Serial.print("Ingrese la coordenada ");
    Serial.print(numCoordenada);
    Serial.print(": ");
    while (!Serial.available()); // Esperar a que esté disponible la entrada
    delay(100); // Pequeño retraso para evitar lecturas prematuras
    valor = Serial.parseInt(); // Leer el valor
    Serial.println(valor); // Imprimir el valor leído
    delay(100); // Pequeño retraso para evitar lecturas prematuras
    // Limpiar el búfer de entrada serial
    while (Serial.available() > 0) {
      char _ = Serial.read();
    }
  } while (valor < -20 || valor > 20); // Verificar el rango
  return valor;
}

void grafica() {
  for (int i = -20; i<=20; i++)
  {
      for (int a = -20; a <= 20; a++){
        Serial.print(plano_cartesiano[a+20][i+20]);
  }
}
}

void vectoresGen(int x1, int y1, int x2,int y2){
int componente_x1 = 0;
int componente_y1 = 0;
int componente_x2 = 0;
int componente_y2 = 0;
componente_x1 = x1;
componente_y1 = y1;
componente_x2 = x2;
componente_y2 = y2;
traza(componente_x1,componente_y1);
traza(componente_x2,componente_y2);
}
void traza (int x, int y){
if (x!=0)
{
float  m = (float) y/x;
if (x>0)
{
  for (int i = x ; i >= 0; i--)
  {
  int newy = (int)(m*i);
  point(i,newy);
  Serial.print("newy (x > 0): ");
  Serial.println(newy);

  }
}
else if (x<0)
  for (int i = x ; i <= 0; i++)
  {
  int newy = (int)(m*i);
  point(i,newy);
  }
}
else
{
  point(x,y);
}
}
void point(int punto0, int punto1){

int px = punto0+20;
int py = -punto1+20;
plano_cartesiano[px][py]= '*';
}

void calcularInversa(){
    //Primero calculamos la matriz transpuesta de B

   int auxB[2][2] = {{matrizBaseB[0][0], matrizBaseB[1][0]},{matrizBaseB[0][1], matrizBaseB[1][1]}};

   //Después calculamos la matriz de cofactores de la transpuesta para obtener la matriz adjunta, y la dividimos sobre su determinante para obtener la inversa.
   int matrizBInver[2][2];

   int det = determinante(auxB);

   
      matrizBInver[0][0] = (auxB[1][1])/det;
      matrizBInver[0][1] = (-1 * auxB[1][0])/det;
      matrizBInver[1][0] =  (-1 * auxB[0][1])/det;
      matrizBInver[1][1] = (auxB[0][0])/det;

}

float determinante(int m[2][2]){
    float detM = 0;
    detM = ((m[0][0] * m[1][1]) - (m[0][1] * m[1][0]));
    return detM;
}

void calcularMatrizCambioBase() {
    // Calcular la matriz inversa
    calcularInversa();
    // Calcular las entradas de la matriz de cambio de base
    int entrada[4];

     entrada[0] = (matrizBInver[0][0] * matrizBaseA[0][0]) + (matrizBInver[0][1] * matrizBaseA[1][0]);
     entrada[1] = (matrizBInver[0][0] * matrizBaseA[0][1]) + (matrizBInver[0][1] * matrizBaseA[1][1]);
     entrada[2] = (matrizBInver[1][0] * matrizBaseA[0][0]) + (matrizBInver[1][1] * matrizBaseA[1][0]);
     entrada[3] = (matrizBInver[1][0] * matrizBaseA[0][1]) + (matrizBInver[1][1] * matrizBaseA[1][1]);
    
    // Asignar las entradas calculadas a la matriz de cambio de base
    for(int i = 0; i <= 1; i++){
      for(int j = 0; j <= 1; j++){
        cambiodeBase[i][j] = entrada[i];
      }
    }
}

void cambiardeBase(){
   puntoBaseB[0] = (punto[0] * cambiodeBase[0][0]) + (punto[1] * cambiodeBase[0][1]);
   puntoBaseB[1] = (punto[0] * cambiodeBase[1][0]) + (punto[1] * cambiodeBase[1][1]);
}


void inicializar(){
  bases(1);
  bases(2);

  //comprobar que ambas matrices sean LI. Si no, pedir datos de nuevo.
 if(determinante(matrizBaseA) == 0 ){
     while(determinante(matrizBaseA) == 0){
      Serial.println("La matriz A es linealmente dependiente, por lo tanto no puede formar una base. Por favor inserte nuevos vectores: ");
      bases(1);
    }
  }

  if(determinante(matrizBaseB) == 0){
    while(determinante(matrizBaseB) == 0)
    { Serial.print("La matriz B es linealmente dependiente, por lo tanto no puede formar una base. Por favor inserte nuevos vectores: ");
      bases(2);
    } 
  } 

}

void setup() {

  Serial.begin(9600);

  //pedir datos matrices
  inicializar();

  calcularMatrizCambioBase();

for (int i = -20; i<=20; i++)
  {
      for (int a = -20; a<= 20; a++){
        if (a == 0 && i==0)
        {
        plano_cartesiano[a+20][i+20]= 'o';
        }
        else if (a == 0)
        {
        plano_cartesiano[a+20][i+20]= '|';
        }
        else if (i == 0)
        {
        plano_cartesiano[a+20][i+20]= '-';
        }
        else if (a!= 0 && i != 0)
        {
        plano_cartesiano[a+20][i+20]= '.';
        }
      }

  }

}

void menu() {
  char opcion;

  while (Serial.available() > 0) {
      char _ = Serial.read();
    }
  delay(100);

  Serial.println("Bienvenido a la calculadora de bases.");
  Serial.println("Seleccione una opción:");
  Serial.println("A. Capturar un punto");
  Serial.println("G. Graficar");

  
  while (!Serial.available()); // Esperar a que esté disponible la entrada
  opcion = Serial.read();
  Serial.println(opcion); // Imprimir la opción seleccionada
  
  if(opcion == 'A' || opcion == 'a'){
    capturarPunto();
  }
  else if(opcion == 'G' || opcion == 'g'){
    cambiardeBase();
    point(punto[0], punto[1]);
    vectoresGen(cambiodeBase[0][0], cambiodeBase[1][0], cambiodeBase[0][1], cambiodeBase[1][1]);
    grafica();
  }
  else{
     Serial.println("Opción inválida. Por favor, seleccione una opción válida.");
  }
  
}

void capturarPunto() {

  for( int i = 0; i <2; i ++){
  int valor;
  do {
    Serial.print("Ingrese la coordenada ");
    Serial.print(i+1);
    Serial.print(": ");
    while (!Serial.available()); // Esperar a que esté disponible la entrada
    delay(500); // Pequeño retraso para evitar lecturas prematuras
    valor = Serial.parseInt(); // Leer el valor
    Serial.println(valor); // Imprimir el valor leído
    delay(500); // Pequeño retraso para evitar lecturas prematuras
    // Limpiar el búfer de entrada serial
    while (Serial.available() > 0) {
      char _ = Serial.read();
    }
  } while (valor < -128 || valor > 128); // Verificar el rango
  punto[1] = valor;
  }
}


void loop() {
  menu();
  delay(5000);
  }