/*********************************************************************
*
*  Task APT
*
*  CODE 0: Seperate a Master APT file
*  CODE != 0: Write Time Stamped U,B,V TISAN files
*
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <io.h>
#include <time.h>
#include <dos.h>
#include <process.h>
#include <ctype.h>
#include <signal.h>

#include "TISAN.H"

short APTSEP(void);
short APTUBV(void);
char GAPTLINE(char *);

char BUFFER1[1024], BUFFER2[1024];
FILE *INSTR;

main(argc,argv)
short argc;
char *argv[];
   {
   short ERRFLAG=0;
   char INFILE[_MAX_PATH];

   signal(SIGINT,BREAKREQ);

   if (Ztskinit("APT",argv[0])) Zexit(1);
   ZBuildFileName(M_inname,INFILE);

   Zencode(2,"APT     : Opening Input File '%s'\n",INFILE);
   if ((INSTR = Zopen(INFILE,O_readb)) == NULL) Zexit(1);

   if (CODE)
      ERRFLAG = APTUBV();
   else 
      ERRFLAG = APTSEP();

   Zexit(ERRFLAG);
   }

/*********************************************************************
*
* Function to seperate and APT file into source files
*
*/
short APTSEP()
   {
   FILE *OUTSTR;
   short ERRVAL=0, NFLAG=1, I, J;
   char SNAME[11], OUTFILE[_MAX_PATH], *SPNTR;

   while (!feof(INSTR) && !ferror(INSTR))
      {
      if (GAPTLINE(BUFFER1))
         {
         SPNTR=strchr(BUFFER1,0);
         SPNTR -= 10;
         for (J=I=0;I<10;++I)
            {
            if (isalnum((short)*(SPNTR + I)))
               {
               SNAME[J] = *(SPNTR + I);
               ++J;
               }
            }
         SNAME[J]=(char)0;
         strupr(SNAME);

         if ((NFLAG) || (strcmp(OUTNAME,SNAME)))
            {
            if (!NFLAG) Zclose(OUTSTR); else NFLAG=0;
            strnset(OUTNAME,0,9);
            strncpy(OUTNAME,SNAME,8);
            ZBuildFileName(M_outname,OUTFILE);
            Zencode(2,"APT     : Opening Output File '%s'\n",OUTFILE);
            if ((OUTSTR = Zopen(OUTFILE,O_appendb)) == NULL) Zexit(1);
            }
         strcat(BUFFER1,"\r\n");
         if (fputs(BUFFER1,OUTSTR) == EOF)
            {
            Zerror();
            Zclose(INSTR);
            Zclose(OUTSTR);
            Zexit(1);
            }
         }
      }
   if (ferror(INSTR)) ERRVAL=1;
   Zclose(INSTR);
   return(ERRVAL);
   }

/*********************************************************************
*
* Function to Write out U,B,V files from an APT source file
*
*/
short APTUBV()
   {
   FILE *OUTU, *OUTB, *OUTV;
   short ERRVAL=0, NFLAG=1, I;
   char SNAME[31], OUTFILE[_MAX_PATH], *SPNTR;
   double JD, U, B, V;
   struct FILEHDR FileHeader;
   struct TRData DATA;

   FileHeader.type = TR_Data;
   strcpy(OUTCLASS,"U");
   ZBuildFileName(M_outname,OUTFILE);
   Zencode(2,"APT     : Opening U Output File '%s'\n",OUTFILE);
   if (((OUTU = Zopen(OUTFILE,O_writeb)) == NULL) ||
       (Zputhead(OUTU,&FileHeader))) Zexit(1);
   strcpy(OUTCLASS,"B");
   ZBuildFileName(M_outname,OUTFILE);
   Zencode(2,"APT     : Opening B Output File '%s'\n",OUTFILE);
   if (((OUTB = Zopen(OUTFILE,O_writeb)) == NULL) ||
       (Zputhead(OUTB,&FileHeader))) Zexit(1);
   strcpy(OUTCLASS,"V");
   ZBuildFileName(M_outname,OUTFILE);
   Zencode(2,"APT     : Opening V Output File '%s'\n",OUTFILE);
   if (((OUTV = Zopen(OUTFILE,O_writeb)) == NULL) ||
       (Zputhead(OUTV,&FileHeader))) Zexit(1);

   while (!feof(INSTR) && !ferror(INSTR))
      {
      if (GAPTLINE(BUFFER2))
         {
         JD = atof(strtok(BUFFER2," "));
         if (!FACTOR) FACTOR = JD;
         JD -= FACTOR;
         U=B=V=0.;
         for (I=0;I<3;++I)
            {
            U += atof(strtok(NULL," "));
            B += atof(strtok(NULL," "));
            V += atof(strtok(NULL," "));
            }
         for (I=0;I<3;++I) strtok(NULL," "); /* Trash Comp Data */
         SPNTR=strtok(NULL,"\0");
         if (NFLAG>0)
            {
            NFLAG = 0;
            strcpy(SNAME,SPNTR);
            }
         if ((!NFLAG) && (strcmp(SNAME,SPNTR)))
            {
            Zencode(9,"APT     : WARNING! Multiple Sources\n");
            NFLAG = -1;
            }
         U /= 3.;
         B /= 3.;
         V /= 3.;
         DATA.t = JD;
         DATA.y = U;
         if (Zwrite(OUTU,(char *)&DATA,TR_Data))
            {
            Zencode(10,"APT     : Error Writing U File\n");
            Zerror();
            Zexit(1);
            }
         DATA.y = B;
         if (Zwrite(OUTB,(char *)&DATA,TR_Data))
            {
            Zencode(10,"APT     : Error Writing B File\n");
            Zerror();
            Zexit(1);
            }
         DATA.y = V;
         if (Zwrite(OUTV,(char *)&DATA,TR_Data))
            {
            Zencode(10,"APT     : Error Writing V File\n");
            Zerror();
            Zexit(1);
            }
         }
      }
   if (ferror(INSTR)) ERRVAL=1;
   Zclose(INSTR);
   Zclose(OUTU);
   Zclose(OUTB);
   Zclose(OUTV);
   return(ERRVAL);
   }

/*********************************************************************
*
* Function to get 1 line of APT data
*
*/
char GAPTLINE(PNTR)
char *PNTR;
   {
   short I=0;
   char C;

   do {
      C = fgetc(INSTR);
      if ((!I) && (C == 10)) continue;
      if ((C == 13) || (C == 10) || (feof(INSTR)) || (ferror(INSTR)))
         C = 0;
      *(PNTR + I) = C;
      ++I;
      }
   while (C);
   if (feof(INSTR) || ferror(INSTR)) *PNTR=0;
   return(*PNTR);
   }

/***************************************************************
**
** Process ^C Interrupt
*/
short BREAKREQ()
   {
   INTERRUPT = 1;
   Zexit(3);
   return(0);
   }