#include <Xm/Frame.h>
#include <Xm/Form.h>
#include <Xm/RowColumn.h>
#include <Xm/PushB.h>
#include <Xm/ToggleB.h>
#include <Xm/Label.h>
#include <Xm/ArrowB.h>
#include <Xm/Scale.h>
#include <xpm.h>
#include <Vk/VkErrorDialog.h>
#include "BenthicBioGui.h"
#include "benthicBioNames.h"
#include "powerDM.h"
#include "DmErrno.h"
#include "netNanny.xpm"
#include "TiburonApp.h"
 
#define dprintf if (debug) fprintf


BenthicBioPower::BenthicBioPower(const char *name, Widget parent,
			     BenthicBioGui *benthicBioGui)
{
  _baseWidget = XtVaCreateWidget(name, xmRowColumnWidgetClass, parent,
				XmNorientation, XmVERTICAL, NULL);
  
  installDestroyHandler();

  _benthicBioGui = benthicBioGui;
  
  Widget label = 
    XtVaCreateManagedWidget("powerLabel", xmLabelWidgetClass, _baseWidget, 
			    NULL);
  
  Widget mgr2 = 
    XtVaCreateWidget("mgr2", xmRowColumnWidgetClass, _baseWidget,
		     XmNorientation, XmHORIZONTAL, NULL);
  
  char itemName[MaxDmNameLen];
  strcpy(itemName, POWER_DM_PREFIX);

  char *namePtr = itemName + strlen(itemName);
  
  sprintf(namePtr, "%s.%s", BenthicBioAppName, IndexExciteName);

  indexSensor = 
    new PowerSwitchGui("indexSensor", mgr2, itemName,
		       "Index Sensor", 100, 50, 500, True);
  
  indexSensor->addCallback(PowerSwitchGui::statusChangeCallback, this,
			   (VkCallbackMethod )
			   &BenthicBioPower::statusCallback);
  
  indexSensor->show();


  sprintf(namePtr, "%s.%s", BenthicBioAppName, ArmPositionExciteName);

  armPositionSensor = 
    new PowerSwitchGui("armPositionSensor", mgr2, itemName,
		       "ArmPos Sensor", 100, 50, 500, True);
  
  armPositionSensor->show();


  sprintf(namePtr, "%s.%s", BenthicBioAppName, TungstenLampName);
  
  incandLight = new PowerSwitchGui("incandLight", mgr2,
				    itemName,
				    "Incand Light", 100, 50, 500, True);
  
  incandLight->show();

  sprintf(namePtr, "%s.%s", BenthicBioAppName, ValvePackName);
  
  valvePack = new PowerSwitchGui("ecuBoard", mgr2,
				 itemName,
				 "ECU Board", 100, 50, 500, True);
  
  valvePack->show();

  sprintf(namePtr, "%s.%s", BenthicBioAppName, SSPumpName);
  
  pump = 
    new PowerSwitchGui("pump", mgr2, itemName,
		       "SS Pump", 100, 50, 500, True);
  
  pump->addCallback(PowerSwitchGui::statusChangeCallback, this,
		    (VkCallbackMethod )&BenthicBioPower::statusCallback);

  pump->show();

  sprintf(namePtr, "%s.%s", BenthicBioAppName, ManipulatorName);
  
  manipulator = 
    new PowerSwitchGui("manipulator", mgr2, itemName,
		       "Manip", 100, 50, 500, True);

  manipulator->show();


  XtManageChild(mgr2);

  mgr2 = 
    XtVaCreateWidget("mgr2", xmRowColumnWidgetClass, _baseWidget,
		     XmNorientation, XmHORIZONTAL, NULL);


  sprintf(namePtr, "%s.%s", BenthicBioAppName, SciencePort12vName);

  sciencePort12v = 
    new PowerSwitchGui("sciencePort12v", mgr2, itemName,
		       "Science Port 12V", 100, 50, 500, True);
  
  sciencePort12v->show();

  sprintf(namePtr, "%s.%s", BenthicBioAppName, Camera12vName);

  camera12v = 
    new PowerSwitchGui("camera12v", mgr2, itemName,
		       "Camera 12V", 100, 50, 500, True);
  
  camera12v->show();


  sprintf(namePtr, "%s.%s", BenthicBioAppName, SciencePort24vName);

  sciencePort24v = 
    new PowerSwitchGui("sciencePort24v", mgr2, itemName,
		       "Science Port 24V", 100, 50, 500, True);
  
  sciencePort24v->show();

  sprintf(namePtr, "%s.%s", BenthicBioAppName, Camera24vName);

  camera24v = 
    new PowerSwitchGui("camera24v", mgr2, itemName,
		       "Camera 24V", 100, 50, 500, True);
  
  camera24v->show();


  XtManageChild(mgr2);
}


BenthicBioPower::~BenthicBioPower()
{
  delete indexSensor;
  delete armPositionSensor;
  delete sciencePort12v;
  delete camera12v;
  delete sciencePort24v;
  delete camera24v;

  delete pump;
  delete incandLight;
  delete manipulator;
  delete valvePack;
}


void BenthicBioPower::statusCallback(VkCallbackObject *obj,
				   void *clientData,
				   void *callData)
{
  Boolean debug = ((TiburonApp *)theApplication)->debug();
  
  dprintf(stderr, "BenthicBioGui::powerSwitchCallback()\n");

  switchStatus status = (switchStatus )callData;

  if (obj == pump)
  {
    dprintf(stderr, "BenthicBioGui::powerSwitchCallback() - pump status\n");

    switch (status)
    {
      case SWITCH_ON:
      case SWITCH_ON_CASCADE:
      _benthicBioGui->suctionSampler->pump->setSensitive(True);
      break;
      
      default:
      _benthicBioGui->suctionSampler->pump->setSensitive(False);
    }
  }
  else if (obj == valvePack)
  {
    dprintf(stderr, 
	    "BenthicBioGui::powerSwitchCallback() - valvePack status\n");
  }
}



BenthicBioGui::BenthicBioGui(const char *name, Widget parent, 
			     const char *platformName)
{
  _baseWidget = XtVaCreateWidget(name, xmFormWidgetClass, parent, NULL);
  
  installDestroyHandler();

  Widget label, title;

  title = 
    XtVaCreateManagedWidget("benthicBioLabel", xmLabelWidgetClass, _baseWidget,
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNrightAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_FORM,
			    NULL);

  _dmItems = new BenthicBioDm(platformName);

  label = 
    XtVaCreateManagedWidget("hydraulicLabel", xmLabelWidgetClass, _baseWidget,
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_WIDGET,
			    XmNtopWidget, title,
			    NULL);
  
  hydraulicSelect = new HydraulicSelect("hydraulicSelect", _baseWidget);
  XtVaSetValues(hydraulicSelect->baseWidget(),
		XmNleftAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_WIDGET,
		XmNtopWidget, label,
		NULL);
  
  hydraulicSelect->show();
  
  Widget powerFrame, valveFrame, ssFrame;
  
  powerFrame =
    XtVaCreateManagedWidget("powerFrame", xmFrameWidgetClass, _baseWidget, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_WIDGET,
			    XmNtopWidget, hydraulicSelect->baseWidget(),
			    XmNrightAttachment, XmATTACH_FORM,
			    NULL);

  power = new BenthicBioPower("power", powerFrame, this);
  power->show();
  
  valveFrame =
    XtVaCreateManagedWidget("valveFrame", xmFrameWidgetClass, _baseWidget, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_WIDGET,
			    XmNtopWidget, powerFrame,
			    XmNrightAttachment, XmATTACH_FORM,
			    NULL);
  
  Widget mgr = XtVaCreateWidget("mgr", xmRowColumnWidgetClass, valveFrame,
				XmNorientation, XmHORIZONTAL,
				XmNpacking, XmPACK_COLUMN,
				XmNnumColumns, 1,
				NULL);


  char itemName[MaxDmNameLen];

  DmObject::buildPrefix(itemName, platformName, BenthicBioAppName, 0);

  valveFunctions = new ValveFunctions("valveFunctions", mgr, 7, 1,
				      itemName, True);
  valveFunctions->show();

  // Build array of ValveControls to use in ValveSwitchMap
  int nValves = valveFunctions->nValves();
  
  if ((_valveControl = 
       (ValveControl **)malloc(nValves * sizeof(ValveControl *))) == NULL)
  {
    fprintf(stderr, 
	    "BenthicBioGui::BenthicBioGui() - malloc of _valveControl failed\n");
    exit(1);
  }
  
  for (int i = 0 ; i < nValves; i++)
    _valveControl[i] = valveFunctions->valves->valve[i];
  
  strcat(itemName, "MAPPED_VALVENO");
  
  _switchMap = new ValveSwitchMap("switchMap", mgr, 2,
				  itemName,
				  nValves,
				  _valveControl);
  

  _switchMap->show();

  XtManageChild(mgr);

  ssFrame =
    XtVaCreateManagedWidget("ssFrame", xmFrameWidgetClass, _baseWidget, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_WIDGET,
			    XmNtopWidget, valveFrame,
			    NULL);
  
  suctionSampler = new SuctionSampler("suctionSampler", ssFrame, 
				      BenthicBioAppName,
				      _dmItems->ssAutoIndex,
				      _dmItems->ssIndexSense,
				      _dmItems->ssJarNumber,
				      _dmItems->ssPumpSpeed,
				      _dmItems->ssPumpDirection);
  suctionSampler->show();
}


BenthicBioGui::~BenthicBioGui()
{
  delete hydraulicSelect;
  delete power;
  delete valveFunctions;
  delete suctionSampler;
  delete _switchMap;
  free((void *)_valveControl);
}