/****************************************************************************/
/* Copyright (c) 2012 MBARI                                                 */
/* MBARI Proprietary Information. All rights reserved.                      */
/****************************************************************************/
/* Summary  :                                                               */
/* Filename : delta_tTest.cc                                            */
/* Author   :                                                               */
/* Project  :                                                               */
/* Version  : 1.0                                                           */
/* Created  : 09/17/2012                                                    */
/* Modified :                                                               */
/* Archived :                                                               */
/****************************************************************************/
/* Modification History:                                                    */
/****************************************************************************/
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <conio.h>
#include <process.h>
#include <signal.h>
#include <stdlib.h>
#include "Delta_T.h"    // Behavior
#include "Exception.h"
#include "StringConverter.h"
#include "MathP.h"
#include "System.h"
#include "Task.h"
#include "Syslog.h"
#include "DeltaTIF.h"

int main(int argc, char **argv)
{
  Boolean debug = True;
  Boolean error = False;

  printf("Starting delta_tServer...\n");

  char *program = "delta_tServer";

  char errorBuf[256];
  char buf[256];
 
  pid_t pid;
 
  //Delta_T *dt_behavior = new Delta_T();

  switch ((pid = fork())) {
     
  case 0:
    // In child
    // Execute driver program
    execlp(program, program, (char *)0);

    sprintf(errorBuf, 
	    "Task::spawnServer() - exec() of \"%s\" failed", program);

    perror(errorBuf);
 
    break;

  case -1:
    perror("Task::spawnServer() - fork() failed");
    return -1;
  }

  DeltaTIF *mbs;
  
  try {
    mbs = new DeltaTIF("Delta_TServer");
  }
  catch (Exception e) {
    fprintf(stderr, "Caught exception: %s\n", e.msg);
    error = True;
  }
  catch (...) {
    fprintf(stderr, "Caught some exception...");
    error = True;
  }

  if (error) exit(1);

  printf("Set for auto sos update\n");
  mbs->set_auto_sos(True);
  sleep(3);

  float sos = 1498.0;
  printf("Let's set the SOS\n");
  mbs->set_sos(DeltaTIF::Side, sos);
  mbs->set_sos(DeltaTIF::Fwd, sos);
  printf("Sos is %f\n", sos);

  printf("Start logging on Fwd::IDT and locally\n");
  mbs->start(DeltaTIF::Fwd);
  mbs->start(DeltaTIF::Side);
  mbs->set_idt_logging(DeltaTIF::Fwd, True);

  for (int i = 0; i < 5; i++)
  {
    sleep(1);
    DeltaTIF::Data data;
    mbs->get(DeltaTIF::Fwd, &data);
    printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
  }

  mbs->set_auto_sos(True);
  printf("Set sector size to 90, 60, and 30, back to 120\n");
  mbs->set_sector_size(DeltaTIF::Fwd, 90);
  mbs->set_sector_size(DeltaTIF::Side, 90);
  {
    sleep(2);
    DeltaTIF::Data data;
    //mbs->get(DeltaTIF::Fwd, &data);
    //printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    //printf("Fwd range(10) = %f, nbeams = %d\n", data.beam_ranges[10], data.nbeams);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    printf("Side range(7) = %f, nbeams = %d\n", data.beam_ranges[7], data.nbeams);
  }
  sleep(5);
  mbs->set_sector_size(DeltaTIF::Fwd, 60);
  mbs->set_sector_size(DeltaTIF::Side, 60);
  {
    sleep(2);
    DeltaTIF::Data data;
    //mbs->get(DeltaTIF::Fwd, &data);
    //printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    //printf("Fwd range(10) = %f, nbeams = %d\n", data.beam_ranges[10], data.nbeams);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    printf("Side range(7) = %f, nbeams = %d\n", data.beam_ranges[7], data.nbeams);
  }
  sleep(5);
  mbs->set_auto_sos(False);
  mbs->set_sector_size(DeltaTIF::Fwd, 30);
  mbs->set_sector_size(DeltaTIF::Side, 30);
  {
    sleep(2);
    DeltaTIF::Data data;
    //mbs->get(DeltaTIF::Fwd, &data);
    //printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    //printf("Fwd range(10) = %f, nbeams = %d\n", data.beam_ranges[10], data.nbeams);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    printf("Side range(7) = %f, nbeams = %d\n", data.beam_ranges[7], data.nbeams);
  }
  sleep(5);
  mbs->set_sector_size(DeltaTIF::Fwd, 120);
  mbs->set_sector_size(DeltaTIF::Side, 120);
  {
    sleep(2);
    DeltaTIF::Data data;
    //mbs->get(DeltaTIF::Fwd, &data);
    //printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    //printf("Fwd range(10) = %f, nbeams = %d\n", data.beam_ranges[10], data.nbeams);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    printf("Side range(7) = %f, nbeams = %d\n", data.beam_ranges[7], data.nbeams);
  }
  sleep(5);

  printf("Stop logging on Fwd::IDT and locally, start on Side::IDT\n");
  mbs->stop(DeltaTIF::Fwd);
  mbs->stop(DeltaTIF::Side);
  mbs->set_idt_logging(DeltaTIF::Fwd, False);
  mbs->set_idt_logging(DeltaTIF::Side, True);

  for (i = 0; i < 3; i++)
  {
    sleep(1);
    DeltaTIF::Data data;
    mbs->get(DeltaTIF::Fwd, &data);
    printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
  }

  printf("Set trigger delay to 100000, ppf to 1st return\n");
  mbs->set_trigger_delay(DeltaTIF::Fwd, 100000L);
  mbs->set_profile_point_filter(DeltaTIF::Side, 0);
  sleep(5);

  printf("Set trigger edge to negative, pmr to 5\n");
//  mbs->set_trigger_edge(DeltaTIF::Fwd, 0);
  mbs->set_profile_min_range(DeltaTIF::Side, 5);
  sleep(5);

  printf("Start logging on Fwd::IDT and locally\n");
  mbs->start(DeltaTIF::Fwd);
  mbs->set_idt_logging(DeltaTIF::Fwd, True);

  for (i = 0; i < 3; i++)
  {
    sleep(1);
    DeltaTIF::Data data;
    mbs->get(DeltaTIF::Fwd, &data);
    printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
  }

  printf("Set beam width to Wide and Narrow-Mixed\n");
  mbs->set_beam_width(DeltaTIF::Fwd, 0);
  mbs->set_beam_width(DeltaTIF::Side, 1);
  sleep(5);
  mbs->set_beam_width(DeltaTIF::Fwd, 3);
  mbs->set_beam_width(DeltaTIF::Side, 3);
  sleep(5);

  printf("Set averaging to Off and 5\n");
  mbs->set_averaging(DeltaTIF::Fwd, 1);
  mbs->set_averaging(DeltaTIF::Side, 1);
  sleep(5);
  mbs->set_averaging(DeltaTIF::Fwd, 5);
  mbs->set_averaging(DeltaTIF::Side, 3);
  sleep(5);

  printf("Set range to 30/10 and 100\n");
  mbs->set_range(DeltaTIF::Fwd, 30);
  mbs->set_range(DeltaTIF::Side, 10);
  sleep(5);
  mbs->set_range(DeltaTIF::Fwd, 100);
  mbs->set_range(DeltaTIF::Side, 100);

  for (i = 0; i < 3; i++)
  {
    sleep(1);
    DeltaTIF::Data data;
    mbs->get(DeltaTIF::Fwd, &data);
    printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
  }

  printf("Stop logging on IDT and locally\n");
  mbs->stop(DeltaTIF::Side);
  mbs->set_idt_logging(DeltaTIF::Side, False);
  mbs->stop(DeltaTIF::Fwd);
  mbs->set_idt_logging(DeltaTIF::Fwd, False);

  printf("Set gain to 19and 10\n");
  mbs->set_gain(DeltaTIF::Fwd, 19);
  mbs->set_gain(DeltaTIF::Side, 19);
  sleep(5);
  mbs->set_gain(DeltaTIF::Fwd, 10);
  mbs->set_gain(DeltaTIF::Side, 10);
  sleep(5);

  printf("Set gain_eq true then false\n");
  mbs->set_gain_eq(DeltaTIF::Fwd, True);
  mbs->set_gain_eq(DeltaTIF::Side, True);
  sleep(5);
  mbs->set_gain_eq(DeltaTIF::Fwd, False);
  mbs->set_gain_eq(DeltaTIF::Side, False);
  sleep(5);

  printf("Set sos to 1455 then 1492\n");
  mbs->set_sos(DeltaTIF::Fwd, 1455);
  sleep(5);
  mbs->set_sos(DeltaTIF::Fwd, 1492);
  mbs->set_sos(DeltaTIF::Side, 1492);
  sleep(5);

  printf("Start logging locally\n");
  mbs->start(DeltaTIF::Fwd);
  mbs->start(DeltaTIF::Side);

  for (i = 0; i < 3; i++)
  {
    sleep(1);
    DeltaTIF::Data data;
    mbs->get(DeltaTIF::Fwd, &data);
    printf("Fwd:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
    mbs->get(DeltaTIF::Side, &data);
    printf("Side:%f %d %d %d\n", data.range, data.update_time.seconds, data.enabled, data.interval);
  }

  // Signal all children
  kill(0, SIGTERM);
  Syslog::write("OK, LEAVING!!!\n");

  printf("Ending delta_t...\n");

  if (error)
    return 1;
  else
    return 0;
}