#include "fonctions_socket.h"

char ack[4]="ACK\0";
char syn_ack[8]="SYN-ACK\0";
char fin[4]="FIN\0";
char syn[4]="SYN\0";

int puissance(int x, int n){
  if(n==0){
    return 1;
  }
  else{
    return x*puissance(x,n-1);
  }
}

double val_absolue(double a){
  if(a<0){
    return (a*(-1));
  }
  else {
    return a;
  }
}

double SRTT(double RTT,double SRTT){
  return (0.9*SRTT+0.1*RTT);
}

double RTTVAR(double SRTT, double RTT, double RTTVAR){
  return ((1-(1/4))*RTTVAR+(1/4)*val_absolue(SRTT-RTT));
}


double max_element(double var1,double var2){
  if (var1>var2){
    return var1;
  } else {
    return var2;
  }
}


int digit_to_int(char d)
{
 char str[2];

 str[0] = d;
 str[1] = '\0';
 return (int) strtol(str, NULL, 10);
}

int isIn(int tab[], int val, int size){ //return index of value et -1 if not
  int i;
  for(i=0;i<size;i++)
  {
    if(tab[i]==val)
    {
      return i;
    }
  }
  return -1;
}

int ackGood(int tab[],int size){ //return index of ack missing and -1 if good
  int i;
  for(i=0;i<size;i++)
  {
    if(tab[i]>0)
    {
      return i;
    }
  }
  return -1;
}

int main(int argc, char const *argv[])
{
  char connect[1024];
  int port=1025;
  int socket = createSocketUDP();
  struct sockaddr_in addr = setIP("0.0.0.0", strtol(argv[1],NULL,10));
  int taille = sizeof(addr);
  reuseSocket(socket);
  bind(socket, (struct sockaddr*)&addr, sizeof(struct sockaddr));
  /*
            MODE CONNECTE
  */
  while(1)
  {
    port++;
    int r = recvfrom(socket, &connect, sizeof(connect), 0, (struct sockaddr*)&addr, &taille);
    printf("MESSAGE %d octets = %s\n", r, connect);
    int sockFils = createSocketUDP();
    int portFils;
    struct sockaddr_in fils;

    fils = setIP("0.0.0.0", port);
    bind(sockFils, (struct sockaddr*)&fils, sizeof(struct sockaddr));

    getsockname(sockFils, (struct sockaddr *)&fils, &taille);
    portFils = ntohs(fils.sin_port);


    printf("Port =  %d\n", ntohs(fils.sin_port));
    printf("message=%s\n",connect);
    if (strcmp(connect,syn) == 0)
    {
      char connect[MAX_LENGTH] = "SYN-ACK";
      char port[10];
      sprintf(port, "%d", portFils);
      strcat(connect, port);
      int s = sendto(socket, &connect, strlen(connect)+1, 0, (struct sockaddr*)&addr, taille);
      if (s >= 0)
      {
        printf("Message envoyé %d octets !\n", s);
      }
      else
      {
          printf("Message non envoyé !\n");
      }
    }
    r = recvfrom(socket, &connect, sizeof(connect), 0, (struct sockaddr*)&addr, &taille);
    printf("MESSAGE %d octets = %s\n", r, connect);

    if (strcmp(connect,"ACK") == 0)
    {
      printf("ACK connexion réussie !\n");
    }

    int pid = fork();
    if(pid == 0)
    {
      //CODE DU FILS
      clock_t start;
      clock_t end;
      double rtt=200;
      double srtt=200;
      double rttvar=rtt/2;

      double rto=rtt+max_element(4*rttvar,1);

      struct timeval timeout;
      timeout.tv_sec=0;
      //timeout.tv_usec=200;
      char msg[MAX_LENGTH];
      char pathFile[FILE_SIZE];
      char numSeq[6];

      int i;
      for(i=0;i<5;i++){
        numSeq[i]='0';
      }
      numSeq[5]='1';
      char buffer[1024];
      int sequence=1;
      int cwd = 10;
      int nbelem;

      int size_paquet = 1024;

      r = recvfrom(sockFils, &connect, sizeof(connect), 0, (struct sockaddr*)&addr, &taille);

      memset(pathFile,0,sizeof(pathFile));
      strcat(pathFile,"./");
      strcat(pathFile,connect);

      FILE* file = fopen(pathFile, "rb");
      fseek(file, 0, SEEK_END);
      int size_file = ftell(file);
      fseek(file, 0, SEEK_SET);
      rewind(file);


      if(file == NULL)
      {
        printf("ERREUR OUVERTURE FICHIER !\n");
        exit(-1);
      }

      int c, d, out;
      int seq[cwd];
      int verif[cwd];
      int ack[cwd];
      int indice, indice1, indice2, indice3, indice4;
      int nbpaquet = size_file/1024;
      fd_set ecouteur;
      int res_select;
      int acquittement;

      printf("\n~~~~~~~~~~~~~~ ENVOI ~~~~~~~~~~~~\n");
      cwd = 3;
      while(sequence <= nbpaquet)
      {
        printf("SEQUENCE : %d\n\n", sequence);
        for(c = 0; c < cwd; c++)
        {
          seq[c] = sequence + c;
          verif[c] = 1;

          memset(numSeq, 0, sizeof(numSeq));
          sprintf(numSeq,"%d",seq[c]);
          int strlenSeq=strlen(numSeq);
          int i;
          memset(numSeq, 0, sizeof(numSeq));
          for(i=0;i<(6-strlenSeq);i++){
            numSeq[i]='0';
          }
          char newSeq[strlenSeq];
          sprintf(newSeq,"%d",seq[c]);
          strcat(numSeq,newSeq);

          memset(msg, 0, sizeof(msg));
          memset(buffer,0,sizeof(buffer));
          memcpy(&msg,&numSeq,sizeof(numSeq));


          nbelem = fread(buffer, 1024, 1, file);
          if(nbelem==1)
          {
            size_paquet=1024;
          }
          else
          {
            size_paquet=size_file%1024;
            //cwd = c;
          }
          printf("size_paquet = %d\n", size_paquet);

          memcpy(&msg[6],&buffer,size_paquet);
          //start=clock();
          int s = sendto(sockFils, &(msg), (size_paquet+6), 0, (struct sockaddr*)&addr, taille);
          printf("MESSAGE ENVOYE ! Sequence = %d\n", seq[c]);
        }

        d = 1;
        out = 0;
        while((d <= cwd) && (out == 0))
        {
          printf("d vaut %d\n", d);
          timeout.tv_usec=1000000;
          FD_ZERO(&ecouteur);
          FD_SET(sockFils,&ecouteur);
          res_select=select((sockFils+1),&ecouteur,NULL,NULL, &timeout);


          if(!res_select)
          {
            indice1 = ackGood(verif, cwd);
            if(indice1 >= 0)
            {
              fseek(file,-(size_paquet*(cwd-indice1)),SEEK_CUR);
              printf("Time out\n");
              sequence = seq[indice1];
              printf("New seq time out = %d\n", sequence);
              out = 1;
            }
            else
            {
              out = 0;
              sequence = seq[cwd-1]+1;
            }
          }
          else
          {
            r = recvfrom(sockFils, &msg, sizeof(msg), 0, (struct sockaddr*)&addr, &taille);
            //end=clock();
            /*rtt=(double)(end-start)/(CLOCKS_PER_SEC);
            rtt=rtt*1000000;
            srtt=SRTT(rtt,srtt);
            rttvar=RTTVAR(srtt,rtt,rttvar);
            rto=srtt+max_element(1,4*rttvar);*/

            acquittement=0;
            for(i=3;i<9;i++){
              acquittement=acquittement + puissance(10,i-3)*digit_to_int(msg[8+3-i]);
            }
            ack[d] = acquittement;
            if (acquittement == seq[cwd-1])
            {
              sequence = seq[cwd-1]+1;
              for(i=0; i<cwd; i++)
              {
                verif[i] = 0;
              }
              d = cwd;
              out = 1;
            }
            printf("ACK n° %d reçu ! \n", acquittement);
            indice2 = isIn(seq,acquittement,cwd);
            if(indice2 >= 0 && acquittement != seq[cwd-1])
            {
              for(i=0; i<=indice2; i++)
              {
                verif[i] = 0;
              }
              d++;
              printf("INDICE isIN ACK = %d\n", indice2);
            }
            else
            {
              indice3 = ackGood(verif, cwd);
              if(indice3 >=0)
              {
                fseek(file,-(size_paquet*(cwd-indice3)),SEEK_CUR);
                sequence = seq[indice3];
                printf("INDICE = %d\n", indice3);
                printf("Revenons à la sequence n° %d\n", sequence);
                out = 1;
              }
              else
              {
                sequence = seq[cwd-1]+1;
                printf("Nouvelle sequence = %d (sortie de boucle)\n", sequence);
              }
            }
          }
        }
        if(out == 0)
        {
          indice4 = ackGood(verif, cwd);
          if(indice4 >= 0)
          {
            fseek(file,-(size_paquet*(cwd-indice4)),SEEK_CUR);
            sequence = seq[indice4];
            printf("INDICE = %d\n", indice4);
            printf("Revenons à la sequence n° %d (sortie de boucle)\n", sequence);
          }
          else
          {
            sequence = seq[cwd-1]+1;
            printf("Nouvelle sequence = %d (sortie de boucle)\n", sequence);
          }
        }
      }
      printf("Envoi de fin !\n");
      int k;
      for(k=0;k<100000;k++)
      {
        int s = sendto(socket, &fin, strlen(fin)+1, 0, (struct sockaddr*)&addr, taille);
      }
      fclose(file);
      exit(0);
    }
  }
  return 0;
}