#define _POSIX_C_SOURCE 200809L
#define _GNU_SOURCE

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "lista.h"
#include "heap.h"
#include "modificaciones_tda.c"

#define SIZE 1024
//#include "tp2.h"
//#include "interfaz.c"

//Necesito definifr un parametro para C.

typedef struct linea_registro {
  char* ip;
  char* fecha;
  char* recurso;
  char* ruta;
} linea_registro_t;


linea_registro_t* crear_registro(){
  linea_registro_t* registro = malloc(sizeof(linea_registro_t));
  if(!registro) return NULL;
  registro->ip = NULL;
  registro->fecha = NULL;
  registro->recurso = NULL;
  registro->ruta = NULL;
  return registro;
}

void registro_destruir(linea_registro_t** registro,size_t TAM_REGISTRO){
  for(size_t i=0;i<TAM_REGISTRO;i++){
    if(registro[i]){
      free((char*)registro[i]->ip);
        free((char*)registro[i]->fecha);
          free((char*)registro[i]->recurso);
            free((char*)registro[i]->ruta);
    }
    free(registro[i]);
  }
  free(registro);
}


void ordenar_archivo(const char* archivo,size_t memoria_disponible){
  //Necesita la funcion de comparacion de strings.
  //heap_t* heap = heap_crear((cmp_func_t)funcion_cmp_logs);
  FILE* archivo_log = fopen(archivo,"r");
  char* linea=NULL;
  size_t CANTIDAD_LINEAS = 0;

  char line[SIZE];
  size_t tam_line=0;
  /*Cuento la cantidad de lineas y busco la linea maxima para definir
  la cantidad de particiones a hacer y la cota de lineas para leer por particion.
  */
  while(fgets(line, sizeof(line), archivo_log) != NULL){
      if(sizeof(linea)>tam_line) tam_line=(sizeof(line));
      CANTIDAD_LINEAS++;
  }
  const size_t K_PARTICIONES = memoria_disponible/tam_line;
  const size_t COTA_LINEAS = (CANTIDAD_LINEAS / K_PARTICIONES)+1;

  //Armo un array de punteros a las futuras particiones.
  FILE *particiones[K_PARTICIONES];

  int contador_linea = 0; //esto es muy villero but it works dude

  fseek( archivo_log, 0, SEEK_SET ); //me paro al principio del archivo actual para volver a leerlo


  //La papa. Aca arranco a meter la data en cada particion.
  for (int i = 0; i < K_PARTICIONES; i++){
    char filename[50];
    sprintf(filename,"particion%d.txt",i);
    particiones[i] = fopen(filename,"w");
    FILE* archivo_actual = particiones[i];
    size_t i = 0;

    char* linea_actual = NULL; size_t cap_archivo = 0;

    /*
    Esto funciona parecido a la tabla del hash. La idea es tener un array temporal
    de registros, donde cada indice van a ser las lineas que se van a escribir en la particion
    actual. Entonces en cada indice hay un struct con la data necesaria de la linea.
    */
    linea_registro_t** registros = malloc(sizeof(linea_registro_t*)*COTA_LINEAS);

    //Inicializo cada campo del vector de registros.
    for(int i=0;i<COTA_LINEAS;i++){
      registros[i] = crear_registro();
    }

    while(i < COTA_LINEAS && contador_linea < CANTIDAD_LINEAS){
      getline(&linea_actual,&cap_archivo,archivo_log);
      char** registro_actual = split(linea_actual,'\t');
      //printf("%zu\n",strlen(registro_actual[0]));
      //strcpy(registros[i]->ip,registro_actual[0]); //Tira invalid write, nose pq.
      // strcpy(registros[i]->fecha,registro_actual[1]);
      // strcpy(registros[i]->recurso,registro_actual[2]);
      // strcpy(registros[i]->ruta,registro_actual[3]);


      i++,contador_linea++;
      free_strv(registro_actual);
    }
    registro_destruir(registros,COTA_LINEAS);
    /*Despues de tener bien la linea en el vector la idea es
    Hacer primero heapsort con la funcion cmp que hice, y despues
    de hacerle heapsort a ese vector, escribirlo en las k particiones.*/
    free(linea_actual);
    fclose(archivo_actual);
  }
  fclose(archivo_log);

}






int main(int argc, char* argv[]){

  const char* archivo_log = argv[1];
  const size_t memoria = atoi(argv[2]);
  if(memoria<=0){
    fprintf(stderr,"Parametro memoria incorrecto");
  }
  ordenar_archivo(archivo_log,memoria);
  return 0;
}