// BatteryDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Dashboard.h"
#include "BatteryDlg.h"
#include "DashboardRecipient.h"
#include "StatusStatic.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define BATTERY_TIMER 1
#define BATTERY_TIMER_ELAPSE 2000

/////////////////////////////////////////////////////////////////////////////
// CBatteryDlg dialog


CBatteryDlg::CBatteryDlg(CWnd* pParent /*=NULL*/)
	: CTestDlg(CBatteryDlg::IDD, pParent,IDC_BATDRIVER_STATUS)
{
	//{{AFX_DATA_INIT(CBatteryDlg)
	m_batAlive = 0.0f;
	m_batOn = 0.0f;
	m_bat1Amps = 0.0f;
	m_bat1Volts = 0.0f;
	m_bat1Min = 0.0f;
	m_bat1Max = 0.0f;
	m_bat1Capacity = 0.0f;
	m_bat2Amps = 0.0f;
	m_bat2Volts = 0.0f;
	m_bat2Min = 0.0f;
	m_bat2Max = 0.0f;
	m_bat2Capacity = 0.0f;
	m_bat3Amps = 0.0f;
	m_bat3Volts = 0.0f;
	m_bat3Min = 0.0f;
	m_bat3Max = 0.0f;
	m_bat3Capacity = 0.0f;
	m_globalAmps = 0.0f;
	m_globalCapacity = 0.0f;
	m_globalVolts = 0.0f;
	m_numBat = 0.0f;
	//}}AFX_DATA_INIT
}


void CBatteryDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CBatteryDlg)
	DDX_Control(pDX, IDC_AUTO_MODE, m_autoMode);
	DDX_OCFloat(pDX, IDC_BAT_ALIVE, DISPID(7), m_batAlive);
	DDX_OCFloat(pDX, IDC_BAT_ON, DISPID(7), m_batOn);
	DDX_OCFloat(pDX, IDC_BAT1_AMPS, DISPID(7), m_bat1Amps);
	DDX_OCFloat(pDX, IDC_BAT1_VOLTS, DISPID(7), m_bat1Volts);
	DDX_OCFloat(pDX, IDC_BAT1_MIN, DISPID(7), m_bat1Min);
	DDX_OCFloat(pDX, IDC_BAT1_MAX, DISPID(7), m_bat1Max);
	DDX_OCFloat(pDX, IDC_BAT1_CAPACITY, DISPID(7), m_bat1Capacity);
	DDX_Control(pDX, IDC_BAT1_TEMP, m_bat1TempControl);
	DDX_OCFloat(pDX, IDC_BAT2_AMPS, DISPID(7), m_bat2Amps);
	DDX_OCFloat(pDX, IDC_BAT2_VOLTS, DISPID(7), m_bat2Volts);
	DDX_OCFloat(pDX, IDC_BAT2_MIN, DISPID(7), m_bat2Min);
	DDX_OCFloat(pDX, IDC_BAT2_MAX, DISPID(7), m_bat2Max);
	DDX_OCFloat(pDX, IDC_BAT2_CAPACITY, DISPID(7), m_bat2Capacity);
	DDX_Control(pDX, IDC_BAT2_TEMP, m_bat2TempControl);
	DDX_OCFloat(pDX, IDC_BAT3_AMPS, DISPID(7), m_bat3Amps);
	DDX_OCFloat(pDX, IDC_BAT3_VOLTS, DISPID(7), m_bat3Volts);
	DDX_OCFloat(pDX, IDC_BAT3_MIN, DISPID(7), m_bat3Min);
	DDX_OCFloat(pDX, IDC_BAT3_MAX, DISPID(7), m_bat3Max);
	DDX_OCFloat(pDX, IDC_BAT3_CAPACITY, DISPID(7), m_bat3Capacity);
	DDX_Control(pDX, IDC_BAT3_TEMP, m_bat3TempControl);
	DDX_OCFloat(pDX, IDC_GLOBAL_AMPS, DISPID(7), m_globalAmps);
	DDX_OCFloat(pDX, IDC_GLOBAL_CAPACITY, DISPID(7), m_globalCapacity);
	DDX_OCFloat(pDX, IDC_GLOBAL_VOLTS, DISPID(7), m_globalVolts);
	DDX_OCFloat(pDX, IDC_NUM_BAT, DISPID(7), m_numBat);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CBatteryDlg, CTestDlg)
	//{{AFX_MSG_MAP(CBatteryDlg)
	ON_BN_CLICKED(IDC_UPDATE, OnUpdate)
	ON_BN_CLICKED(IDC_BAT1_OFF, OnBat1Off)
	ON_BN_CLICKED(IDC_BAT1_ON, OnBat1On)
	ON_BN_CLICKED(IDC_BAT2_OFF, OnBat2Off)
	ON_BN_CLICKED(IDC_BAT2_ON, OnBat2On)
	ON_BN_CLICKED(IDC_BAT3_OFF, OnBat3Off)
	ON_BN_CLICKED(IDC_BAT3_ON, OnBat3On)
	ON_BN_CLICKED(IDC_AUTO_MODE, OnAutoMode)
	ON_BN_CLICKED(IDC_MANUAL_MODE, OnManualMode)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBatteryDlg message handlers

void CBatteryDlg::initSubClassDlg()
{
	SetTimer(BATTERY_TIMER,BATTERY_TIMER_ELAPSE,0);
	m_autoMode.SetButtonStyle(BS_AUTORADIOBUTTON);

	m_globalStatus.SubclassDlgItem(IDC_GLOBAL_STATUS,this);
	m_bat1Status.SubclassDlgItem(IDC_BAT1_STATUS, this);
	m_bat2Status.SubclassDlgItem(IDC_BAT2_STATUS, this);
	m_bat3Status.SubclassDlgItem(IDC_BAT3_STATUS, this);
	m_bat1Error.SubclassDlgItem(IDC_BAT1_ERROR, this);
	m_bat2Error.SubclassDlgItem(IDC_BAT2_ERROR, this);
	m_bat3Error.SubclassDlgItem(IDC_BAT3_ERROR, this);
}

void CBatteryDlg::requestUpdate()
{
	Assert(m_recipient);

	m_recipient->requestData(MMAgentRequest::Start,
		ModemMessage::tMMThalesBatteryInfo,3);
	m_recipient->requestData(MMAgentRequest::Start,
		ModemMessage::tMMThalesBatteryGlobal,3);
}

void CBatteryDlg::stopRequests()
{
	Assert(m_recipient);

	m_recipient->requestData(MMAgentRequest::Stop,
		ModemMessage::tMMThalesBatteryInfo,-1);
	m_recipient->requestData(MMAgentRequest::Stop,
		ModemMessage::tMMThalesBatteryGlobal,-1);

	resetDialog();
}

void CBatteryDlg::resetDialog()
{
	m_batAlive = 0.0f;
	m_batOn = 0.0f;
	m_bat1Amps = 0.0f;
	m_bat1Volts = 0.0f;
	m_bat1Min = 0.0f;
	m_bat1Max = 0.0f;
	m_bat1Capacity = 0.0f;
	m_bat2Amps = 0.0f;
	m_bat2Volts = 0.0f;
	m_bat2Min = 0.0f;
	m_bat2Max = 0.0f;
	m_bat2Capacity = 0.0f;
	m_bat3Amps = 0.0f;
	m_bat3Volts = 0.0f;
	m_bat3Min = 0.0f;
	m_bat3Max = 0.0f;
	m_bat3Capacity = 0.0f;
	m_globalAmps = 0.0f;
	m_globalCapacity = 0.0f;
	m_globalVolts = 0.0f;
	m_numBat = 0.0f;
	m_globalStatus.setBatteryError(-1);
	m_bat1TempControl.SetValue(COleVariant(0.0));
	m_bat1Status.setBatteryStatus('r');
	m_bat1Error.setBatteryError(-1);
	m_bat2TempControl.SetValue(COleVariant(0.0));
	m_bat2Status.setBatteryStatus('r');
	m_bat2Error.setBatteryError(-1);
	m_bat3TempControl.SetValue(COleVariant(0.0));
	m_bat3Status.setBatteryStatus('r');
	m_bat3Error.setBatteryError(-1);
	UpdateData(FALSE);
}

void CBatteryDlg::OnUpdate() 
{
	requestUpdate();
}

void CBatteryDlg::setBatteryGlobal(double voltage, double amps, double capacity, short errorLevel,
		int numBatteries, int numOn, int numAlive)
{
	receiveData();
	m_globalVolts = voltage;
	m_globalAmps = amps;
	m_globalCapacity = capacity;
	m_numBat = numBatteries;
	m_batAlive = numAlive;
	m_batOn = numOn;
	m_globalStatus.setBatteryError(errorLevel);
	UpdateData(False);
}

void CBatteryDlg::setBatteryInfo(int num, double voltage, double amps, double minV, 
		double maxV, double temp, double capacity, char state, char errorState, int comms,
		int errorLevel)
{
	receiveData();
	switch(num) {
	case 0:
		m_bat1Volts = voltage;
		m_bat1Amps = amps;
		m_bat1Min = minV;
		m_bat1Max = maxV;
		m_bat1Capacity = capacity;
		m_bat1TempControl.SetValue(COleVariant(temp));
		m_bat1Status.setBatteryStatus(state);
		m_bat1Error.setBatteryError(errorLevel);
		break;
	case 1:
		m_bat2Volts = voltage;
		m_bat2Amps = amps;
		m_bat2Min = minV;
		m_bat2Max = maxV;
		m_bat2Capacity = capacity;
		m_bat2TempControl.SetValue(COleVariant(temp));
		m_bat2Status.setBatteryStatus(state);
		m_bat2Error.setBatteryError(errorLevel);
		break;
	case 2:
		m_bat3Volts = voltage;
		m_bat3Amps = amps;
		m_bat3Min = minV;
		m_bat3Max = maxV;
		m_bat3Capacity = capacity;
		m_bat3TempControl.SetValue(COleVariant(temp));
		m_bat3Status.setBatteryStatus(state);
		m_bat3Error.setBatteryError(errorLevel);
		break;
	}

	UpdateData(False);
}

void CBatteryDlg::OnBat1Off() 
{
	m_recipient->setString("batteryOff,0");	
}

void CBatteryDlg::OnBat1On() 
{
	m_recipient->setString("batteryOn,0");	
	
}

void CBatteryDlg::OnBat2Off() 
{
	m_recipient->setString("batteryOff,1");	
	
}

void CBatteryDlg::OnBat2On() 
{
	m_recipient->setString("batteryOn,1");	
	
}

void CBatteryDlg::OnBat3Off() 
{
	m_recipient->setString("batteryOff,2");	
	
}

void CBatteryDlg::OnBat3On() 
{
	m_recipient->setString("batteryOn,2");	
	
}

void CBatteryDlg::OnAutoMode() 
{
	if(IDC_AUTO_MODE == GetCheckedRadioButton(IDC_AUTO_MODE, IDC_MANUAL_MODE)) return;
	
	m_recipient->setString("batteryAutoMode");
	CheckRadioButton(IDC_AUTO_MODE, IDC_MANUAL_MODE, IDC_AUTO_MODE);
	UpdateData(False);

}

void CBatteryDlg::OnManualMode() 
{
	if(IDC_MANUAL_MODE == GetCheckedRadioButton(IDC_AUTO_MODE, IDC_MANUAL_MODE)) return;
	
	m_recipient->setString("batteryManualMode");
	CheckRadioButton(IDC_AUTO_MODE, IDC_MANUAL_MODE, IDC_MANUAL_MODE);
	UpdateData(False);
}