/************************************
 * Converts KmaxNT edf to ASCII txt *
 *                                  *
 *     written by Leif              *
 *----------------------------------*
 *           5 Mar 2001 (Leif)
 *          28 Jun 2001 (Leif) - made better use of evSize and blkCount for looping reads
 *           6 Jul 2001 (Leif) - created separate functions for various edf formats
 *          17 Aug 2001 (Leif) - added formatcode -4
 *          30 Aug 2001 (Leif) - added formatcode -5
 ************************************/

/*
(1) things may screw up when a module wrote NO data but still wrote its module header (not format -5)
(2) -1 shouldn't be used as format code since it's used as event delimiter
(3) assumption for format -5: no module produces data 8 items long (any evSize=8 assumed
	to be -1, ms, date, time)
 */


#include <stdio.h>
#include <stdlib.h>


/* short = 2 bytes (16 bits) */
/* int   = 4 bytes (32 bits) */


#define format2Code -666
#define format3Code -4
#define format4Code -5



int ReadFormat1 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter);
int ReadFormat2 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter);
int ReadFormat3 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter);
int ReadFormat4 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter);
int ReadBlockHeader (short *evSize,	// number of "rows" (i.e., parameters) in each "column" of block
		     short *blkEvType,	// number of event (i.e., CSL function) that wrote this block
		     int *blkCount,	// number of "columns" in block
		     FILE *edfFile);	// file pointer to edf file



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

   if (argc != 2)
      printf ("\nUsage: edf2txt <edfFile>\n\n"
              "\t<edfFile>\tedf file (input) to convert to text\n\n"
              "\tText file (output) name will be the same as edf file.\n\n");
   else
   {
      char answer, textName[80];
      short i, j, OK=1;

      /* figure out name of text file (dropping ".edf" and adding ".txt") */
      for (i=0; i<strlen(argv[1])-4; ++i)
         textName[i] = argv[1][i];
      textName[i++] = '.';
      textName[i++] = 't';
      textName[i++] = 'x';
      textName[i++] = 't';
      textName[i] = '\0';

      /* ask user about file name */
//      printf ("\nText file will be \"%s\", okay? (Y/N) ", textName);
//      scanf ("%c", &answer);
//      while (getchar ()!= '\n') {}
      printf ("\nText file will be \"%s\"\n\n", textName);
      answer = 'Y';

      /* if user is okay with it */
      if (toupper (answer) == 'Y')
      {
         short  dummy, numRead;
         FILE   *textFile;

         /* check if text file exists already */
         /* open as read only (to not overwrite) */
         textFile = fopen (textName, "r");
         if (textFile != NULL)
         {
            printf ("File exists already. Overwrite? (Y/N) ");
            scanf ("%c", &answer);
            while (getchar ()!= '\n') {}
            if (toupper (answer) == 'N')
               OK = 0;

            fclose (textFile);
         }

         /* check if edf exists */
         edfFile = fopen (argv[1], "rb");	// read binary file
         if (edfFile == NULL)
         {
            OK = 0;
            printf ("\n\"%s\" does not exist.\n", argv[1]);
         }

         /* if user is okay with overwriting existing text file */
         if (OK)
         {
            short		// [16 bits]
                  blkEvType,	// number of Kmax event that wrote the parameters in the block
                  evSize;	// number of parameters per line in the block
            int			// [32 bits]
                  blkCount,	// number of lines of parameters in the block
                  parameter;

            textFile = fopen (textName, "w");	// write text file (open as write file this time)

            /* read event file 512-byte header */
            i = 0;
            while (i<256)			// because (short) dummy is 2 bytes
            {
               numRead = fread (&dummy, sizeof(short), 1, edfFile);
               ++i;
            }

            numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

            /* if block written by first user event (WriteFileHeader) */
            /* hopefully, no edf will accidentally have this format except for format code */
            if (blkEvType == 6  &&  evSize == 1  && blkCount == 1)
            {
               fread (&parameter, sizeof(int), 1, edfFile);
               if (parameter == format2Code)		// code for format of tdc & adc
                  ReadFormat2 (edfFile, textFile, evSize, blkEvType, blkCount, parameter);

               else if (parameter == format3Code)	// code for format of tdc05.tsh
                  ReadFormat3 (edfFile, textFile, evSize, blkEvType, blkCount, parameter);

               else if (parameter == format4Code)	// code for format of tdc06.tsh
                  ReadFormat4 (edfFile, textFile, evSize, blkEvType, blkCount, parameter);

               /* other if stmts for file format codes go here */

               else
               {
                  printf ("\n\n***ERROR!*** Incompatible edf format!\n"
                          "\tFirst edf block must be one of 2 types:\n"
                          "\t\t(1) if blkEvType = 6, evSize = 1, blkCount = 1,\n"
                          "\t\t    then parameter MUST = negative number known by edf2txt\n"
                          "\t\t(2) anything else with at least\n"
                          "\t\t    1 of first 3 conditions listed in (1) not met\n");
                  OK = 0;
               }
            }
            else				// old edf format (to deal with edf's without format code)
            {
               ReadFormat1 (edfFile, textFile, evSize, blkEvType, blkCount, parameter);
            }

            /* now all that's left to read are the closing 8-byte event file footer (ignored) */
            /* (0xFFFFFFFF, 0xFFFFFFFF) */

            fclose (edfFile);
            fclose (textFile);
         }
      }
      /* if user is not ok with text file name */
      else
         OK = 0;

      if (!OK)
         printf ("\nNothing done. Game over.\n");
      else
         printf ("\nText file \"%s\" created happily.\n", textName);
   }

   return 0;
}




/*---------------------------------------------------------*
 *  ReadFormat1 : read from edf with old adc-only format
 *			and write to text file
 *---------------------------------------------------------*/
int ReadFormat1 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter)
{
   int i, j, numRead=3;

   /* loop over all blocks */
   while (numRead != 0)
   {
      for (j=0; j<blkCount; ++j)
      {
         for (i=0; i<evSize && numRead!=0; ++i)
         {
            numRead = fread (&parameter, sizeof(int), 1, edfFile);
            fprintf (textFile, "%d ", parameter);
         }
         fprintf (textFile, "\n");
      }

      numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
   }

   /* 19 0's for sentinel line */
   fprintf (textFile, "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n");

   return 1;
}



/*---------------------------------------------------------*
 *  ReadFormat2 : read from edf with tdc and adc format
 *			and write to text file
 *---------------------------------------------------------*/
int ReadFormat2 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter)
{
   int i, j, numRead, inum, imodNum, islotNum,
       itimer, ims, iyr, imo, iday, ihr, imin, isec;

   numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

   /* read SRQ block collection marker */
   numRead = fread (&inum, sizeof(int), 1, edfFile);


   /* loop over all SRQ block collections (groups of ADC and TDC data) */
   while (numRead != 0  &&  inum == -1)
   {
      /* read time */
      numRead = fread (&itimer, sizeof(int), 1, edfFile);

      /* early versions had 2 data for the milliseconds */
      if (evSize==10)
         numRead = fread (&ims, sizeof(int), 1, edfFile);
      numRead = fread (&ims, sizeof(int), 1, edfFile);

      numRead = fread (&iyr, sizeof(int), 1, edfFile);
      numRead = fread (&imo, sizeof(int), 1, edfFile);
      numRead = fread (&iday, sizeof(int), 1, edfFile);
      numRead = fread (&ihr, sizeof(int), 1, edfFile);
      numRead = fread (&imin, sizeof(int), 1, edfFile);
      numRead = fread (&isec, sizeof(int), 1, edfFile);
      fprintf (textFile, "%d %d %d %d %d %d %d %d \n", itimer, ims, iyr, imo, iday, ihr, imin, isec);

      numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

      /* loop over all ADC & TDC modules */
      while (evSize == 2  &&  numRead != 0)
      {
         /* read in module number & slot number */
         numRead = fread (&imodNum, sizeof(int), 1, edfFile);
         numRead = fread (&islotNum, sizeof(int), 1, edfFile);
         fprintf (textFile, "%d %d ", imodNum, islotNum);

         numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
         fprintf (textFile, "%d %d \n", evSize, blkCount);

         /* loop over a module's data */
         for (j=0; j<blkCount; ++j)
         {
            for (i=0; i<evSize && numRead!=0; ++i)
            {
               numRead = fread (&parameter, sizeof(int), 1, edfFile);
               fprintf (textFile, "%d ", parameter);
            }
            fprintf (textFile, "\n");
         }

         numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
      }
      fprintf (textFile, "-1 -1 -1 -1 \n");

      /* read SRQ block collection marker */
      numRead = fread (&inum, sizeof(int), 1, edfFile);
   }
   fprintf (textFile, "-1 -1 -1 -1 -1 -1 -1 -1 \n");

   return 1;
}



/*---------------------------------------------------------*
 *  ReadFormat3 : read from edf with tdc and adc format
 *			and write to text file
 *---------------------------------------------------------*/
int ReadFormat3 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter)
{
   int i, j, numRead, inum, imodNum, islotNum,
       itimer, ims, iyr, imo, iday, ihr, imin, isec;

   /* read header for date */
   numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
   //evSize = 6; blkEvType = 7; blkCount = 1
   if (evSize != 6  ||  blkCount != 1)
      return 0;

   /* read time */
   numRead = fread (&iyr, sizeof(int), 1, edfFile);
   numRead = fread (&imo, sizeof(int), 1, edfFile);
   numRead = fread (&iday, sizeof(int), 1, edfFile);
   numRead = fread (&ihr, sizeof(int), 1, edfFile);
   numRead = fread (&imin, sizeof(int), 1, edfFile);
   numRead = fread (&isec, sizeof(int), 1, edfFile);
   fprintf (textFile, "%d %d %d %d %d %d \n", iyr, imo, iday, ihr, imin, isec);

   /* read header for -1, timer, milliseconds */
   numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

   /* read SRQ block collection marker (-1) */
   numRead = fread (&inum, sizeof(int), 1, edfFile);

   /* loop over all SRQ block collections (groups of ADC and TDC data) */
   while (numRead != 0  &&  inum == -1)
   {
      /* read timer, milliseconds */
      numRead = fread (&itimer, sizeof(int), 1, edfFile);
      numRead = fread (&ims, sizeof(int), 1, edfFile);
      fprintf (textFile, "%d %d \n", itimer, ims);

      /* read header for module# and slot# */
      numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

      /* loop over all ADC & TDC modules */
      while (evSize == 2  &&  numRead != 0)
      {
         /* read module# and slot# */
         numRead = fread (&imodNum, sizeof(int), 1, edfFile);
         numRead = fread (&islotNum, sizeof(int), 1, edfFile);
         fprintf (textFile, "%d %d ", imodNum, islotNum);

         /* read header for module data */
         numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
         fprintf (textFile, "%d %d \n", evSize, blkCount);

         /* loop over a module's data */
         for (j=0; j<blkCount; ++j)
         {
            for (i=0; i<evSize && numRead!=0; ++i)
            {
               numRead = fread (&parameter, sizeof(int), 1, edfFile);
               fprintf (textFile, "%d ", parameter);
            }
            fprintf (textFile, "\n");
         }

         /* read header for next module or for next timer/ms */
         numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
      }
      fprintf (textFile, "-1 -1 -1 -1 \n");

      /* read SRQ block collection marker (-1) */
      numRead = fread (&inum, sizeof(int), 1, edfFile);
   }
   fprintf (textFile, "-1 -1 \n");

   return 1;
}



/*---------------------------------------------------------*
 *  ReadFormat4 : read from edf with tdc and adc format
 *			and write to text file
 *---------------------------------------------------------*/
int ReadFormat4 (FILE *edfFile,		// input file
		 FILE *textFile,	// output file
		 short evSize,		// number of parameters per line in the block
		 short blkEvType,	// number of Kmax event that wrote the parameters in the block
		 int blkCount,		// number of lines of parameters in the block
		 int parameter)
{
   int i, j, numRead, inum, imodNum, islotNum,
       itimer, ims, iyr, imo, iday, ihr, imin, isec;

   /* read header for -1, milliseconds, date, time */
   numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

   /* read SRQ block collection marker (-1) */
   numRead = fread (&inum, sizeof(int), 1, edfFile);

   /* loop over all SRQ block collections (groups of ADC and TDC data) */
   while (numRead != 0  &&  inum == -1)
   {
      /* read milliseconds, date, time */
      numRead = fread (&ims,  sizeof(int), 1, edfFile);
      numRead = fread (&iyr,  sizeof(int), 1, edfFile);
      numRead = fread (&imo,  sizeof(int), 1, edfFile);
      numRead = fread (&iday, sizeof(int), 1, edfFile);
      numRead = fread (&ihr,  sizeof(int), 1, edfFile);
      numRead = fread (&imin, sizeof(int), 1, edfFile);
      numRead = fread (&isec, sizeof(int), 1, edfFile);
      fprintf (textFile, "%d %d %d %d %d %d %d \n", ims, iyr, imo, iday, ihr, imin, isec);

      /* read header for module# and slot# */
      numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

      /* loop over all ADC & TDC modules */
      while (evSize == 2  &&  numRead != 0)
      {
         /* read module# and slot# */
         numRead = fread (&imodNum, sizeof(int), 1, edfFile);
         numRead = fread (&islotNum, sizeof(int), 1, edfFile);
         fprintf (textFile, "%d %d ", imodNum, islotNum);

         /* read header for module data */
         numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);

         /* TDC may not have any data (evSize=8 corresponds to -1, ms, date, time) */
         /* WARNING! a module may eventually come along with 8 data values */
         if (evSize != 8)
         {
            fprintf (textFile, "%d %d \n", evSize, blkCount);

            /* loop over a module's data */
            for (j=0; j<blkCount; ++j)
            {
               for (i=0; i<evSize && numRead!=0; ++i)
               {
                  numRead = fread (&parameter, sizeof(int), 1, edfFile);
                  fprintf (textFile, "%d ", parameter);
               }
               fprintf (textFile, "\n");
            }

            /* read header for next module or for next ms/date/time */
            numRead = ReadBlockHeader (&evSize, &blkEvType, &blkCount, edfFile);
         }
         else
            fprintf (textFile, "0 0 \n");		// for dataless TDC
      }
      fprintf (textFile, "-1 -1 -1 -1 \n");

      /* read SRQ block collection marker (-1) */
      numRead = fread (&inum, sizeof(int), 1, edfFile);
   }
   fprintf (textFile, "-1 -1 -1 -1 -1 -1 -1 \n");

   return 1;
}



/*---------------------------------------------------------*
 *  ReadBlockHeader : read edf block header
 *
 *---------------------------------------------------------*/
int ReadBlockHeader (short *evSize,	// number of "rows" (i.e., parameters) in each "column" of block
		     short *blkEvType,	// number of event (i.e., CSL function) that wrote this block
		     int *blkCount,	// number of "columns" in block
		     FILE *edfFile)	// file pointer to edf file
{
   int numRead;

   /* read block header  */
   numRead = fread (evSize, sizeof(short), 1, edfFile);
   numRead += fread (blkEvType, sizeof(short), 1, edfFile);
   numRead += fread (blkCount, sizeof(int), 1, edfFile);

   return numRead;
}