#include "stdafx.h"
#include "DIOSBoardCommunicateEntity.h"
#include "DIOSBoardProtocolHelper.h"
#include "IDIOSBoardController.h"
#include "DIOSBoardFactory.h"
#include "IDIOSBoardPacketRecevier.h"
#include "IOInterfaceMapper.h"
#include "NotifyPacket.h"

using namespace DIOS::Dev::Communication::Detail;
using namespace DIOS::Dev::Detail::MachineryECOM;

DIOSBoardCommunicateEntity::DIOSBoardCommunicateEntity() 
:m_DiosBoard(nullptr),
m_SendPacket(nullptr),
m_ReceivePacket(nullptr)
{
}


DIOSBoardCommunicateEntity::~DIOSBoardCommunicateEntity()
{
	if (m_SendPacket)
	{
		ReleaseSCFPacket(m_SendPacket);
	}
	if (m_ReceivePacket)
	{
		ReleaseSCFPacket(m_ReceivePacket);
	}
}

bool DIOSBoardCommunicateEntity::Initialize(IDIOSBoardPacketRecevier *packetReceiver)
{
	if (packetReceiver)
	{
		AddReceiver(packetReceiver);
	}

	m_SendPacket = (SCFPacket *)MallocSCFPacket();
	m_ReceivePacket = (SCFPacket *)MallocSCFPacket();

	return true;
}

bool DIOSBoardCommunicateEntity::Connect(SCF* pSCF, ResDataObject& Connection,HANDLE disconnectListenerhandle, const std::string &ioboardName)
{
	bool connected = false;

	if (!m_DiosBoard)
	{
		auto boardname = ioboardName;
		if (boardname == "")
		{
			boardname = ECOM_DIOSBOARD;
		}

		//if(gcommLog) gcommLog->Info("[DIOSBoardCommunicateEntity][Connect]->[Create Diosboard controller %s]", boardname.c_str());
		{ if (gcommLog) { gcommLog->Info("[DIOSBoardCommunicateEntity][Connect]->[Create Diosboard controller {$}]", boardname.c_str()); } }

		m_DiosBoard = DIOSBoardFactory::Instance()->CreateSingleton(boardname/*ECOM_DIOSBOARD*/);
		if (m_DiosBoard)
		{
			m_DiosBoard->Initialize(pSCF);
			m_DiosBoard->SetPassiveDisconnectEventHandle(disconnectListenerhandle);
		}
	
	}


	if (m_DiosBoard)
	{
		if(gcommLog) gcommLog->Info("[DIOSBoardCommunicateEntity][Connect]->[Start to connect diosboard]");

		connected = m_DiosBoard->Connect(Connection);
		if (connected)
		{
			connected = SendInitDiosBoardCommands();

			if(gcommLog) gcommLog->Info("[DIOSBoardCommunicateEntity][Connect]->[Connected]");
		}
	}

	return connected;
}

bool DIOSBoardCommunicateEntity::Disonnect()
{
	if (m_DiosBoard)
	{
		return m_DiosBoard->Disonnect();
	}

	return m_DiosBoard != nullptr;
}

int DIOSBoardCommunicateEntity::GPIO_DO_Ctrl(DIOSBOARD_OP op, GPIO_DO_ID id, GPIO_DO_ATTRIBUTE attr, GPIO_DO_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_SET)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeGpioDOSetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}		
	}
	else if (op == OP_WRITE)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeGpioDOWritePacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}

	m_DiosBoard->UnLock();
	
	return 0;
}

int DIOSBoardCommunicateEntity::GPIO_DI_Ctrl(DIOSBOARD_OP op, GPIO_DI_ID id, GPIO_DI_ATTRIBUTE attr, GPIO_DI_PARAM &params)
{
	if (op == OP_SET)
	{
		m_DiosBoard->Lock();

		if (DIOSBoardProtocolHelper::Instance()->MakeGpioDISetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}

		m_DiosBoard->UnLock();
	}
	else if (op == OP_READ)
	{
		FUNCTIONID functionid;
		functionid.CharPart = id;
		char context[4] = { 0 };

		int readLen = Read(functionid, context, 4);
		if (readLen > 0)
		{
			if (params.input_mode == GIM_DIGITAL)
			{
				params.active_level = context[0];
			}
			else if (params.input_mode == GIM_PULSE_COUNT && readLen >= 2)
			{
				params.pulse_count.pulse_count_byte.pulse_count_lowbyte = context[0];
				params.pulse_count.pulse_count_byte.pulse_count_highbyte = context[1];
			}
		}
	}

	return 0;
}

int DIOSBoardCommunicateEntity::AD_Ctrl(DIOSBOARD_OP op, AD_ID id, AD_ATTRIBUTE attr, AD_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_SET)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeADSetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}
	else if (op == OP_READ)
	{
		FUNCTIONID functionid;
		functionid.CharPart = id;
		char context[4] = { 0 };

		int readLen = Read(functionid, context, 4);
		if (readLen > 0)
		{
			params.ad_value.ad_value_btye.ad_lowbyte = context[0];
			params.ad_value.ad_value_btye.ad_highbyte = context[1];
		}
	}

	m_DiosBoard->UnLock();

	return 0;
}

int DIOSBoardCommunicateEntity::RS232_Ctrl(DIOSBOARD_OP op, RS232_ID id, RS232_ATTRIBUTE attr, RS232_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_SET)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeRS232SetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}
	else if (op == OP_WRITE)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeData485WritePacket(
			(const char *)params.rs485.data(), (unsigned int)params.rs485.length(), m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}
	
	m_DiosBoard->UnLock();

	return 0;
}

int DIOSBoardCommunicateEntity::CAN_Ctrl(DIOSBOARD_OP op, CAN_ID id, CAN_ATTRIBUTE attr, CAN_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_SET)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeCanSetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}
	else if (op == OP_READ)
	{
		ReadCanData(id, params.can_stdid, m_SendPacket, m_ReceivePacket, params);
	}
	else if (op == OP_WRITE)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeCanWritePacket(id,params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}

	m_DiosBoard->UnLock();

	return 0;
}

int DIOSBoardCommunicateEntity::SEC_Ctrl(DIOSBOARD_OP op, SEC_ID id, SEC_ATTRIBUTE attr, SEC_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_SET)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeSECSetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}
	else if (op == OP_READ)
	{
		FUNCTIONID functionid;
		functionid.CharPart = id;
		char context[8] = { 0 };

		int readLen = Read(functionid, context, 8);
		if (readLen > 0)
		{
			params.encoder_value.encoder_value_byte.encoder_lowbyte_0 = context[0];
			params.encoder_value.encoder_value_byte.encoder_lowbyte_1 = context[1];
			params.encoder_value.encoder_value_byte.encoder_highbyte_0 = context[2];
			params.encoder_value.encoder_value_byte.encoder_highbyte_1 = context[3];
		}
	}

	m_DiosBoard->UnLock();

	return 0;
}

int DIOSBoardCommunicateEntity::SCL_Ctrl(DIOSBOARD_OP op, SCL_ID id, SCL_ATTRIBUTE attr, SCL_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_SET)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeSCLSetPacket(id, attr, params, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}

	m_DiosBoard->UnLock();

	return 0;
}

int DIOSBoardCommunicateEntity::ExposureCtrl(DIOSBOARD_OP op, EXPOSURE_ID id, EXPOSURE_PARAM &params)
{
	m_DiosBoard->Lock();

	if (op == OP_WRITE)
	{
		if (DIOSBoardProtocolHelper::Instance()->MakeExposureWritePacket(id, params.active_level, m_SendPacket))
		{
			m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);
		}
	}

	m_DiosBoard->UnLock();

	return 0;
}

int DIOSBoardCommunicateEntity::MCU_Ctrl(DIOSBOARD_OP op, MCU_ID id, MCU_ATTRIBUTE attr, MCU_PARAM &params)
{

	if (op == OP_READ)
	{
		if (attr == MCU_ATTR_VERSION)
		{
			FUNCTIONID functionid;
			functionid.CharPart = (unsigned char)id;
			char context[1] = { (char)attr };
			char rescontext[20] = {0};
			if (ReadEx(functionid, context, 1, rescontext, 20) > 0)
			{
				params.mcu_version.version_byte.version_lowbyte = rescontext[0];
				params.mcu_version.version_byte.version_highbyte = rescontext[1];
			}
		}		
	}

	return 0;
}

bool DIOSBoardCommunicateEntity::SendInitDiosBoardCommands()
{
	bool bRes = true;

	if (!m_DiosBoard)
	{
		return false;
	}

	return bRes;
}

int  DIOSBoardCommunicateEntity::Read(FUNCTIONID Id, char *pszContext, unsigned int PacketLen)
{
	if (!m_DiosBoard)
	{
		return -1;
	}

	m_DiosBoard->Lock();

	DIOSBoardProtocolHelper::Instance()->MakeReadDataPacket(Id, m_SendPacket);

	m_DiosBoard->ReceiveACK(m_SendPacket, m_ReceivePacket, pszContext, PacketLen);

	m_DiosBoard->UnLock();

	return PacketLen;
}

int  DIOSBoardCommunicateEntity::ReadEx(FUNCTIONID Id, char *pszRes, unsigned int ResLen, char *pszContext, unsigned int PacketLen)
{
	if (!m_DiosBoard)
	{
		return -1;
	}
	m_DiosBoard->Lock();

	DIOSBoardProtocolHelper::Instance()->MakeReadDataExPacket(Id, pszRes, ResLen, m_SendPacket);

	m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);

	int retLen = -1;

	if (ReceiveACK(m_SendPacket, m_ReceivePacket, DIOSCTRLCPU_COM_TIMEOUT))
	{
		CTRLPACKETHEAD *pReceiveHead = (CTRLPACKETHEAD *)((char *)(*m_ReceivePacket));
		int dataLen = pReceiveHead->FrameSize - 5;
		dataLen = min((int)PacketLen, dataLen);
		if (dataLen > 0)
		{
			unsigned char *pData = &(pReceiveHead->Data1);
			memcpy(pszContext, pData, dataLen);
		}

		retLen = dataLen;
	}

	m_DiosBoard->UnLock();

	return retLen;
}

int	 DIOSBoardCommunicateEntity::ReadFrame(FUNCTIONID Id, char *pszContext, unsigned int PacketLen, unsigned char FrameCmd)
{
	unsigned int readLen = 0;

	if (!m_DiosBoard)
	{
		return readLen;
	}
	m_DiosBoard->Lock();

	DIOSBoardProtocolHelper::Instance()->MakeReadDataPacket(Id, m_SendPacket);
	m_DiosBoard->ReceiveFrame(m_SendPacket, m_ReceivePacket, Id, FrameCmd, pszContext, PacketLen, readLen);

	m_DiosBoard->UnLock();

	return readLen;
}

int  DIOSBoardCommunicateEntity::ReadCanData(CAN_ID Id, unsigned short stdid, SCFPacket *sendPacket, SCFPacket *RecvPacket, CAN_PARAM &params)
{
	if (!m_DiosBoard)
	{
		return -1;
	}

	if (!DIOSBoardProtocolHelper::Instance()->MakeCanWritePacket(Id, params, m_SendPacket))
	{
		return -1;
	}

	m_DiosBoard->Lock();

	m_DiosBoard->Send(m_SendPacket, m_ReceivePacket);

	auto ret = ReceiveCanFream(Id,stdid,params);

	m_DiosBoard->UnLock();

	return ret?0:-1;
}

void DIOSBoardCommunicateEntity::OnReceivedPacketNotMatched(SCFPacket *RecvPacket)
{
	if (m_DiosBoard)
	{
		m_DiosBoard->QueNotifyPacket(RecvPacket);
	}
}

void DIOSBoardCommunicateEntity::OnReceiveFrameNotMatched(char *packet, int length)
{
	m_ReceivePacket->SetPacket(packet, length);
	NotifyPacket notifyPacket(m_ReceivePacket);
	Notify(notifyPacket);
}

bool DIOSBoardCommunicateEntity::ReceiveACK(SCFPacket *sendPacket, SCFPacket *RecvPacket,DWORD timeout)
{
	return false;
}

bool DIOSBoardCommunicateEntity::ReceiveFrame(FUNCTIONID Id, unsigned char FrameCmd, char *pszContext,unsigned int PacketLen, unsigned int& nDataLen, DWORD Timeout)
{
	return false;
}

union _canStdid
{
	unsigned short stdid_short;
	struct _ststdid
	{
		unsigned char low_byte;
		unsigned char high_byte;
	} stdid_byte;
};

bool DIOSBoardCommunicateEntity::ReceiveCanFream(CAN_ID Id, unsigned short stdid, CAN_PARAM &params, DWORD Timeout)
{
	//TPRINTA_DEBUG("Enter ReceiveCanFream");

	//DWORD StartTick = GetTickCount();
	//DWORD TimePeriod = Timeout;
	//int nPacketLen = 0;
	//char pPacket[MAX_PATH] = { 0 };

	//while ((GetTickCount() - StartTick) < Timeout)
	//{
	//	memset(pPacket, 0, MAX_PATH);

	//	if ((nPacketLen = m_DiosBoard->Receive(pPacket, MAX_PATH, 500)) > 0)
	//	{
	//		CTRLPACKETHEAD *pReceiveHead = (CTRLPACKETHEAD *)((char *)(pPacket));

	//		if (pReceiveHead->FrameCmd == 0xFE 
	//			&& pReceiveHead->FuncId == (unsigned char)Id
	//			)
	//		{
	//			_canStdid canstdid;
	//			canstdid.stdid_byte.low_byte = pReceiveHead->Data2;
	//			canstdid.stdid_byte.high_byte = pReceiveHead->Data3;
	//			if (canstdid.stdid_short == params.can_stdid)
	//			{
	//				int canDataLen = pReceiveHead->Data4;
	//				if (canDataLen > 8 || canDataLen < 0)
	//				{
	//					canDataLen = 8;
	//				}
	//				params.candata.clear();
	//				for (int i = 0; i < canDataLen;++i)
	//				{
	//					params.candata.push_back(((unsigned char*)&pReceiveHead->Data5)[i]);
	//				}
	//			}

	//			TPRINTA_DEBUG("Leave ReceiveResult, WaitIO NOTIFY:SUCCEED");

	//			return true;
	//		}
	//		else
	//		{
	//			TPRINTA_DEBUG("Got Other Packet");
	//			OnReceiveFrameNotMatched(pPacket, nPacketLen);
	//		}
	//	}
	//	else
	//	{
	//		TPRINTA_DEBUG("WaitIO NOTIFY:FAILED");
	//	}

	//}

	//TPRINTA_DEBUG("Leave ReceiveResult, WaitIO NOTIFY:FAILED");
	//TPRINTA_ERROR("Leave ReceiveResult, WaitIO NOTIFY:FAILED");

	return false;
}