#include <stdio.h>
#include <stdbool.h>
#include "fauces.h"



#define ARCHIVO_ATAQUES "ataques_por_vulnerabilidad.txt"
#define ARCHIVO_RESUMEN "resumen_ataques.txt"

#define READ_BIN "rb"
#define WRITE_BIN "wb"
#define READ "r"
#define WRITE "w"

#define LINEA_ATAQUE "%c;%c;%i\n" //H;X;5

#define LINEA_RESUMEN "%c;%i;%i\n"

#define MAX_ESCUADRONES 26
#define MAX_VUL 7



#define MAX 50

typedef struct linea_ataque{
  char elemento;
  char codigo;
  int naves_baja;
} linea_ataque_t;


void procesar_escuadron_alta(squads_t *squad, char codigo_escuadron, int cantidad_naves,
   char elemento_ataque, int potencia_ataque){
     (*squad).codigo_escuadron = codigo_escuadron;
     (*squad).cantidad_naves = cantidad_naves;
     (*squad).elemento_ataque = elemento_ataque;
     (*squad).potencia_ataque = potencia_ataque;
}
void ordenar_escuadrones(squads_t squads[MAX_ESCUADRONES], int tope){
  int i,j=0;
  squads_t aux;
  bool ordenado;
  ordenado = true;
  while ((j<tope) &&ordenado){
    ordenado = false;
    for (i=0;i<tope-1;i++){
      if (squads[i].elemento_ataque > squads[i+1].elemento_ataque){
        aux = squads[i];
        squads[i] = squads[i+1];
        squads[i+1] = aux;
        ordenado = true;
      }
    }
    j++;
  }
}
bool abrir_archivos_ataques(FILE** escuadrones, FILE** vulnerabilidades, FILE** ataques_por_vulnerabilidad, FILE** resumen){

  *ataques_por_vulnerabilidad = fopen(ARCHIVO_ATAQUES,READ);
  *escuadrones = fopen(RUTA_MAESTRO_ESCUADRONES,READ_BIN);
  *vulnerabilidades = fopen(RUTA_MAESTRO_VULNERABILIDADES,READ_BIN);
  *resumen = fopen(ARCHIVO_RESUMEN,WRITE);
  if (!resumen){
    fclose(*ataques_por_vulnerabilidad);
    fclose(*escuadrones);
    fclose(*vulnerabilidades);
    return false;
    }
  return true;
  }
void cerrar_archivos_ataques(FILE** escuadrones, FILE** vulnerabilidades, FILE** ataques_por_vulnerabilidad, FILE** resumen_ataques){
  fclose(*escuadrones);
  fclose(*vulnerabilidades);
  fclose(*ataques_por_vulnerabilidad);
  fclose(*resumen_ataques);
}

void cargar_escuadrones(squads_t escuadrones[MAX_ESCUADRONES], FILE* maestro_escuadrones, int *tope_escuadrones){
    squads_t escuadron_actual;
    fseek(maestro_escuadrones,0,SEEK_SET);
    for (int i=0;fread(&escuadron_actual,sizeof(squads_t),1,maestro_escuadrones);i++){
        escuadrones[i] = escuadron_actual;
        (*tope_escuadrones)++;
    }
}
void generar_resumen_ataques(FILE* maestro_escuadrones, FILE* maestro_vulnerabilidades, FILE* ataques_por_vulnerabilidad, FILE* resumen_ataques,bool *fauces_destruida){
  int ataque, bajas;
  int turnos_resistencia, turnos_durabilidad;
  int tope_escuadrones = 0;
  int i = 0;
  linea_ataque_t linea_ataque;
  vulnerabilidad_t vulnerabilidad_actual;
  squads_t escuadrones[tope_escuadrones];

  cargar_escuadrones(escuadrones, maestro_escuadrones,&tope_escuadrones);
  ordenar_escuadrones(escuadrones, tope_escuadrones);
  printf("\tEscuadrones ordenados por elemento \n");
  for(int b=0;b<tope_escuadrones;b++){
    printf("%c %i %c %i\n",escuadrones[b].codigo_escuadron,escuadrones[b].cantidad_naves,escuadrones[b].elemento_ataque,escuadrones[b].potencia_ataque);
  }

  //Leo el primer elemento_actual de archivo_ataques y vulnerabilidades
  fscanf(ataques_por_vulnerabilidad,LINEA_ATAQUE,&linea_ataque.elemento,&linea_ataque.codigo,&linea_ataque.naves_baja);
  fread(&vulnerabilidad_actual,sizeof(vulnerabilidad_t),1,maestro_vulnerabilidades);

  while (!feof(ataques_por_vulnerabilidad)){
    printf("\t\t 1er While\n");
    turnos_resistencia = 0;
    printf("turnos_resistencia: %i\n",turnos_resistencia);
    turnos_durabilidad = 0;
    printf("turnos_durabilidad: %i\n",turnos_durabilidad);

    while(!feof(ataques_por_vulnerabilidad) && vulnerabilidad_actual.elemento == linea_ataque.elemento){
      printf("\t\t 2do While\n");

      printf("vulnerabilidad_actual.elemento: %c\n",vulnerabilidad_actual.elemento);
      printf("linea_ataque: %c;%i;%i\n",linea_ataque.elemento,linea_ataque.codigo,linea_ataque.naves_baja);

      bajas = 0;
      printf("Bajas:%i \n",bajas);

      while(!feof(ataques_por_vulnerabilidad) && (vulnerabilidad_actual.elemento == linea_ataque.elemento) && escuadrones[i].codigo_escuadron==linea_ataque.codigo){
        printf("\t\t 3er While\n");
        printf("Elemento: %c, Codigo: %c",linea_ataque.elemento,linea_ataque.codigo);

        ataque = (escuadrones[i].cantidad_naves - bajas) * (escuadrones[i].potencia_ataque);
        printf("ataque: %i\n",ataque);

        if (vulnerabilidad_actual.resistencia > 0){
          vulnerabilidad_actual.resistencia -= ataque;
          printf("Resistencia: %i\n",vulnerabilidad_actual.resistencia);
          }
        if (vulnerabilidad_actual.resistencia<0 && vulnerabilidad_actual.durabilidad>0){
          vulnerabilidad_actual.durabilidad -= ataque;

          printf("Durabilidad: %i\n",vulnerabilidad_actual.durabilidad);
          }
        bajas += linea_ataque.naves_baja;
        fscanf(ataques_por_vulnerabilidad,LINEA_ATAQUE,&linea_ataque.elemento,&linea_ataque.codigo,&linea_ataque.naves_baja);
        }

      i++;
    }
    if (vulnerabilidad_actual.resistencia>0){
      turnos_resistencia = -1;
      }
    if (vulnerabilidad_actual.durabilidad>0){
      turnos_durabilidad = -1;
      }
    if(vulnerabilidad_actual.durabilidad>0 || vulnerabilidad_actual.resistencia>0){
      *fauces_destruida = false;
    }
    printf("Linea a escribir:\n%c;%i;%i\n",vulnerabilidad_actual.elemento,turnos_resistencia,turnos_durabilidad);
    fprintf(resumen_ataques,LINEA_RESUMEN,vulnerabilidad_actual.elemento,turnos_resistencia,turnos_durabilidad);
    fread(&vulnerabilidad_actual,sizeof(vulnerabilidad_t),1,maestro_vulnerabilidades);
  }
}

bool realizar_ataques(char* archivo_ataques,char* archivo_resumen, bool* fauces_destruida){
  //Leo el archivo
  FILE* maestro_squads;
  FILE* maestro_vulnerabilidades;
  FILE* ataques_por_vulnerabilidad;
  FILE* resumen_ataques;

  if (!abrir_archivos_ataques(&maestro_squads,&maestro_vulnerabilidades,&ataques_por_vulnerabilidad,&resumen_ataques)){
    return false;
  }
  generar_resumen_ataques(maestro_squads,maestro_vulnerabilidades,ataques_por_vulnerabilidad,resumen_ataques,fauces_destruida);
  cerrar_archivos_ataques(&maestro_squads,&maestro_vulnerabilidades,&ataques_por_vulnerabilidad,&resumen_ataques);
  return true;
}

int main(){
  char archivo_ataques,archivo_resumen;
  bool fauces_destruida = true;
  realizar_ataques(ARCHIVO_ATAQUES,ARCHIVO_RESUMEN,&fauces_destruida);
  return 0;
}