#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"

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 cargar_registro(linea_registro_t* registro,char* linea){
  char** campos = split(linea,'\t');
  registro->ip=strdup(campos[0]);
  registro->fecha=strdup(campos[1]);
  registro->recurso=strdup(campos[2]);
  registro->ruta=strdup(campos[3]);
  free_strv(campos);
}

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);
}

/*Esta funcion se encarga de cargar una particion con sus K lineas correspondientes.*/
void cargar_particion(FILE* log_original,FILE* particion,size_t K_LINEAS){
  printf("---CARGAR PARTICION---\n\n");
  linea_registro_t** lineas_particion;
  lineas_particion = malloc(sizeof(linea_registro_t*)*K_LINEAS);
  char* linea=NULL;
  size_t tam_linea = 0;
  for(size_t l=0; l<K_LINEAS && (getline(&linea,&tam_linea,log_original)!=-1);l++){
        lineas_particion[l] = crear_registro();
        cargar_registro(lineas_particion[l],linea);
        printf("%s ",lineas_particion[l]->ip);
        printf("%s\n",lineas_particion[l]->fecha);
  }
  free(linea);
  registro_destruir(lineas_particion,K_LINEAS);
}

void ordenar_archivo(const char* archivo, size_t memoria){

  FILE* log_original = fopen(archivo,"r");
  if(!log_original) return;
  //Cuento las lineas y la linea mas grande.
  size_t cantidad_lineas_archivo = 0;
  size_t tam_max_linea = 0;


  char* linea=NULL;
  size_t tam_linea = 0;
  while(getline(&linea,&tam_linea,log_original)!=-1){
      if(tam_linea>tam_max_linea) tam_max_linea=tam_linea;
      cantidad_lineas_archivo++;
  }

  free(linea);
  size_t K_PARTICIONES = memoria / tam_max_linea;
  size_t K_LINEAS = (cantidad_lineas_archivo / K_PARTICIONES ) + 1;
  fseek( log_original, 0, SEEK_SET );

  //Hago un vector de particiones  y  c/u lo cargo con K lineas.
  FILE* particiones_temporales[K_PARTICIONES];


  for(size_t i = 0 ;i<K_PARTICIONES;i++){
    char filename[50];
    sprintf(filename,"particion%zu.bin",i);
    printf("%s\n",filename);
    particiones_temporales[i] = fopen(filename,"wb");

    cargar_particion(log_original,particiones_temporales[i],K_LINEAS);

    fclose(particiones_temporales[i]);
  }
  fclose(log_original);
}









int main(int argc, char* argv[]){
    if(argc !=3){
      fprintf(stderr, "Cantidad de parametros erronea\n");
      return 1;
    }

    const char* archivo_log = argv[1];
    const size_t memoria = atoi(argv[2]);

    if(memoria==0){
      fprintf(stderr,"Parametro memoria incorrecto");
      return 0;
    }

    ordenar_archivo(archivo_log,memoria);

    return 0;
}