//----------------------------------------------------------------------//
//  incubator.cc                                                        //
//  see /usr/share/doc/howto/en/html/Serial-Programming-HOWTO/x115.html //
//  Latest revision: 12-14-2005                                         //
//----------------------------------------------------------------------//

#include "incubator.h"
speed_t BAUDRATE = B9600;             
Alarm *a;
Incubator *f;
int ALARM_COUNT=0;
enum{ OFF, READY, RINGING };
const int ON = 1;
const int SLEEPTIME=10;  // seconds between successive readings

int main(void)
{
    int fd[MAX_PORTS];
    initialize_app_globals();
    ////  Open any additional ports here
    if(PORTS>0) fd[0] = open_port(SERIAL_PORT_0, PORT0_ADDRESS);
    if(PORTS>1) fd[1] = open_port(SERIAL_PORT_1, PORT1_ADDRESS);
    sleep(5);
    monitor(fd);
    ////  Close any additional ports here
    if(PORTS>1) close(fd[1]);
    if(PORTS>0) close(fd[0]);
    exit(EXIT_SUCCESS);
}  


//------------------------------------------------------------------//
// initialize_app_globals                                           //
// Change alarm threshold and initial states here.                  //
//------------------------------------------------------------------//
void initialize_app_globals(void)
{
    int frzr,k,count=0,cmd_start,location=0,label_start,skip=0;
    a = new Alarm[ALARMS];
    f = new Incubator[INCUBATORS];
    char tempstring[FILENAMELENGTH];
    char label[FILENAMELENGTH];
    FILE *fp;
    for(k=0;k<INCUBATORS;k++) f[k].state = OFF;

    //// Temperature threshold above which alarm will sound 
    //// if alarm is active
    printf("\n");
    for(k=0; k<INCUBATORS; k++) 
    {   f[k].location = new char[FILENAMELENGTH];
        f[k].state_string = new char[1024];
        f[k].inc_string = new char[1024];
        strcpy(f[k].state_string, "none");
        f[k].inc_string[0] = 0;
        f[k].temp = -200;
    }

    if((fp=fopen("locations","r"))==NULL)
    {   printf("Cant read locations\n");
        exit(1);
    }else
    {   printf("Locations:\n");
        while(!feof(fp) && count<100)
        {  f[location].location = new char[FILENAMELENGTH]; 
           fgets(tempstring, FILENAMELENGTH-1, fp);
           if(tempstring[0] == '#' || !strlen(tempstring)) continue;
           sscanf(tempstring, "%d", &f[location].port);
           if(feof(fp)) break;

           label_start = 0;
           skip = 0;
           for(k=0;k<(int)strlen(tempstring);k++)
           {    if(skip==0 && isdigit(tempstring[k])) skip=1;
                if(skip==1 && isspace(tempstring[k])) skip=2;
                if(skip==2 && !isspace(tempstring[k])){ label_start=k; break; }
           }
           strcpy(label, tempstring+label_start);          
           remove_terminal_cr(label);
           
           strcpy(f[location].location, label);
           printf("Location %d %d %s\n",location,strlen(f[location].location),f[location].location);
           location++;
        }
    }
    fclose(fp);


    if((fp=fopen("./alarm-commands","r"))==NULL)
    {   printf("Cant read alarm commands\n");
        exit(1);
    }else
    {   printf("Alarm commands:\n");
        while(!feof(fp) && count<100)
        {  a[count].command = new char[FILENAMELENGTH]; 
           fgets(tempstring, FILENAMELENGTH-1, fp);
           if(feof(fp)) break;
           if(tempstring[0] == '#' || !strlen(tempstring)) continue;
           if(strlen(tempstring)<3) continue;
           sscanf(tempstring, "%d %lf ", &a[count].inc, &a[count].threshold);
           cmd_start = find_command_start(tempstring);
           if(cmd_start) strcpy(a[count].command, tempstring+cmd_start);
           if(!strlen(a[count].command)) break;
           sprintf(tempstring, "Alarm=%d incubator=%d  temperature=%f command=%s", 
               count,
               a[count].inc, 
               a[count].threshold,
               a[count].command);
           //tempstring[79] = 0;
           printf("%s\n", tempstring);
           a[count].state = READY;
           frzr = a[count].inc;
           printf("count %d frzr = %d INCUBATORS = %d\n",count,frzr,INCUBATORS);
           if(frzr >= INCUBATORS) { printf("Error reading alarms\n"); exit(1); }
           f[frzr].state = ON;
           printf("Incubator %d state is ", frzr);
           switch(f[frzr].state)
	   {   case 0: printf("off\n"); break;
	       case 1: printf("on\n"); break;
	       default: printf("%d\n",f[frzr].state); break;
           }
           if(feof(fp)) break;
           count++;
           if(count >= ALARMS) { printf("Too many alarms\n"); exit(1); }
        }
        ALARM_COUNT = count;
        printf("Alarm count = %d\n",ALARM_COUNT);
        for(k=0;k<count;k++) printf(" Alarm %d state %d inc %d\n", 
	    k, a[k].state, a[k].inc);
        if(!count){ printf("No alarms\n"); exit(1); }
        fclose(fp);
    }
} 


//------------------------------------------------------------------//
// find_command_start                                               //
//------------------------------------------------------------------//
int find_command_start(char *string)
{
   int start=0,k,hit=0,inspace=0;
   for(k=0;k<(int)strlen(string);k++) 
   {    if(string[k]==' ' && !inspace){ inspace=1; hit++; }
        if(string[k]!=' ')
        {   inspace=0;
            if(hit==2){ start=k; break; }
        }
   }
   return start;
}         


//------------------------------------------------------------------//
// open_port                                                        //
//------------------------------------------------------------------//
int open_port(const char *port_name, int port_address)
{
  int fd;
  int port = 0x2e8;
  static struct serial_struct ss;
  static struct termios newtio;

  //// Open port
  if((fd = open(port_name, O_RDWR | O_NOCTTY )) < 0)
  {   printf("Cant open serial port %s\n", port_name);
      exit(1);
  }

  //// Find out what port and get permission to write to it
  if(ioctl(fd, TIOCGSERIAL, &ss)) 
  {   //printf("ioctl(TIOCSERGSTRUCT) failed: -- trying c800\n");
      // Can't get address: assume it's a rocket port
      ss.port = port_address;
  }

  //// Should be 3f8 for cua0, 2f8 for cua1, 3e8 for cua2, 0x2e8 for cua3
  port=ss.port;  
  printf("%s port %x\n" ,port_name, port);
 
  //// Enable asynchronous I/O
  //if(fcntl(fd, F_SETFL, FNDELAY)) printf("fcntl didnt work\n");;

  printf("Opened port %s, fd = %d\n", port_name, fd);
  //// Obtain current port settings 
  tcgetattr(fd, &newtio); 

  //// Set new port settings 
  // clear struct for new port settings 
  bzero(&newtio, sizeof(newtio)); 

  // CRTSCTS = hardware flow control
  // CS8     = 8N1
  // CLOCAL  = no modem control
  // CREAD   = enable receiving characters
  newtio.c_cflag = CRTSCTS | CS8 | CLOCAL | CREAD;
  // Ignore bytes with parity errors
  // Map CR to NL
  newtio.c_iflag = IGNPAR | ICRNL;
  newtio.c_cc[VMIN]=1;
  newtio.c_cc[VTIME]=0;   // Tenths of seconds before timeout 
  // Raw output 
  newtio.c_oflag = 0;
  // ICANON = enable canonical output (no echo, no signals)
  newtio.c_lflag = ICANON;
       
  tcflush(fd, TCIFLUSH);
  tcsetattr(fd, TCSANOW, &newtio);

  //// Set baud rate
  cfsetispeed(&newtio, BAUDRATE);
  cfsetospeed(&newtio, BAUDRATE);
  tcflush(fd, TCIFLUSH);
  tcsetattr(fd, TCSANOW, &newtio);
  return fd;
}


//------------------------------------------------------------------//
// monitor                                                          //
//------------------------------------------------------------------//
void monitor(int file_descriptor[])
{
  int port0, port1;
  int fd0=0, fd1=0, n;     /* input sources 1 and 2 */
  struct timeval timeout;
  fd_set readfs;    /* file descriptor set */
  printf("In monitor\n");
  int    maxfd;     /* maximum file desciptor used */

  timeout.tv_sec = 10;
  timeout.tv_usec = 0;
  if(PORTS>0)
  {   port0 = f[0].port;
      fd0 = file_descriptor[0];
  }
  if(PORTS>1)  
  {   port1 = f[1].port;
      fd1 = file_descriptor[1];
  }
  FD_ZERO(&readfs);
  maxfd = max(fd0, fd1)+1;  /* maximum bit entry (fd) to test */
  printf("maxfd = %d\n", maxfd);
  printf("Waiting for data\n");
  while (1)
  {
          FD_SET(fd0, &readfs);  /* set testing for source 1 */
          FD_SET(fd1, &readfs);  /* set testing for source 2 */
          /* block until input becomes available */
          n = select(maxfd, &readfs, NULL, NULL, &timeout);
//printf("%d ",n);fflush(stdout);
          if (FD_ISSET(fd0, &readfs))     /* input from source 1 available */
              handle_input(0, fd0);
          if (FD_ISSET(fd1, &readfs))     /* input from source 2 available */
              handle_input(1, fd1);          
  }
  printf("ending loop\n");
}   


//------------------------------------------------------------------//
// handle_input                                                     //
//------------------------------------------------------------------//
void handle_input(int inc, int fd)
{ 
  int port, k, n, len, alarm;
  int got_alarm[ALARM_COUNT];
  char tempstring[128];
  char *buffer;
  struct tm *tmstruct;
  time_t   t;                             // current time in seconds since 1970
  char thetime[256];                      // current time as string
  thetime[0] = 0;
  buffer = new char[128];
  port = f[inc].port;
  for(k=0;k<ALARM_COUNT; k++) got_alarm[k] = 0;

  ////  Read data from the port
  n = read(fd, buffer, 100);  
printf("handling fd=%d incubator=%d bytes=%d\n",fd,inc,n);
  if(n<2) return;
  if(n>0)         
  {     //// Put server time in logs, first part of buffer is garbled.
        time(&t);                    // Read clock -> time_t
        tmstruct = localtime(&t);    // time_t -> tm struct
        strftime(thetime, 256, "%A %B %d %I:%M:%S %P %Y", tmstruct);
        sprintf(f[inc].inc_string, "%s %s", thetime, buffer+29);
        len = (int) strlen(f[inc].inc_string);
        for(k=0;k<len;k++)
        {   if(f[inc].inc_string[k]=='R') f[inc].inc_string[k+2]=0;
        }
        printf("%s\n",f[inc].inc_string);
  }else
        strcpy(f[inc].inc_string, "No response from incubator \n");
  log_temperatures(inc);

  ////  Check each alarm to see if its alarm state should be changed
  ////  Each alarm can be      OFF READY RINGING
  ////  Each incubator can be  OFF READY RINGING
  for(alarm=0; alarm<ALARM_COUNT; alarm++)
  {  
      ////  READY->RINGING
      if(a[alarm].state == READY && inc == a[alarm].inc)
      {     
             if(strstr(f[inc].inc_string, "LO") && f[inc].state == ON)
             {    
                   got_alarm[alarm] = 1;
                   printf("Low Alarm %d\n",alarm);
             }
             if(strstr(f[inc].inc_string, "HI") && f[inc].state == ON)
             {    
                   got_alarm[alarm] = 1;
                   printf("High Alarm %d\n",alarm);
             }
      }
      ////  RINGING->READY
      if(a[alarm].state == RINGING && inc == a[alarm].inc)
      {      if(!strstr(f[inc].inc_string, "LO") &&
                !strstr(f[inc].inc_string, "HI"))
             {     a[alarm].state = READY;
                   memset(tempstring, ' ', 75);
                   tempstring[75] = 0;
             }
       }
  }
  for(alarm=0; alarm<ALARM_COUNT; alarm++)
  {   
       if(got_alarm[alarm])
       {     a[alarm].state = RINGING;
             alarm_ring(alarm);
       }
  }

  delete[] buffer;
}


//--------------------------------------------------------------------// 
// log_temperatures                                                   //
//--------------------------------------------------------------------// 
void log_temperatures(int inc)
{
  FILE *fp;
  int kk;
  char tempstring[1024];
  //// Append to incubator.txt for logs
  if((fp=fopen("incubator.txt","at"))==NULL)
  {    printf("Cant open incubator.txt file\n"); 
       exit(1);
  }
  time_t current_time;
  time(&current_time);
  f[inc].inc_string[67] = 0; 
  fprintf(fp, "Incubator %d: %s\n",inc, f[inc].inc_string);
  if(strcmp(f[inc].state_string,"none"))
         fprintf(fp, "%s\n", f[inc].state_string);
  fclose(fp);

  /// Save latest reading in incubator-current.txt
  if((fp=fopen("incubator-current.txt","wt"))==NULL)
  {    printf("Cant open incubator-current.txt file\n"); 
       exit(1);
  }
  fprintf(fp, "Incubator %d: %s\n",inc, f[inc].inc_string);
  if(strcmp(f[inc].state_string,"none"))
         fprintf(fp, "%s\n", f[inc].state_string);
  fclose(fp);

  if((fp=fopen("incubators.html","wt"))==NULL)
  {    printf("Cant open incubators.html file\n"); 
       exit(1);
  }
  time(&current_time);
  strcpy(tempstring,ctime(&current_time));
  for(kk=0;kk<(int)strlen(tempstring);kk++) if(tempstring[kk]=='\n') tempstring[kk]=' ';

  fprintf(fp,"<META HTTP-EQUIV=\"REFRESH\" CONTENT=\"40; index.html\">\n");
  fprintf(fp,"<HTML>\n<HEAD>\n<TITLE>Incubator Conditions</TITLE>\n</HEAD>\n\
<BODY> \n\
<H4>Incubator conditions at %s </H4> \n\
Time stamp: %ld<BR>\n\
<table border>\n\
<tr><td> Conditions           </td><td>Alarm state          </td><td>Location</td>\n",
  tempstring,current_time);

  fprintf(fp,"<tr><td> %s \t  </td><td> %s\t </td><td> %s </td></td>\n",
      f[inc].inc_string, 
      f[inc].state_string, 
      f[inc].location);

  fprintf(fp,"</TABLE>\n</BODY>\n<HTML>\n");
  fclose(fp);
  system("/home/incubator/programs/incubator/logcommands");
}


//--------------------------------------------------------------------// 
// alarm_ring                                                         //
//--------------------------------------------------------------------// 
void alarm_ring(int alarm)
{
   char tempstring[FILENAMELENGTH];
   int inc = a[alarm].inc;
   int status=0;

   log_temperatures(inc);
   printf("executing alarm %d\n",alarm);
   sprintf(tempstring, "Executing %s", a[alarm].command);
   tempstring[79]=0;
   sleep(1);

   sprintf(tempstring,"Incubator %d conditions %s alarm %d\n", inc,
       f[inc].inc_string, alarm);
   syslog(LOG_WARNING, tempstring);    
   printf("sending alarm >>%s\n<<",a[alarm].command);
   status = system(a[alarm].command);
   if(status!=0)
   {   sprintf(tempstring,"Error executing alarm command: \n%d %s\n",
             inc, a[alarm].command);
       syslog(LOG_WARNING, tempstring);    
   }
}


//--------------------------------------------------------------------------//
//  remove_terminal_cr                                                      //
//--------------------------------------------------------------------------//
void remove_terminal_cr(char *s)
{
    int pos = max(0, (int)(strlen(s))-1);
    if(s[pos]=='\n') s[pos]=0;
}

//--------------------------------------------------------------------------//
// between    - returns 1 if a is between b and c                           //
//--------------------------------------------------------------------------//
int between(int a,int b,int c)
{   if((a>=b)&&(a<=c)) return(1);
    else return(0);
}