// StationStatus.cpp : implementation file
//

#include "stdafx.h"
#include "../Resource.h"
#include "../dvrmanager.h"
#include "../utils/common.h"
#include "StationStatus.h"

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

/////////////////////////////////////////////////////////////////////////////
// CStationStatus dialog


CStationStatus::CStationStatus(CWnd* pParent /*=NULL*/)
	: CDialog(CStationStatus::IDD, pParent)
{
	//{{AFX_DATA_INIT(CStationStatus)
	m_station = _T("");
	cyc_num = 0;
	all_chnls = 0;
	m_alarmout1 = FALSE;
	m_alarmout2 = FALSE;
	m_alarmout3 = FALSE;
	m_alarmout4 = FALSE;
	//}}AFX_DATA_INIT
	m_brush.CreateSolidBrush(RGB(117, 200, 146));
}


void CStationStatus::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CStationStatus)
	DDX_Control(pDX, IDC_STATION, m_stationctl);
	DDX_CBString(pDX, IDC_STATION, m_station);
	DDX_Control(pDX, IDC_MSFLEXGRID, m_grid);

	DDX_Check(pDX, IDC_OUPUT1, m_alarmout1);
	DDX_Check(pDX, IDC_OUPUT2, m_alarmout2);
	DDX_Check(pDX, IDC_OUPUT3, m_alarmout3);
	DDX_Check(pDX, IDC_OUPUT4, m_alarmout4);

	DDX_Control(pDX, IDC_OUPUT1, m_alarmout1ctl);
	DDX_Control(pDX, IDC_OUPUT2, m_alarmout2ctl);
	DDX_Control(pDX, IDC_OUPUT3, m_alarmout3ctl);
	DDX_Control(pDX, IDC_OUPUT4, m_alarmout4ctl);
	DDX_Control(pDX, IDC_TURNON, m_turnonctl);
	DDX_Control(pDX, IDC_STATIC_ST, m_lable);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CStationStatus, CDialog)
	//{{AFX_MSG_MAP(CStationStatus)
	ON_CBN_SETFOCUS(IDC_STATION, OnSetfocusStation)
	ON_CBN_SELCHANGE(IDC_STATION, OnSelchangeStation)
	ON_BN_CLICKED(IDC_TURNON, turnon)
	ON_WM_TIMER()
	ON_WM_CTLCOLOR()
	//}}AFX_MSG_MAP

	ON_MESSAGE(NTM_OPT_GET_OK, on_get_ok)

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CStationStatus message handlers

BOOL CStationStatus::OnInitDialog()
{
	CDialog::OnInitDialog();
	init_label(m_lable);
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

HBRUSH CStationStatus::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
	
	if (nCtlColor==CTLCOLOR_DLG) 
	return (HBRUSH)m_brush .GetSafeHandle( ) ;
	return hbr;
}

void CStationStatus::OnSetfocusStation() 
{
	m_stationctl.ResetContent();
	fill_combo(&m_stationctl);
}

void CStationStatus::OnSelchangeStation() 
{
	UpdateData(true);
    int index = m_stationctl.GetCurSel();
	if (index!=CB_ERR)
	{
    	m_stationctl.GetLBText(index, m_station);
	}

	if(m_station.IsEmpty())
		return;
	
	CString m_str;
	ULONG ip; USHORT port;
	get_addr(m_station, ip, port);
	all_chnls = get_chnls(ip, port);
	m_grid.SetRows(all_chnls+1);

	onintigrid();
	for(int i=0; i< all_chnls; i++)
	{
	
		m_str.Format("%d", i+1);
		m_grid.SetCol(0);
		m_grid.SetRow(i+1);
		m_grid.SetText(m_str);
	}

	OnQueryRecord(0);
	SetTimer(10, 100, NULL);
}

LRESULT CStationStatus::on_get_ok(WPARAM w, LPARAM l)
{
	CString m_yes, m_no;
	m_yes.Format(IDS_YES);
	m_no.Format(IDS_NO);

	NET_OPTIONS no = (NET_OPTIONS)w;
	if( no == OPT_TITLE )
	{
		char m_title[30] ;
		TREC_CHANNELTITLE* p = (TREC_CHANNELTITLE*)l;
		if(!p)
			return 0;

		memcpy(m_title, p->channel_name, p->channel_name_length);
		m_title[p->channel_name_length] = '\0';
		onsetgrid(p->channel+1, 1, m_title);
		return 1;
	}

	if( no == OPT_REC_ENABLE )
	{
		SHORT rec_opt = *(SHORT*)l;
		for(int i=0; i<all_chnls; i++)
		{
			if((rec_opt>>i) & 0x01)
				onsetgrid(i+1, 2, m_yes);
			else
				onsetgrid(i+1, 2, m_no);
		}
		return 1;
	}

	if(no == OPT_MD)
	{
		TREC_MOTIONRECPARA* p = (TREC_MOTIONRECPARA*)l;
		if(!p)
			return 0;

		if(!onsetonoffgrid(p->channel+1, 3, p->onoff))
			return 0;
			
		TREC_MOTIONRECPARA opt;
		memcpy(&opt, p, sizeof(TREC_MOTIONRECPARA));

		SYSTEMTIME systime	;
		CTime curtime = CTime::GetCurrentTime();
		curtime.GetAsSystemTime(systime);

		BOOL m_rec_sched = IS_DAY_SET(opt, 0) || IS_DAY_SET(opt, systime.wDayOfWeek+1);
		if(m_rec_sched)
		{
			CTime t1 = SEG1_BGN(opt, 0);	CTime t2 = SEG1_END(opt, 0);
			CTime t3 = SEG2_BGN(opt, 0);	CTime t4 = SEG2_END(opt, 0);

			if(checktime(t1, t2, t3, t4))
			{
				onsetgrid(p->channel+1, 3, m_yes);
				return 0;
			}
		}

		onsetgrid(p->channel+1, 3, m_no);
		return 1;
	}
	
	if(no == OPT_ALARM)
	{
		TREC_ALARMRECPARA* p = (TREC_ALARMRECPARA*)l;
		if(!p)
			return 0;

		if(!onsetonoffgrid(p->alarmin+1, 4, p->onoff))
			return 0;

		TREC_ALARMRECPARA opt;
		memcpy(&opt, p, sizeof(TREC_ALARMRECPARA));

		SYSTEMTIME systime	;
		CTime curtime = CTime::GetCurrentTime();
		curtime.GetAsSystemTime(systime);

		BOOL m_rec_sched = IS_DAY_SET(opt, 0) || IS_DAY_SET(opt, systime.wDayOfWeek+1);
		if(m_rec_sched)
		{
			CTime t1 = SEG1_BGN(opt, 0);	CTime t2 = SEG1_END(opt, 0);
			CTime t3 = SEG2_BGN(opt, 0);	CTime t4 = SEG2_END(opt, 0);

			if(checktime(t1, t2, t3, t4))
			{
				onsetgrid(p->alarmin+1, 4, m_yes);
				return 0;
			}
		}

		onsetgrid(p->alarmin+1, 4, no);
		return 1;
	}

	if (no == OPT_SCHED)  
	{
		TREC_SCHEDULEPARA* p = (TREC_SCHEDULEPARA*)l;
		if(!p)
			return 0;

		if(!onsetonoffgrid(p->channel+1, 5, p->onoff))
			return 0;

		TREC_SCHEDULEPARA opt;
		memcpy(&opt, p, sizeof(TREC_SCHEDULEPARA));

		SYSTEMTIME systime	;
		CTime curtime = CTime::GetCurrentTime();
		curtime.GetAsSystemTime(systime);

		BOOL m_rec_sched = IS_DAY_SET(opt, 0) || IS_DAY_SET(opt, systime.wDayOfWeek+1);
		if(m_rec_sched)
		{
			CTime t1 = SEG1_BGN(opt, 0);	CTime t2 = SEG1_END(opt, 0);
			CTime t3 = SEG2_BGN(opt, 0);	CTime t4 = SEG2_END(opt, 0);

			if(checktime(t1, t2, t3, t4))
			{
				onsetgrid(p->channel+1, 5, m_yes);
				return 0;
			}
		}

		onsetgrid(p->channel+1, 5, m_no);
		return 1;
	}

	return 1;
}

BOOL CStationStatus::onsetonoffgrid(int row, int col, BOOL m_bool) 
{
	CString m_no;
	m_no.Format(IDS_NO);
	if(!m_bool)
	{
		onsetgrid(row, col, m_no);
		return FALSE;
	}
	return TRUE;
}

BOOL CStationStatus::checktime(CTime &t1, CTime &t2, CTime &t3, CTime &t4) 
{
	CTime curtime = CTime::GetCurrentTime();
	CTime t11 = CTime(curtime.GetYear(), curtime.GetMonth(), curtime.GetDay(), t1.GetHour(), t1.GetMinute(), t1.GetSecond());
	CTime t22 = CTime(curtime.GetYear(), curtime.GetMonth(), curtime.GetDay(), t2.GetHour(), t2.GetMinute(), t2.GetSecond());
	CTime t33 = CTime(curtime.GetYear(), curtime.GetMonth(), curtime.GetDay(), t3.GetHour(), t3.GetMinute(), t3.GetSecond());
	CTime t44 = CTime(curtime.GetYear(), curtime.GetMonth(), curtime.GetDay(), t4.GetHour(), t4.GetMinute(), t4.GetSecond());

	if((curtime>=t11) && (curtime<=t22))
		return TRUE;

	if((curtime>=t33) && (curtime<=t44))
		return TRUE;

	return FALSE;
}


void CStationStatus::OnQueryTitle(int channel) 
{
	get_net_opt(m_station, OPT_TITLE, channel, m_hWnd);
}

void CStationStatus::OnQueryRecord(int channel)
{
	
	get_net_opt(m_station, OPT_REC_ENABLE, channel, m_hWnd) ;

}

void CStationStatus::OnQueryMotionRecord(int channel) 
{
	get_net_opt(m_station, OPT_MD, channel, m_hWnd);
}

void CStationStatus::OnQueryAlarmRecord(int channel) 
{
	get_net_opt(m_station, OPT_ALARM, channel, m_hWnd);
}

void CStationStatus::OnQuerySchedRecord(int channel) 
{
	get_net_opt(m_station, OPT_SCHED, channel, m_hWnd);	
}

void CStationStatus::onsetgrid(int row, int col, CString str) 
{
	m_grid.SetRow(row);
	m_grid.SetCol(col);
    m_grid.SetText(str);
}

void CStationStatus::onintigrid() 
{
	CString m_temstr;
	m_grid.Clear();
    m_grid.SetRow(0);
	m_grid.SetCol(0);
	m_temstr.Format(IDS_CHANNEL);
	m_grid.SetText(m_temstr);

	m_grid.SetCol(1);
	m_grid.SetColAlignment(1 , 4);
	m_grid.SetColWidth(1,1500);
	m_temstr.Format(IDS_CHANNELTITLE);
	m_grid.SetText(m_temstr);

	m_grid.SetCol(2);
	m_grid.SetColAlignment(2 , 4);
	m_temstr.Format(IDS_ISRECORDING);
	m_grid.SetText(m_temstr);

	m_grid.SetCol(3);
	m_grid.SetColAlignment(3 , 4);
	m_temstr.Format(IDS_ISMOTIONRECORDING);
	m_grid.SetText(m_temstr);

    m_grid.SetCol(4);
	m_grid.SetColAlignment(4 , 4);
	m_temstr.Format(IDS_ISALARMRECORDING);
	m_grid.SetText(m_temstr);

	m_grid.SetCol(5);
	m_grid.SetColAlignment(5 , 4);
	m_temstr.Format(IDS_ISSCHEDRECORDING);
	m_grid.SetText(m_temstr);
}

void CStationStatus::OnTimer(UINT nIDEvent) 
{
	if(nIDEvent == 10)
	{
		OnQueryTitle(cyc_num);
		cyc_num++;
		
		if(cyc_num >= all_chnls)
		{
			cyc_num = 0;
			KillTimer(nIDEvent);
			SetTimer(11, 100, NULL);
		}
	}

	if(nIDEvent == 11)
	{
		OnQueryMotionRecord(cyc_num);
		cyc_num++;
		
		if(cyc_num >= all_chnls)
		{
			cyc_num = 0;
			KillTimer(nIDEvent);
			SetTimer(12, 100, NULL);
		}
	}

	if(nIDEvent == 12)
	{
		OnQueryAlarmRecord(cyc_num);
		cyc_num++;
		
		if(cyc_num >= all_chnls)
		{
			cyc_num = 0;
			KillTimer(nIDEvent);
			SetTimer(13, 100, NULL);
		}
	}

	if(nIDEvent == 13)
	{
		OnQuerySchedRecord(cyc_num);
		cyc_num++;
		
		if(cyc_num >= all_chnls)
		{
			cyc_num = 0;
			KillTimer(nIDEvent);
		}
	}
		
	CDialog::OnTimer(nIDEvent);
}

void CStationStatus::turnon()
{
	UpdateData(TRUE);
	if(m_station.IsEmpty())
		return;

	int output = 0;

	if(m_alarmout1)
		output |= 0x01;

	if(m_alarmout2)
		output |= 0x02;

	if(m_alarmout3)
		output |= 0x04;

	if(m_alarmout4)
		output |= 0x08;

	ULONG ip;
	USHORT port;
	get_addr(m_station, ip, port);

	send_alarm_output(ip, port, output);
}