//////////////////////////////////////////////////////////////////////
//
// HAL_Illumination.cpp : interface for the Illumination related functions
//
//////////////////////////////////////////////////////////////////////

#include "StdAfx.h"

#include "..\include\resource.h"

#include "HAL.h"
#include "HSI.h"

double Intensity[HAL_ILLUMINATION_MAX_LAMPS][HAL_ILLUMINATION_MAX_BULBS];
bool   State[HAL_ILLUMINATION_MAX_LAMPS][HAL_ILLUMINATION_MAX_BULBS];
//unsigned short LastLevelSent[HAL_ILLUMINATION_MAX_LAMPS][HAL_ILLUMINATION_MAX_BULBS];

extern CHAL           *g_pHSI;
extern CHALMicroVuExt  g_HSIExt;
extern CMv_Proto      *g_pMv_Proto;


//////////////////////////////////////////////////////////////////////
bool IsTopLight(int nLamp)
{
	switch(g_HSIExt.m_ActiveMachineType)
	{
	case HAL_MACHINE_TYPE_EXCEL:
	case HAL_MACHINE_TYPE_VECTRA:
	default:
		if(nLamp == 0)
			return true;
		else
			return false;
		break;
	}
}


//////////////////////////////////////////////////////////////////////
bool IsBottomLight(int nLamp)
{
  UNREFERENCED_PARAMETER(nLamp);
	switch(g_HSIExt.m_ActiveMachineType)
	{
	case HAL_MACHINE_TYPE_VECTRA:
	case HAL_MACHINE_TYPE_EXCEL:
	default:
		if(nLamp == 1)
			return true;
		else
			return false;
		break;
	}
  return false;
}


//////////////////////////////////////////////////////////////////////
bool IsRingLight(int nLamp)
{
	switch(g_HSIExt.m_ActiveMachineType)
	{
	case HAL_MACHINE_TYPE_VECTRA:
	case HAL_MACHINE_TYPE_EXCEL:
	default:
		if(nLamp == 2)
			return true;
		else
			return false;
		break;
	}
}
// Map a lamp from the PCDMIS ring light to the MicroVu ring light
// MV start with the inner ring.  The first or zero lamp is at 12 oclock and goes CCW
// PCD starts with the outer ring.  The first or zero lamp is at 12 oclock and goes CW
//////////////////////////////////////////////////////////////////////
int PCDRingBulbToMicroVu_8x5(int Lamp)
{
	switch(Lamp)
	{
	case 0:
		return 32;
	case 1:
		return 39;
	case 2:
		return 38;
	case 3:
		return 37;
	case 4:
		return 36;
	case 5:
		return 35;
	case 6:
		return 34;
	case 7:
		return 33;

	case 8:
		return 24;
	case 9:
		return 31;
	case 10:
		return 30;
	case 11:
		return 29;
	case 12:
		return 28;
	case 13:
		return 27;
	case 14:
		return 26;
	case 15:
		return 25;

	case 16:
		return 16;
	case 17:
		return 23;
	case 18:
		return 22;
	case 19:
		return 21;
	case 20:
		return 20;
	case 21:
		return 19;
	case 22:
		return 18;
	case 23:
		return 17;

	case 24:
		return 8;
	case 25:
		return 15;
	case 26:
		return 14;
	case 27:
		return 13;
	case 28:
		return 12;
	case 29:
		return 11;
	case 30:
		return 10;
	case 31:
		return 9;

	case 32:
		return 0;
	case 33:
		return 7;
	case 34:
		return 6;
	case 35:
		return 5;
	case 36:
		return 4;
	case 37:
		return 3;
	case 38:
		return 2;
	case 39:
		return 1;
  }
  ASSERT(0);
	return 0;
}

// Map a lamp from the PCDMIS ring light to the MicroVu ring light
// MV start with the inner ring.  The first or zero lamp is at 12 oclock and goes CCW
// PCD starts with the outer ring.  The first or zero lamp is at 12 oclock and goes CW
//////////////////////////////////////////////////////////////////////
int PCDRingBulbToMicroVu_8x2(int Lamp)
{
	switch(Lamp)
	{
	case 0:
		return 8;
	case 1:
		return 9;
	case 2:
		return 10;
	case 3:
		return 11;
	case 4:
		return 12;
	case 5:
		return 13;
	case 6:
		return 14;
	case 7:
		return 15;
	case 8:
		return 0;
	case 9:
		return 1;
	case 10:
		return 2;
	case 11:
		return 3;
	case 12:
		return 4;
	case 13:
		return 5;
	case 14:
		return 6;
	case 15:
		return 7;
  }
  ASSERT(0);
	return 0;
}

// Map a lamp from the PCDMIS ring light to the MicroVu ring light
// MV start with the inner ring.  The first or zero lamp is at 12 oclock and goes CCW
// PCD starts with the outer ring.  The first or zero lamp is at 12 oclock and goes CW
//////////////////////////////////////////////////////////////////////
int PCDRingBulbToMicroVu(int Lamp)
{
  if ((g_HSIExt.m_NumRings == 2) && (g_HSIExt.m_NumSegs == 8))
  {
    PCDRingBulbToMicroVu_8x2(Lamp);
  }
  else
  if ((g_HSIExt.m_NumRings == 3) && (g_HSIExt.m_NumSegs == 8))
  {
    PCDRingBulbToMicroVu_8x5(Lamp);
  }
  else
  {
    PCDRingBulbToMicroVu_8x5(Lamp);
  };
	return 0;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_IsSupported(UINT &Type)
{
	Type = HAL_ILLUMINATION_SUPPORTS_DCC_CONTROL;

	HAL_SendDebug(_T("HAL_Illumination_IsSupported %X\n"), Type);
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_Startup( )
{
	memset(Intensity, 0, sizeof(Intensity));
	memset(State, 1, sizeof(State));

  switch(g_HSIExt.m_ActiveMachineType)
	{
	case HAL_MACHINE_TYPE_EXCEL:
  case HAL_MACHINE_TYPE_VECTRA:
    g_pMv_Proto->mv_light_set_light_off();
    break;
	}

	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_GetLampCount( int &nLamps )
{
	UINT NumLamps = 0;

	switch(g_HSIExt.m_ActiveMachineType)
	{
	case HAL_MACHINE_TYPE_EXCEL:
	case HAL_MACHINE_TYPE_VECTRA:
		NumLamps = 4;
		break;
	}

	ASSERT(NumLamps <= HAL_ILLUMINATION_MAX_LAMPS);

	nLamps = NumLamps;

	HAL_SendDebug(_T("HAL_Illumination_GetLampCount %d\n"), NumLamps);
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_GetLampInfo( int nLamp, TCHAR LampName[HAL_MaxLampNameLength+1], TCHAR LampDescription[HAL_MaxLampDescriptionLength+1],
										enum HAL_ILLUMINATION_LAMP_LOCATION_TYPE &LocationType, int &LocationAngle,
										enum HAL_ILLUMINATION_BULB_TYPE &BulbType,
										enum HAL_ILLUMINATION_BULB_CONTROL_TYPE &BulbControlType,
										enum HAL_ILLUMINATION_INTENSITY_CONTROL_TYPE &IntensityControlType,
										int &NumColors, COLORREF *Colors,
										int &NumRings, int *NumSectors,
										double &MinAngle, double &MaxAngle,
										bool &bCanBeCalibrated)
{
	if(IsTopLight(nLamp))
	{
		LocationType                  = HAL_ILLUMINATION_LAMP_LOCATION_TOP_ON_AXIS;
		BulbType                      = HAL_ILLUMINATION_BULB_ROUND;
		BulbControlType               = HAL_ILLUMINATION_BULB_CONTROL_BY_LAMP;
		IntensityControlType          = HAL_ILLUMINATION_INTENSITY_CONTROL_BY_LAMP;
		CString LampNameStr;
		LampNameStr.LoadString(IDS_ILLUMINATION_TOP);
		wcsncpy_s(LampName, HAL_MaxLampNameLength+1, LampNameStr, HAL_MaxLampNameLength);
		wcsncpy_s(LampDescription, HAL_MaxLampDescriptionLength+1, _T("MicroVu Coaxial Light"), HAL_MaxLampDescriptionLength);
		NumColors = 1;
		Colors[0] = RGB(255, 255, 255);
		NumRings = 0;
		NumSectors = 0;
		LocationAngle = 0;
		MinAngle = 0.0;
		MaxAngle = 0.0;
		bCanBeCalibrated = true;
	}

	if(IsBottomLight(nLamp))
	{
		LocationType                  = HAL_ILLUMINATION_LAMP_LOCATION_BOTTOM;
		BulbType                      = HAL_ILLUMINATION_BULB_ROUND;
		BulbControlType               = HAL_ILLUMINATION_BULB_CONTROL_BY_LAMP;
		IntensityControlType          = HAL_ILLUMINATION_INTENSITY_CONTROL_BY_LAMP;
		CString LampNameStr;
		LampNameStr.LoadString(IDS_ILLUMINATION_BTM);
		wcsncpy_s(LampName,HAL_MaxLampNameLength+1,LampNameStr,HAL_MaxLampNameLength);
		wcsncpy_s(LampDescription,HAL_MaxLampDescriptionLength+1,_T("MicroVu Backlight (Green)"),HAL_MaxLampDescriptionLength);
		NumColors = 1;
		Colors[0] = RGB(255, 255, 255);
		NumRings = 0;
		NumSectors = 0;
		LocationAngle = 0;
		MinAngle = 0.0;
		MaxAngle = 0.0;
		bCanBeCalibrated = true;
	}

	if(IsRingLight(nLamp))
	{
		LocationType                  = HAL_ILLUMINATION_LAMP_LOCATION_TOP_ANGLED;
		BulbType                      = HAL_ILLUMINATION_BULB_RING;
		BulbControlType               = HAL_ILLUMINATION_BULB_CONTROL_BY_BULB;
		IntensityControlType          = HAL_ILLUMINATION_INTENSITY_CONTROL_BY_BULB;

		CString LampNameStr;
		LampNameStr.LoadString(IDS_ILLUMINATION_RNG);
		wcsncpy_s(LampName, HAL_MaxLampNameLength+1, LampNameStr, HAL_MaxLampNameLength);
		wcsncpy_s(LampDescription, HAL_MaxLampDescriptionLength+1, _T("MicroVu Ringlight"), HAL_MaxLampDescriptionLength);
		NumColors = 1;
		Colors[0] = RGB(255, 255, 255);

    NumRings = g_HSIExt.m_NumRings;
    for(int i = 0 ; i < NumRings ; i++)
      NumSectors[i] = g_HSIExt.m_NumSegs;

		LocationAngle = 0;

		MinAngle = 0.0;
		MaxAngle = 0.0;

		bCanBeCalibrated = true;
	}

	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
int GetLampNumberFromLocation(const enum HAL_ILLUMINATION_LAMP_LOCATION_TYPE SearchLocationType)
{
  for(int nLamp=0;nLamp<HAL_ILLUMINATION_MAX_LAMPS;nLamp++)
  {
	  TCHAR LampName[HAL_MaxLampNameLength+1], LampDescription[HAL_MaxLampDescriptionLength+1];
	  enum HAL_ILLUMINATION_LAMP_LOCATION_TYPE LocationType=HAL_ILLUMINATION_LAMP_LOCATION_TOP_ON_AXIS;
	  enum HAL_ILLUMINATION_BULB_TYPE BulbType=HAL_ILLUMINATION_BULB_ROUND;
	  enum HAL_ILLUMINATION_BULB_CONTROL_TYPE BulbControlType=HAL_ILLUMINATION_BULB_CONTROL_BY_LAMP;
	  enum HAL_ILLUMINATION_INTENSITY_CONTROL_TYPE IntensityControlType=HAL_ILLUMINATION_INTENSITY_CONTROL_BY_LAMP;
	  int NumColors=1, NumRings=0,NumSectors[HAL_ILLUMINATION_MAX_SECTORS], LocationAngle=0;
	  COLORREF Colors[HAL_ILLUMINATION_MAX_BULB_COLORS];
	  Colors[0]=RGB(255,255,255);
	  double MinAngle=0.0,MaxAngle=0.0;
	  bool bCanBeCalibrated=true;

	  HAL_STATUS Status=HAL_Illumination_GetLampInfo(nLamp,LampName,LampDescription,LocationType,LocationAngle,BulbType,
		  BulbControlType,IntensityControlType,NumColors,Colors,NumRings,
		  NumSectors,MinAngle,MaxAngle,bCanBeCalibrated);

	  if((Status==HAL_STATUS_NORMAL) && (LocationType==SearchLocationType))
      return nLamp;
  }
  return -1;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_GetLampState_2x8( int nLamp, bool *bBulbStates,  double *Intensities,
										 int & Color, double & Angle )
{
	if(IsTopLight(nLamp))
	{
		bBulbStates[0] = g_HSIExt.m_LampOutputState_2x8[nLamp][0];
		Intensities[0] = g_HSIExt.m_LampOutputLevel_2x8[nLamp][0];
	}

	if(IsBottomLight(nLamp))
	{
		bBulbStates[0] = g_HSIExt.m_LampOutputState_2x8[nLamp][0];
		Intensities[0] = g_HSIExt.m_LampOutputLevel_2x8[nLamp][0];
	}

	if(IsRingLight(nLamp))
	{
		for(int Bulb = 0 ; Bulb < TWO_RINGS * EIGHT_SEGS; Bulb++)
		{
			bBulbStates[Bulb] = g_HSIExt.m_LampOutputState_2x8[nLamp][Bulb];
			Intensities[Bulb] = g_HSIExt.m_LampOutputLevel_2x8[nLamp][Bulb];
		}
	}

	Color=0;
	Angle=0.0;
  return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_GetLampState_5x8( int nLamp, bool *bBulbStates,  double *Intensities,
										 int & Color, double & Angle )
{
	if(IsTopLight(nLamp))
	{
		bBulbStates[0] = g_HSIExt.m_LampOutputState_5x8[nLamp][0];
		Intensities[0] = g_HSIExt.m_LampOutputLevel_5x8[nLamp][0];
	}

	if(IsBottomLight(nLamp))
	{
		bBulbStates[0] = g_HSIExt.m_LampOutputState_5x8[nLamp][0];
		Intensities[0] = g_HSIExt.m_LampOutputLevel_5x8[nLamp][0];
	}

	if(IsRingLight(nLamp))
	{
		for(int Bulb = 0 ; Bulb < TWO_RINGS * EIGHT_SEGS; Bulb++)
		{
			bBulbStates[Bulb] = g_HSIExt.m_LampOutputState_5x8[nLamp][Bulb];
			Intensities[Bulb] = g_HSIExt.m_LampOutputLevel_5x8[nLamp][Bulb];
		}
	}

	Color=0;
	Angle=0.0;

	return HAL_STATUS_NORMAL;
};

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_GetLampState( int nLamp, bool *bBulbStates,  double *Intensities,
										 int & Color, double & Angle )
{
  if ((g_HSIExt.m_NumRings == 2) && (g_HSIExt.m_NumSegs == 8))
  {
    HAL_Illumination_GetLampState_2x8(nLamp, bBulbStates, Intensities, Color, Angle);
  }
  else
  if ((g_HSIExt.m_NumRings == 5) && (g_HSIExt.m_NumSegs == 8))
  {
    HAL_Illumination_GetLampState_5x8(nLamp, bBulbStates, Intensities, Color, Angle);
  }
  else
  {
    HAL_Illumination_GetLampState_5x8(nLamp, bBulbStates, Intensities, Color, Angle);
  };
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_SetLampState_2x8( int nLamp, bool *bBulbStates, double *Intensities,
										                      int /*Color*/, double /*Angle*/, bool bWait )
{
	static unsigned short MaxLevelChange = 0;

	if(IsTopLight(nLamp))
	{
		g_HSIExt.m_LampOutputState_2x8[nLamp][0] = bBulbStates[0];
		g_HSIExt.m_LampOutputLevel_2x8[nLamp][0] = Intensities[0];
	}

	if(IsBottomLight(nLamp))
	{
		g_HSIExt.m_LampOutputState_2x8[nLamp][0] = bBulbStates[0];
		g_HSIExt.m_LampOutputLevel_2x8[nLamp][0] = Intensities[0];
	}

	if(IsRingLight(nLamp))
	{
		for(int Bulb = 0 ; Bulb < TWO_RINGS*EIGHT_SEGS ; Bulb++)
		{
			g_HSIExt.m_LampOutputState_2x8[nLamp][Bulb] = bBulbStates[Bulb];
			g_HSIExt.m_LampOutputLevel_2x8[nLamp][Bulb] = Intensities[Bulb];
      g_HSIExt.m_LampOutputLevelForMVRing_2x8[PCDRingBulbToMicroVu(Bulb)] = bBulbStates[Bulb]?Intensities[Bulb]:0.0;
    }
  }
  g_pMv_Proto->mv_set_ringlight_data(TWO_RINGS * EIGHT_SEGS, g_HSIExt.m_LampOutputLevelForMVRing_2x8);

  double dBottomIntensity = (g_HSIExt.m_LampOutputState_2x8[1][0])?g_HSIExt.m_LampOutputLevel_2x8[1][0]:0.0;
  double dTopIntensity    = (g_HSIExt.m_LampOutputState_2x8[0][0])?g_HSIExt.m_LampOutputLevel_2x8[0][0]:0.0;
  g_pMv_Proto->mv_light_set_lamp_state(dBottomIntensity,dTopIntensity);
  g_pMv_Proto->mv_light_set_light();

#pragma message("We need to determine a good value for the wait")
  Sleep(60);

	// Only wait if we've been asked to wait, and one of the lamps has changed in this set of changes,
	// and this is the last lamp
	if(bWait)
	{
#pragma message("Testing needs to be done to find a good lighting delay, if any")
		int Time=(int)(g_HSIExt.m_IllumSettleTime * 1000.0);
		CString TimeStr;
		TimeStr.Format(_T("HAL_Illumination_SetLampState MaxLevelChange %d so sleeping for %fs\n"),MaxLevelChange,(double)Time/1000.0);
		HAL_SendDebug(TimeStr);
		Sleep(Time);  // A totally off to totally on switch would give max of 500ms
		MaxLevelChange=0;
	}

	return HAL_STATUS_NORMAL;
};

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_SetLampState_5x8( int nLamp, bool *bBulbStates, double *Intensities,
                                          int /*Color*/, double /*Angle*/, bool bWait )
{
	static unsigned short MaxLevelChange = 0;

	if(IsTopLight(nLamp))
	{
		g_HSIExt.m_LampOutputState_5x8[nLamp][0] = bBulbStates[0];
		g_HSIExt.m_LampOutputLevel_5x8[nLamp][0] = Intensities[0];
	}

	if(IsBottomLight(nLamp))
	{
		g_HSIExt.m_LampOutputState_5x8[nLamp][0] = bBulbStates[0];
		g_HSIExt.m_LampOutputLevel_5x8[nLamp][0] = Intensities[0];
	}

	if(IsRingLight(nLamp))
	{
		for(int Bulb = 0 ; Bulb < TWO_RINGS*EIGHT_SEGS ; Bulb++)
		{
			g_HSIExt.m_LampOutputState_5x8[nLamp][Bulb] = bBulbStates[Bulb];
			g_HSIExt.m_LampOutputLevel_5x8[nLamp][Bulb] = Intensities[Bulb];
      g_HSIExt.m_LampOutputLevelForMVRing_5x8[PCDRingBulbToMicroVu(Bulb)] = bBulbStates[Bulb]?Intensities[Bulb]:0.0;
    }
  }
  g_pMv_Proto->mv_set_ringlight_data(FIVE_RINGS * EIGHT_SEGS, g_HSIExt.m_LampOutputLevelForMVRing_5x8);

  double dBottomIntensity = (g_HSIExt.m_LampOutputState_5x8[1][0])?g_HSIExt.m_LampOutputLevel_5x8[1][0]:0.0;
  double dTopIntensity    = (g_HSIExt.m_LampOutputState_5x8[0][0])?g_HSIExt.m_LampOutputLevel_5x8[0][0]:0.0;
  g_pMv_Proto->mv_light_set_lamp_state(dBottomIntensity,dTopIntensity);
  g_pMv_Proto->mv_light_set_light();

#pragma message("We need to determine a good value for the wait")
  Sleep(60);

	// Only wait if we've been asked to wait, and one of the lamps has changed in this set of changes,
	// and this is the last lamp
	if(bWait)
	{
#pragma message("Testing needs to be done to find a good lighting delay, if any")
		int Time=(int)(g_HSIExt.m_IllumSettleTime * 1000.0);
		CString TimeStr;
		TimeStr.Format(_T("HAL_Illumination_SetLampState MaxLevelChange %d so sleeping for %fs\n"),MaxLevelChange,(double)Time/1000.0);
		HAL_SendDebug(TimeStr);
		Sleep(Time);  // A totally off to totally on switch would give max of 500ms
		MaxLevelChange=0;
	}

	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Illumination_SetLampState( int nLamp, bool *bBulbStates, double *Intensities,
										 int /*Color*/, double /*Angle*/, bool bWait )
{
  if ((g_HSIExt.m_NumRings == 2) && (g_HSIExt.m_NumSegs == 8))
  {
    HAL_Illumination_SetLampState_2x8(nLamp, bBulbStates, Intensities, 0, 0.0, bWait);
  }
  else
  if ((g_HSIExt.m_NumRings == 5) && (g_HSIExt.m_NumSegs == 8))
  {
    HAL_Illumination_SetLampState_5x8(nLamp, bBulbStates, Intensities, 0, 0.0, bWait);
  }
  else
  {
    HAL_Illumination_SetLampState_5x8(nLamp, bBulbStates, Intensities, 0, 0.0, bWait);
  };
	return HAL_STATUS_NORMAL;
}

HAL_STATUS HAL_Illumination_Shutdown( )
{
  g_pMv_Proto->mv_light_set_light_off();
	return HAL_STATUS_NORMAL;
}