#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "TpFinal.h"


void Leer_Datos(emisora_t **d,const char* nombre_archivo,uint32_t *longitud)
{

    uint8_t i=0; //Cantidad de paquetes
    uint8_t *data_Completa=NULL;
    uint8_t Size=0;
    FILE *f = fopen(nombre_archivo,"rb");  //Abro un archivo binario para lectura
    if(f == NULL)                          // si f es distinto de NULL se abre el archivo
    {
        perror("No existe carpeta");
        exit(1);                           // termina el programa con un código de error
    }

            while (getc(f)!=EOF)           //getc retorta EOF si llega al final del archivo
        {
            fseek(f,-1,1);                 // Posiciono el puntero en el archivo
            fread(&(*d)->dato.H1,sizeof(uint8_t),1,f); //Recupero los datos
            if((*d)->dato.H1=='<')              //Arranco la lectura si H1 corresponde a '<'
            {
                fread(&(*d)->dato.id,sizeof(uint8_t),1,f);
                i=(*d)->dato.id;
                fread(&(*d)->dato.dest,sizeof(uint8_t),1,f);
                if((*d)->dato.dest==1)          //Sigo la lectura solo si el destinatario corresponde a 1
                {
                     if (*longitud<(*d)->dato.id) //Realoco memoria cada vez que agrego un paquete con un id mayor.
                     {
                         *longitud=(*d)->dato.id;
                          realocacion_memoria_struct(d,*longitud);
                     }
                fread(&(*d)[i-1].dato.Size,sizeof(uint8_t),1,f);
                Size=(*d)[i-1].dato.Size+3; //Agrego los bytes del CRC
                Reservar_Memoria_Data(&(*d)[i-1].data,(*d)[i-1].dato.Size);
                fread((*d)[i-1].data,sizeof(uint8_t),(*d)[i-1].dato.Size,f);
                fread(&(*d)[i-1].crc,sizeof(uint16_t),1,f);
                data_Completa = (uint8_t *)calloc(Size,sizeof(uint8_t));

                data_Completa[0] = i;
                data_Completa[1] = (*d)->dato.dest;
                data_Completa[2] = (*d)[i-1].dato.Size;


                for (int l=3;l<Size;l++)
                {
                    data_Completa[l] = (*d)[i-1].data[l-3];
                }


                //strcat(data_Completa,); //+1
                //strcat(data_Completa,&(*d)[i-1].data); //+size


                //strcat(data_Completa,d[i-1]->dato.dest);
                /*
                for(int k=0;k<Size;k++)
                {
                     printf("data_Completa %d\n",data_Completa[k]);

                }
                */
                //printf("\n");
                (*d)[i-1].crc_comprobar=calculate_checksum(data_Completa,Size);
                fread(&(*d)->dato.H2,sizeof(uint8_t),1,f);
                //Uso el siguiente printf para ver si dan iguales o no
                // printf("\ni=%d, crc_comprobar= %d, crc data= %d ",i,(*d)[i-1].crc_comprobar,(*d)[i-1].crc);
                //PaqBorrado=Comprobar_CRC(*d,longitud,CRC_Comprobar,i,PaqBorrado);
                //printf("paq=%d",PaqBorrado);
               /* if((*d)[i-1].crc_comprobar!=0)
        {
            PaqBorrado = PaqBorrado +1;
                    for (int x = i;x<*longitud;x++)
                    {
                        d[x-1]->data= d[x]->data; //piso los valores desde el siguiente
                    }
                }*/
        }
             }

            }
}

//Funcion no necesaria para ejecutar el programa. Muestra en forma organizada los datos
void Mostrar_Paquetes(emisora_t *d,uint32_t longitud)
{
        printf("Mostrar_Paquetes: \n");
          for(int i=0;i<longitud+1;i++)
          {

            printf("\n\n ID= %u, Size= %u, CRCCOM= %u CRC= %u\n",i,d[i-1].dato.Size,(d)[i-1].crc_comprobar,(d)[i-1].crc);

             if((d)[i-1].crc_comprobar==(d)[i-1].crc)
             {

                for (int j=0;j<d[i-1].dato.Size;j++)
                {

                    printf("data = (%u)%u ",j+1,d[i-1].data[j]);
                }
              }


          }
}

//VERIFICACION CRC
void calculate_checksum_ptr(uint8_t input[], uint16_t length, uint16_t *result)
{
    static int16_t CRCPoly = 0xA001;
    static uint16_t i = 0;
    static uint8_t j = 0;
    static uint8_t data = 0;
    static uint8_t result_bit = 0;
    static uint8_t data_bit = 0;

    // for every byte
    for (i = 0; i < length; i++) {
        data = input[i];
        // for every bit
        for (j = 0; j < 8; j++) {
            result_bit = *result & 0x1;    // get LSbit
            *result = *result >> 1;        // shift down
            data_bit = data & 0x1;        // get LSbit
            data = data >> 1;            // shift down
            if (result_bit != data_bit) {
                *result = *result ^ CRCPoly;
            }
        }
    }
}

uint16_t calculate_checksum(uint8_t input[], uint16_t length)
{
    uint16_t checksum = 0;

    calculate_checksum_ptr(input, length, &checksum);




    return checksum;
}
/*
uint8_t Comprobar_CRC(emisora_t *d,uint32_t *longitud,uint16_t CRC_Comprobar,uint8_t i,uint8_t PaqBorrado)
{

         if(CRC_Comprobar!=0)  //Si retorta un valor distinto de cero, se descarta el paquete.
                {
                    printf("crc_comprobar=%d",CRC_Comprobar);
                    PaqBorrado=PaqBorrado+1;
                    //printf("Se descarta el paquete debido a que no cumple la verificación por redundancia cíclica1(CRC)");
                    for (uint8_t x = i;x<*longitud;x++)
                    {
                         printf("%d",d[i-1].data[x]);
                        d[x-1].data = d[x].data; //piso los valores desde el siguiente



                      //  d[x].data = d[x+1].data; //piso los valores desde el siguiente
                    }

                }
                return PaqBorrado;
}*/
void grabar_archivo_bmp(emisora_t *d, uint32_t longitud,char* nombre_archivo)
{
    FILE *f = fopen(nombre_archivo,"wb"); //Creo un archivo binario para escritura.
    if (f==NULL)
    {
        printf("No se puede abrir.\n");
    }
    else
    {
        for(int i=0; i<longitud+1; i++)
        {
             if(d[i-1].crc_comprobar==0)
             {
                 for (int j=0; j<d[i-1].dato.Size; j++)
                  {
                      printf("(%u)%u ",j+1,d[i-1].data[j]);
                      fwrite(&d[i-1].data[j], sizeof(uint8_t),d[i-1].dato.Size, f); //Guardo los datos en el archivo bmp
                  }
             }
        }
    }
    fclose(f);

}
//Funcion para eliminar dentro de cada paquete cuando aparecen los simbolos '<' '>' dobles
void Eliminar_doble(emisora_t *d,uint32_t longitud)
{
    int cantidadBorrados = 0; //Declaro variable para luego modificar el Size
    for(int i=0; i<longitud+1; i++)
    {
        cantidadBorrados = 0;
        for (int j=0; j<d[i-1].dato.Size; j++)
        {
            if ((d[i-1].data[j]==60)||(d[i-1].data[j]==62)) //Busco la aparicion de '<' '>'
            {
                if ((d[i-1].data[j] == d[i-1].data[j+1]) && (j<d[i-1].dato.Size)) //Veo si el elemento que sigue es igual al actual y que el contador sea menor al Size
                {
                    cantidadBorrados = cantidadBorrados +1;
                    for (int x = j;x<d[i-1].dato.Size-1;x++)
                    {
                        d[i-1].data[x] = d[i-1].data[x+1]; //piso los valores desde el siguiente
                    }
                }
            }
        }
        if (cantidadBorrados>0) //si se borraron elementos, modifico el tamaño del paquete
        {
            d[i-1].dato.Size = d[i-1].dato.Size - cantidadBorrados;
        }
    }

}