#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <utils.h>
/* DEFINE*/
#define FMTFLOAT "%5.15f"
#define INMEMORY_SAMPLE


/* in-memory buffer for traces */
double sample[SPL_SIZE][NBMAX_SAMPLE];
static double Time = 0.0;
static unsigned int maxSimSample=NBMAX_SAMPLE;

/*------------------------------------------------- getValueFromFile  -----
         |  Function getValueFromFile
         |
         |  Purpose: Read a formatted matrix (size X sizeCol) where the first column contain           
         |timestamps, the others data values needed by inputs. The file filename is open if exist and 
         |then values are loaded in tab, the number of line is written in the file. Then the function 
         |behaves link a zero holder, i.e it compare the next timestamp to current time and if match 
         |then load the new values (the line) in outs, otherwise keeps last values. Since the last line 
         |is reached, the conresponding values will be returned in out forever. If the file could not 
         |be open the function will always send the init values.
         |
         |  Parameters:
         |      -char* filename: IN name of the data file
         |      -double tab[2][NBMAX_SAMPLE]: OUT storing tab for matrix, notice that first dimension should 
         |       be the same as sizeCol
         |      -double init: IN init value of out
         |      -int* last_sample: OUT last sample index
         |      -double* opened: OUT file store state indicator, 0:NOT_OPEN_YET, 1:OPEN_SUCESS, 2:OPEN_FAIL
         |      -int * size OUT: nb of matrix lines
         |      -FILE** fichier: OUT file descriptor obtained after opening
         |      - int sizeCol: IN nb of matrix column
         |      - double out[]: OUT current values of line (last_sample) without timestamp
         |
         *-------------------------------------------------------------------*/
void getValueFromFile(char* fileName, double tab[2][NBMAX_SAMPLE], double init, int* last_sample, double* opened, int * size, FILE** fichier, int sizeCol, double out[]){
 if(fileName==NULL || tab==NULL || last_sample==NULL || opened==NULL || size==NULL || fichier==NULL){
    memcpy(&(out[0]),&init,sizeof(double)*(sizeCol-1));
    return;
 }
 if(*opened==0){
   *fichier=fopen(fileName,"r");
   if (*fichier != NULL)
   {
       fscanf(*fichier,"%d\n",size);
       for(int i=0; i<*size && i<NBMAX_SAMPLE; i++){
          for(int j=0; j<(sizeCol-1); j++) {
            fscanf(*fichier,"%lf ",&(tab[j][i]));
          }
          fscanf(*fichier,"%lf\n",&(tab[sizeCol-1][i]));
       }
       fclose(*fichier);
       *opened=1;
   }
   else
   {
       printf("%s:No such file\n",fileName);
       *opened=2;
   }
 }
 if (*opened==1)
 {
   if((*last_sample+1)<NBMAX_SAMPLE  && (*last_sample+1)<*size)
   {
     if(Time>=tab[0][*last_sample+1])
     {
        *last_sample=*last_sample+1;
     }
   }
   for(int i=1; i<sizeCol; i++){
     out[i-1]=tab[i][*last_sample];
   }
 }
 else
 {
   for(int i=0; i<(sizeCol-1); i++){
    out[i]=init;
   }
 }
}


/*------------------------------------------------- getOptSimu -----
         |  Function getOptSimu
         |
         |  Purpose:  Read a Option simu formatted file and return the parameters
         |
         |  Parameters:
         |      - double out[] : OUT: array containing the options values
         |      - FILE** fichier : IN: file descriptor 
         |      - int optNb : IN : number of options in the formatted file
         |      - char *fileName: IN: name of the option file to read
         |
         *-------------------------------------------------------------------*/
void getOptSimu(unsigned int out[], FILE** fichier, int optNb ,char *fileName){
   *fichier=fopen(fileName,"r");
   if (*fichier != NULL)
   {
       for(int j=0; j<(optNb-1); j++) {
          fscanf(*fichier,"%d ",&(out[j]));
       }
       fscanf(*fichier,"%d\n",&(out[optNb-1]));
       out[0]=(out[0]>NBMAX_SAMPLE)? NBMAX_SAMPLE : out[0];
       fclose(*fichier);
   }
   else
   {
       printf("%s:No such file\n",fileName); 
   }
}


/*------------------------------------------------- print_inmemory_sample -----
         |  Function print_inmemory_sample() 
         |
         |  Purpose:  write the array sample[] in the file LOG_FILE Matlab formatted
         |
         *-------------------------------------------------------------------*/
void print_inmemory_sample() {
    FILE* fichier = NULL;
    fichier = fopen(LOG_FILE , "w+");
    if (fichier != NULL)
    {
        fprintf(fichier,"Data=[\n");
        for (int i=0;i<maxSimSample;i++) {
            fprintf(fichier," %3.4f ",sample[SPL_T][i]); 
            for (int j=1; j<SPL_SIZE; j++){
              fprintf(fichier," "FMTFLOAT " ",sample[j][i]);
            } 
            fprintf(fichier,"\n");
        }
        fprintf(fichier,"]");
        fclose(fichier);
    }
    else
    {
       printf("Failed opening %s file ",LOG_FILE);
    }
}


/*------------------------------------------------- print_simulator_outs_t -----
         |  Function print_simulator_outs_t
         |
         |  Purpose:  save the output of aircraft dynamics node in the array sample[]
         |
         |  Parameters:
         |      struct aircraft_dynamics_outs_t *outputs: IN : pointer of aircraft data structure containing current flight data
         |
         *-------------------------------------------------------------------*/
void print_simulator_outs_t(double outputs, SampleRank_t numCol) {
  static int cpt=0;
  static int deb=1;
  static FILE* optFile=NULL;
  static unsigned int sample_instant=0;
  if(deb==1){
    getOptSimu(&maxSimSample, &optFile, 1 ,SIMU_OPT_FILE);
    deb=0;
  }
#ifdef INMEMORY_SAMPLE
  if(sample_instant<maxSimSample){
    sample[numCol][sample_instant]=outputs;
    sample[SPL_T][sample_instant]=Time;
#ifndef NO_PRINT
    printf("Time: %lf ,output %d: "FMTFLOAT"\n",Time,numCol,outputs);
    //printf("DEBUG: sample_instant=%d\n",sample_instant);
#endif
  }
  else if(sample_instant==maxSimSample) {
    print_inmemory_sample();
    Time+=DT;
#ifndef NO_PRINT
    printf("simulation finished\n");
#endif
  }   
#endif
  cpt+=1;
  if(cpt==SPL_SIZE-1){
    Time+=DT;
    sample_instant++;
    cpt=0;
  }
  
}