/****************************************************************************/
/* Copyright (c) 2012 MBARI                                                 */
/* MBARI Proprietary Information. All rights reserved.                      */
/****************************************************************************/
/* Summary  :                                                               */
/* Filename : DeltaTLog.cc                                             */
/* Author   :                                                               */
/* Project  :                                                               */
/* Version  : 1.0                                                           */
/* Created  : 09/17/2012                                                    */
/* Modified :                                                               */
/* Archived :                                                               */
/****************************************************************************/
/* Modification History:                                                    */
/****************************************************************************/
#include "DataLogWriter.h"
#include "DeltaTLog.h"
#include "DeltaT.h"
#include "ShortData.h"
#include "TimeP.h"
#include "Syslog.h"

class DeltaT;

DeltaTLog::DeltaTLog(DeltaT *dt, 
		     DataLog::FileFormat fileFormat,
		     const char* idtname) 
   : _delta_t(dt), _sim_delta_t(0),
     DataLogWriter(idtname, fileFormat, AutoTimeStamp) 
{
  init();
}

DeltaTLog::DeltaTLog(SimulatedDeltaT *dt, 
		     DataLog::FileFormat fileFormat,
		     const char* idtname) 
  : _delta_t(0), _sim_delta_t(dt),
    DataLogWriter(idtname, fileFormat, AutoTimeStamp) 
{
  init();
}


void DeltaTLog::init(void)
{
  char dname[100];
  sprintf(dname, "%s.data", name());
  setMnemonic(dname);

  sprintf(dname, "%s.DeltaT_Altitude", name());
  addField((_dt_altitude = new FloatData(dname)));
  sprintf(dname, "%s.NumberOfBeams", name());
  addField((_nbeams = new IntegerData(dname)));
  sprintf(dname, "%s.PingNumber", name());
  addField((_ping_number = new FloatData(dname)));

  // Create the data fields for the beam data
  //
  for (int i = 0; i < 120; i++) {
    sprintf(dname, "%s.BeamRange%d", name(), i+1);
    addField((_beam_ranges[i] = new FloatData(dname)));
  }
  for (i = 0; i < 120; i++) {
    sprintf(dname, "%s.Intensity%d", name(), i+1);
    addField((_intensities[i] = new IntegerData(dname)));
  }

  sprintf(dname, "%s.InterrogationTime", name());
  addField((_interrogation_time = new DoubleData(dname)));

}


DeltaTLog::~DeltaTLog()
{
  delete _dt_altitude;
  delete _nbeams;
  delete _ping_number;
  for (int i = 0; i < 120; i++) {
    delete _beam_ranges[i];
    delete _intensities[i];
  }
}


void DeltaTLog::setFields()
{
   Boolean debug = False;


   if( _delta_t )
   {

      DeltaTOutput *output = _delta_t->_output;

      _dt_altitude->setValue(output->data.dt_range);
      _interrogation_time->setValue(output->data.interrogation_time);
      _nbeams->setValue(output->data.nbeams);
      _ping_number->setValue((float)output->data.ping_number);
      int nb = _nbeams->value();

      // Straight copy if nbeams is 120 or less
      //
      if (nb <= 120) {
        for (int i = 0; i < nb; i++) {
          _beam_ranges[i]->setValue(output->data.beam_ranges[i]);
          _intensities[i]->setValue(output->data.intensities[i]);
        }
      }
      else {
        // Otherwise, some multiple of 120 so we average values
        // and place the results into the data fields.
        //
        int navg = nb/120;
        dprintf("Averaging %d beams per value\n", navg);
        for (int i = 0; i < 120; i++) {
          float avg_r = 0.;
          int   avg_i = 0;
	        for (int j = 0; j < navg; j++) {
            avg_r += output->data.beam_ranges[(i*navg)+j];
            avg_i += output->data.intensities[(i*navg)+j];
          }
          avg_r = avg_r/navg;
          avg_i = avg_i/navg;
          _beam_ranges[i]->setValue(avg_r);
          _intensities[i]->setValue(avg_i);
        }
      }

   }
   else if( _sim_delta_t )
   {
      _dt_altitude->setValue(_sim_delta_t->_range);

      int nlog = _sim_delta_t->_nlog;
      int nb   = _sim_delta_t->_nbeams;
      int tb   = _sim_delta_t->_tbeams;
      //
      // The aft sonar, nlog=0, has nbeams.  The forward sonar, nlog=1, has
      // tbeams-nbeams.
      if( nlog == 0 )
      {
        _nbeams->setValue(nb);
        for (int i = 0; i < nb; i++) 
        {
          _beam_ranges[i]->setValue(_sim_delta_t->_beam_ranges[i]);
          _intensities[i]->setValue(_sim_delta_t->_intensities[i]);
        }
      }
      else
      {
        _nbeams->setValue(tb-nb);
        for (int i = nb; i < tb; i++) 
        {
          _beam_ranges[i-nb]->setValue(_sim_delta_t->_beam_ranges[i]);
          _intensities[i-nb]->setValue(_sim_delta_t->_intensities[i]);
        }
      }
   }

}