/****************************************************************************/
/* Copyright (c) 2000 MBARI                                                 */
/* MBARI Proprietary Information. All rights reserved.                      */
/****************************************************************************/
/* Summary  :                                                               */
/* Filename : SeabirdServer.cc                                                  */
/* Author   :                                                               */
/* Project  :                                                               */
/* Version  : 1.0                                                           */
/* Created  : 02/07/2000                                                    */
/* Modified :                                                               */
/* Archived :                                                               */
/****************************************************************************/
/* Modification History:                                                    */
/****************************************************************************/
#include <process.h>

#include <time.h>
#include "SeabirdServer.h"
#include "Syslog.h"

SeabirdServer::SeabirdServer(const char *name, SerialParameters *serialParams,
			     const char *instName)
  : CtdIF_SK(instName)
{
  _instName = strdup(instName);
  _serialParams = serialParams;
   char seabirdOutputName[256];
  strcpy(seabirdOutputName, instName);
  strcat(seabirdOutputName, SeabirdOutputName);
  _output = new SeabirdOutput(seabirdOutputName, SharedData::ReadWrite);
  _output->data.deviceReady = False;

  _output->write();
}


SeabirdServer::~SeabirdServer()
{
  delete _instName;
  delete _output;
}


void SeabirdServer::name(DeviceIF::Name name)
{
  strcpy(name, "Seabird");
}


void SeabirdServer::serialNumber(DeviceIF::Name number)
{
  strcpy(number, "XXX");
}


DeviceIF::Status SeabirdServer::initialize()
{
  // Dummy implementation for now
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::powerOn()
{
  // Dummy implementation for now
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::powerOff()
{
  // Dummy implementation for now
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::status()
{
  // Dummy implementation for now
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::dataLoggingOn()
{
  // Dummy implementation for now
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::dataLoggingOff()
{
  // Dummy implementation for now
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::get_CTD_data(float *cond,
					     float *temp,
					     float *depth,
					     float *tfreq,
					     float *cfreq,
					     TimeIF::TimeSpec *condSampleTime,
					     TimeIF::TimeSpec *tempSampleTime,
					     float *v1,
					     float *v2,
					     float *v3,
					     float *v4,
					     float *v5,
					     float *v6)
{
  Boolean debug = True;
  _output->read();
  if (!_output->data.deviceReady) {
    dprintf("SeabirdServer::get_ctd_data() - device NOT ready");
    return DeviceIF::Error;
  }

  dprintf("SeabirdServer::get_ctd_data() - device ready");
  *cond = _output->data.conductivity;
  *temp = _output->data.temperature;
  *depth = 0.0; //unused ? JR
  *tfreq = _output->data.tfreq;
  *cfreq = _output->data.cfreq;
  condSampleTime->seconds = (long)_output->data.cond_updateTime.tv_sec;
  condSampleTime->nanoSeconds = (long)_output->data.cond_updateTime.tv_nsec;
  tempSampleTime->seconds = (long)_output->data.temp_updateTime.tv_sec;
  tempSampleTime->nanoSeconds = (long)_output->data.temp_updateTime.tv_nsec;
  *v1 = _output->data.voltages[0];
  *v2 = _output->data.voltages[1];
  *v3 = _output->data.voltages[2];
  *v4 = _output->data.voltages[3];
  *v5 = _output->data.voltages[4];
  *v6 = _output->data.voltages[5];
  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::conductivity(float *cond, float *cfreq,
					     TimeIF::TimeSpec *sampleTime)
{
  _output->read();
  if (!_output->data.deviceReady)
    return DeviceIF::Error;

  *cond = _output->data.conductivity;
  *cfreq = _output->data.cfreq;
  sampleTime->seconds = (long)_output->data.cond_updateTime.tv_sec;
  sampleTime->nanoSeconds = (long)_output->data.cond_updateTime.tv_nsec;

  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::temperature(float *temp, float *tfreq,
					    TimeIF::TimeSpec *sampleTime)
{
  _output->read();
  if (!_output->data.deviceReady)
    return DeviceIF::Error;

  *temp = _output->data.temperature;
  *tfreq = _output->data.tfreq;
  sampleTime->seconds = (long)_output->data.temp_updateTime.tv_sec;
  sampleTime->nanoSeconds = (long)_output->data.temp_updateTime.tv_nsec;

  return DeviceIF::Ok;
}


DeviceIF::Status SeabirdServer::voltages(float *v1,
					 float *v2,
					 float *v3,
					 float *v4,
					 float *v5,
					 float *v6)
{
  _output->read();
  if (!_output->data.deviceReady)
    return DeviceIF::Error;

  *v1 = _output->data.voltages[1];
  *v2 = _output->data.voltages[2];
  *v3 = _output->data.voltages[3];
  *v4 = _output->data.voltages[4];
  *v5 = _output->data.voltages[5];
  *v6 = _output->data.voltages[6];
  return DeviceIF::Ok;
}


int SeabirdServer::spawnAuxTasks()
{
 
  char *program = "seabirdDriver";
  char errorBuf[256];
  char buf[256];
 
  pid_t pid;
 
  switch ((pid = fork())) {
     
  case 0:
    // In child
    // Execute server program

    execlp(program, program, "-n", _instName, "-serial",
	   _serialParams->string(), 0);

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

    perror(errorBuf);
 
    break;

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

  return 0;
}