#pragma once

#include <vector>
#include "CHCommonClasses/MacroFile.h"

interface ISignalControl2Parnet
{
	virtual void ISC2P_DisplayMessage(int nIndex, const TCHAR* lpstrFormat, ...) = 0;
	virtual void ISC2P_ReceiveSignal(int nIndex, int nSignalIndex, int nSignalValue, BOOL bOn=TRUE) = 0;
	virtual void ISC2P_SetSignalStatus(int nReadSignal, int nSendSignal, int nSendSignalWord = 0) = 0;
};

enum SignalConnectType		{	SignalConnectType_Simulation = 0, 
								SignalConnectType_Plc, 
								SignalConnectType_Dit_PcControl, 
								SignalConnectType_Count };

enum SignalDelayIndex		{	SignalDelayIndex_Loading=0, 
								SignalDelayIndex_AlignStart, 
								SignalDelayIndex_AlignEnd, 
								SignalDelayIndex_ReviewStart, 
								SignalDelayIndex_ReviewEnd, 
								SignalDelayIndex_Unloading,
								SignalDelayIndex_Count };

enum ReceiveSignal			{	RecvSig_BypassMode=0, 
								RecvSig_AutoMode, 
								RecvSig_ManualMode, 
								RecvSig_ReviewMode, 
								RecvSig_Loading, 
								RecvSig_AlignStart, 
								RecvSig_AlignEnd, 
								RecvSig_ReviewStart, 
								RecvSig_ReviewEnd, 
								RecvSig_Unloading, 
								RecvSig_Count };


struct SSignalSettingData
{
	SSignalSettingData(int nIdx=-1, CString strN=_T(""), CString strA=_T(""), int nS=0)
	{
		nIndex = nIdx;
		strName = strN;
		strAddr = strA;
		nSize = nS;
	}
	~SSignalSettingData()		{ Reset(); }

	void Reset()
	{
		nIndex = -1;
		strName = _T("");
		strAddr = _T("");
		nSize = 0;
	}

	int		nIndex;
	CString	strName;
	CString strAddr;
	int		nSize;
};
typedef std::vector<SSignalSettingData>						VectorSignalSettingData;
typedef std::vector<SSignalSettingData>::iterator			VectorSignalSettingDataIt;
typedef std::vector<SSignalSettingData>::const_iterator		constVectorSignalSettingDataIt;

typedef std::vector<int>		VectorInt;
typedef std::vector<CString>	VectorCString;

class CSignalControlInfo
{
public:
	CSignalControlInfo(int nIndex=0) : m_nIndex(nIndex)		{ Reset(); }
	~CSignalControlInfo(void)								{ Reset(); }
	void Reset()
	{
		m_nIndex					= 0;
		m_strName					= _T("");
		m_nPort						= 0;
		m_nControllerType			= 0;
		m_nReceiveSignalCount		= 1;
		m_nSendSignalCount			= 1;
		m_nMSPeriod					= 0;
		m_nMSTimerTime				= 0;
		m_nMSTotalTime				= 0;
		memset(m_pMsSignalDelayTime, 0x00, sizeof(int)*SignalDelayIndex_Count);
		m_bUseContinuousReadAddr	= FALSE;
		m_bUseContinuousSendAddr	= FALSE;

		m_vecReadSigAddr.clear();
		m_vecSendSigAddr.clear();
		m_vecReadDataAddr.clear();
		m_vecSendDataAddr.clear();
	}
	
	BOOL LoadInfo(CMacroFile* pFile, const CString& strItemName)
	{
		return FALSE;
	}

	BOOL SaveInfo(CMacroFile* pFile, const CString& strItemName)
	{
		return FALSE;
	}

	// getter
	int			GetIndex() const					{ return m_nIndex; }
	CString		GetName() const						{ return m_strName; }
	int			GetPort() const						{ return m_nPort; }
	int			GetControllerType() const			{ return m_nControllerType; }

	int			GetReceiveSignalCount() const		{ return m_nReceiveSignalCount; }
	int			GetSendSignalCount() const			{ return m_nSendSignalCount; }

	int			GetMSPeriod() const					{ return m_nMSPeriod; }
	int			GetMSTimerTime() const				{ return m_nMSTimerTime; }
	int			GetMSTotalTime() const				{ return m_nMSTotalTime; }
	int*		GetDelayTimeData()					{ return &(m_pMsSignalDelayTime[0]); }
	int			GetMSLoadingSignalDelay() const		{ return m_pMsSignalDelayTime[SignalDelayIndex_Loading]; }
	int			GetMSAlignStartSignalDelay() const	{ return m_pMsSignalDelayTime[SignalDelayIndex_AlignStart]; }
	int			GetMSAlignEndSignalDelay() const	{ return m_pMsSignalDelayTime[SignalDelayIndex_AlignEnd]; }
	int			GetMSReviewStartSignalDelay() const	{ return m_pMsSignalDelayTime[SignalDelayIndex_ReviewStart]; }
	int			GetMSReviewEndSignalDelay() const	{ return m_pMsSignalDelayTime[SignalDelayIndex_ReviewEnd]; }
	int			GetMSUnloadingSignalDelay() const	{ return m_pMsSignalDelayTime[SignalDelayIndex_Unloading]; }

	BOOL		GetUseContinuousReadAddress() const { return m_bUseContinuousReadAddr; }
	BOOL		GetUseContinuousSendAddress() const { return m_bUseContinuousSendAddr; }

	int GetReadSignalAddressCount() const
	{
		return int(m_vecReadSigAddr.size());
	}

	CString GetReadSignalAddress(int nIdx) const
	{ 
		if (nIdx<0 || nIdx>=int(m_vecReadSigAddr.size())) return _T("");
		return m_vecReadSigAddr[nIdx];
	}

	int GetSendSignalAddressCount() const
	{
		return int(m_vecSendSigAddr.size());
	}

	CString GetSendSignalAddress(int nIdx) const
	{
		if (nIdx<0 || nIdx>=int(m_vecSendSigAddr.size())) return _T("");
		return m_vecSendSigAddr[nIdx];
	}

	int	GetReadDataAddressCount() const
	{
		return int(m_vecReadDataAddr.size());
	}

	SSignalSettingData*	GetReadDataAddress(int nIdx)
	{
		if (nIdx<0 || nIdx>=int(m_vecReadDataAddr.size())) return NULL;
		return &m_vecReadDataAddr[nIdx];
	}

	const SSignalSettingData* GetReadDataAddress(int nIdx) const
	{
		if (nIdx<0 || nIdx>=int(m_vecReadDataAddr.size())) return NULL;
		return &m_vecReadDataAddr[nIdx];
	}

	int	CSignalControlInfo::GetSendDataAddressCount() const
	{
		return int(m_vecSendDataAddr.size());
	}

	SSignalSettingData*	GetSendDataAddress(int nIdx)
	{
		if (nIdx<0 || nIdx>=int(m_vecSendDataAddr.size())) return NULL;
		return &m_vecSendDataAddr[nIdx];
	}

	const SSignalSettingData* GetSendDataAddress(int nIdx) const
	{
		if (nIdx<0 || nIdx>=int(m_vecSendDataAddr.size())) return NULL;
		return &m_vecSendDataAddr[nIdx];
	}


	// setter
	void		SetIndex(int nIndex)							{ m_nIndex = nIndex; }
	void		SetName(const CString& strName)					{ m_strName = strName; }
	void		SetPort(int nPort)								{ m_nPort = nPort; }
	void		SetControllerType(int nType)					{ m_nControllerType = nType; }
	void		SetReceiveSignalCount(int nCount)				{ m_nReceiveSignalCount = nCount; }
	void		SetSendSignalCount(int nCount)					{ m_nSendSignalCount = nCount; }

	void		SetMSPeriod(int nTime)							{ m_nMSPeriod = nTime; }
	void		SetMSTimerTime(int nTime)						{ m_nMSTimerTime = nTime; }
	void		SetMSLodingSignalDelay(int nTime)				{ m_pMsSignalDelayTime[SignalDelayIndex_Loading] = nTime; }
	void		SetMSAlignStartSignalDelay(int nTime)			{ m_pMsSignalDelayTime[SignalDelayIndex_AlignStart] = nTime; }
	void		SetMSAlignEndSignalDelay(int nTime)				{ m_pMsSignalDelayTime[SignalDelayIndex_AlignEnd] = nTime; }
	void		SetMSReviewStartSignalDelay(int nTime)			{ m_pMsSignalDelayTime[SignalDelayIndex_ReviewStart] = nTime; }
	void		SetMSReviewEndSignalDelay(int nTime)			{ m_pMsSignalDelayTime[SignalDelayIndex_ReviewEnd] = nTime; }
	void		SetMSUnloadingSignalDelay(int nTime)			{ m_pMsSignalDelayTime[SignalDelayIndex_Unloading] = nTime; }
	void		SetMSTotalTime(int nTime)						{ m_nMSTotalTime = nTime; }
	void		SetUseContinuousReadAddress(BOOL bUse)			{ m_bUseContinuousReadAddr = bUse; }
	void		SetUseContinuousSendAddress(BOOL bUse)			{ m_bUseContinuousSendAddr = bUse; }


	void		SetReadSignalAddressCount(int nCnt)				{ m_vecReadSigAddr.resize(nCnt); }
	void		SetReadSignalAddress(CString strAddr)			{ m_vecReadSigAddr.push_back(strAddr); }
	void		SetSendSignalAddressCount(int nCnt)				{ m_vecSendSigAddr.resize(nCnt); }
	void		SetSendSignalAddress(CString strAddr)			{ m_vecSendSigAddr.push_back(strAddr); }
	void		SetReadDataAddressCount(int nCnt)				{ m_vecReadDataAddr.resize(nCnt); }

	void		SetReadDataAddress(const SSignalSettingData& data)	{ m_vecReadDataAddr.push_back(data); }
	void		SetSendDataAddressCount(int nCnt)					{ m_vecSendDataAddr.resize(nCnt); }
	void		SetSendDataAddress(const SSignalSettingData& data)	{ m_vecSendDataAddr.push_back(data); }
	
protected:
	// single - param
	int						m_nIndex;
	CString					m_strName;
	int						m_nPort;
	int						m_nControllerType;
	int						m_nReceiveSignalCount;
	int						m_nSendSignalCount;
	int						m_nMSPeriod;
	int						m_nMSTimerTime;
	int						m_nMSTotalTime;
	int						m_pMsSignalDelayTime[SignalDelayIndex_Count];

	BOOL					m_bUseContinuousReadAddr;
	BOOL					m_bUseContinuousSendAddr;

	// multi - address
	VectorCString			m_vecReadSigAddr;
	VectorCString			m_vecSendSigAddr;

	VectorSignalSettingData	m_vecReadDataAddr;
	VectorSignalSettingData	m_vecSendDataAddr;
};