// IRControl.cpp : ���� DLL Ӧ�ó���ĵ���������
//

#include "stdafx.h"
#include "IRControl.h"
#include "RedRatProcess.h"
#ifdef __MAKE_PYD__
#include "Python.h"
#endif

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#ifdef __CONSOLE__
// Ψһ��Ӧ�ó������

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
	int nRetCode = 0;

	// ��ʼ�� MFC ����ʧ��ʱ��ʾ����
	if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
	{
		// TODO: ���Ĵ�������Է���������Ҫ
		_tprintf(_T("����: MFC ��ʼ��ʧ��\n"));
		nRetCode = 1;
	}
	else
	{
		// TODO: �ڴ˴�ΪӦ�ó������Ϊ��д���롣
		// ���ӷ�����;
		if (!Connect(_T("127.0.0.1"), 40000))
			return 0;

		// ��ȡ�豸�б�,�Զ��ŷָ�;
		std::string devices = getDeviceNames();

		// ����ָ��Ŀ¼��xml�źż��ļ�;
		if ( !loadSignalDataSet("D:\\SAT\\resource\\RCU\\product\\ARTEL_WZ_RC311_2841.xml") )
		{
			TRACE("�����źż��ļ�ʧ��\r");
		}
		else
		{
			TRACE("�����źż��ļ��ɹ�\r");
		}

		Sleep(500);
		// ��ȡ�ź����ݼ�����\n�ָ�;
		std::string signals = getSignalsName();
		TRACE(signals.c_str());

		// ���͵��ź�;
		if ( sendSignal("HOME", 1, 1000) )
		{ 
			TRACE("���͵��źųɹ�\n");
		}
		else
		{
			TRACE("���͵��ź�ʧ��\n");
		}

		// ���Ͷ��ź�;
		if (sendSignals("HOME;right;right;down;up;HOME", 2))
		{
			TRACE("���Ͷ��źųɹ�\n");
		}
		else
		{
			TRACE("���Ͷ��ź�ʧ��\n");
		}

		// �����ظ��ź�;//�ظ��źű���С��256
		if (sendRepeatsSignal("right", 2))
		{
			TRACE("���Ͷ��źųɹ�\n");
		}
		else
		{
			TRACE("���Ͷ��ź�ʧ��\n");
		}

		CloseApp();
	}

	return nRetCode;
}

#endif

static CRedRatProcess g_IRControl;
#ifndef __MAKE_PYD__
// ���� DLL �ĵ��������ͱ�����
int nIRControl = 100;

IRCONTROL_API DWORD IsAppRunning(LPCTSTR lpszAppDir)
{
	return CRedRatProcess::IsAppRunning(lpszAppDir);
}

IRCONTROL_API bool StartIRApp(LPCTSTR lpszAppDir, LPCTSTR lpSignalXml, DWORD dwPort)
{
	if (!CRedRatProcess::StartApp(lpszAppDir, lpSignalXml, dwPort))
		return false;

	return true;
}

IRCONTROL_API bool CloseApp()
{
	return CRedRatProcess::CloseApp();
}

IRCONTROL_API bool Connect(LPCTSTR lpServer, int port)
{
	// ��������;
	if (!g_IRControl.InitSocket())
	{
		Global::WriteTextLog(_T("����TCP����ʧ��"));
		//g_IRControl.CloseApp();
		return false;
	}

	if (!lpServer || lpServer[0] == '\0' || port < 0)
		return false;

	//if (!g_IRControl.SelectConnect(lpServer, port, 5000))
	if (!g_IRControl.Connect(lpServer, port))
	{
		Global::WriteTextLog(_T("���ӷ�����ʧ��"));
		//g_IRControl.CloseApp();
		return false;
	}

	return true;
}

IRCONTROL_API void DisConnect()
{
	g_IRControl.DisConnect();
}

IRCONTROL_API LPCTSTR getDeviceNames()
{
	static std::string devices;
	std::vector<std::string> vtDevices;
	if ( g_IRControl.getDeviceNameList(vtDevices) )
	{
		devices.clear();
		for ( std::vector<std::string>::iterator dv = vtDevices.begin(); dv != vtDevices.end(); dv++)
		{
			devices.append(*dv + _T(";"));
		}

		return devices.c_str();
	}

	return _T("");
}

IRCONTROL_API LPCTSTR getSignalsName()
{
	static std::string signals;
	signals = g_IRControl.getSignalsName();

	return signals.c_str();
}

IRCONTROL_API bool loadSignalDataSet(LPCTSTR lpDatasetXml)
{
	if (!lpDatasetXml || lpDatasetXml[0] == '\0')
		return false;

	return g_IRControl.loadSignalDataSet(lpDatasetXml);
}

IRCONTROL_API bool sendSignal(LPCTSTR lpSignal, int send_times, int sleep_time)
{
	if (!lpSignal || lpSignal[0] == '\0')
		return false;

	return g_IRControl.sendSignal(lpSignal, send_times, sleep_time);
}

IRCONTROL_API bool sendSignals(LPCTSTR lpSignals, int sleep_time)
{
	if (!lpSignals || lpSignals[0] == '\0')
		return false;

	std::string signals = lpSignals;
	std::vector<std::string> vtSignals;
	int npos = -1;
	while (true)
	{
		npos = signals.find_first_of(';');
		if (npos == std::string::npos)
			break;

		vtSignals.push_back(signals.substr(0, npos));
		signals = signals.substr(npos + 1);
	}
	vtSignals.push_back(signals);

	return g_IRControl.sendSignals(vtSignals, sleep_time);
}

IRCONTROL_API bool sendRepeatsSignal(LPCTSTR lpSignal, int repeat_time)
{
	if (!lpSignal || lpSignal[0] == '\0')
		return false;

	return g_IRControl.sendRepeatsSignal(lpSignal, repeat_time);
}
#else

static PyObject* IsAppRunning(PyObject* self, PyObject* args)
{
	// Ӧ�ó���·��;
	const char* pszExePath = NULL;
	if (!PyArg_ParseTuple(args, "s", &pszExePath))
		return NULL;

	// ���ؽ���Id;
	return Py_BuildValue("i", CRedRatProcess::IsAppRunning(pszExePath));
}

static PyObject* StartApp(PyObject* self, PyObject* args)
{
	// Ӧ�ó���·��;
	const char* pszExePath = NULL;
	const char* pszDataset = NULL;
	unsigned int port = 0;
	if (!PyArg_ParseTuple(args, "ssI", &pszExePath, &pszDataset, &port))
		return NULL;

	return Py_BuildValue("b", CRedRatProcess::StartApp(pszExePath, pszDataset, port));
}

static PyObject* StopApp(PyObject* self, PyObject* args)
{
	return Py_BuildValue("b", CRedRatProcess::CloseApp());	// ����None;
}

//�����������豸��Ĭ����������Ϊ0���豸;
static PyObject* ConnectDevice(PyObject* self, PyObject* args)
{
	unsigned int port = 0;
	const char* pszServer = NULL;
	if (!PyArg_ParseTuple(args, "sI", &pszServer, &port))
		return NULL;

	// ��������;
	if (!g_IRControl.InitSocket())
	{
		Global::WriteTextLog(_T("����TCP����ʧ��"));
		g_IRControl.CloseApp();
		return Py_BuildValue("b", false);
	}

	if (!pszServer || pszServer[0] == '\0' || port < 0)
		return Py_BuildValue("b", false);

	if (!g_IRControl.SelectConnect(pszServer, port, 5000))
	{
		Global::WriteTextLog(_T("���ӷ�����ʧ��"));
		g_IRControl.CloseApp();
		return Py_BuildValue("b", false);
	}

	return Py_BuildValue("b", true);
}

static PyObject* DisconnectDevice(PyObject* self, PyObject* args)
{
	g_IRControl.DisConnect();
	return Py_BuildValue("");
}

static PyObject* getDeviceNames(PyObject* self, PyObject* args)
{
	std::string devices;
	std::vector<std::string> vtDevices;
	if (g_IRControl.getDeviceNameList(vtDevices))
	{
		for (std::vector<std::string>::iterator dv = vtDevices.begin(); dv != vtDevices.end(); dv++ )
		{
			devices.append(*dv + _T(";"));
		}

		return Py_BuildValue("s", devices.c_str());
	}

	return Py_BuildValue("s", "");
}

static PyObject* loadSignalDataSet(PyObject* self, PyObject* args)
{
	const char* pszDatasetXml = NULL;
	if (!PyArg_ParseTuple(args, "s", &pszDatasetXml))
		return NULL;

	if ( !pszDatasetXml || pszDatasetXml[0] == '\0')
		return Py_BuildValue("b", false);

	if (!g_IRControl.loadSignalDataSet(std::string(pszDatasetXml)) )
	{
		Global::WriteTextLog(_T("�����ź����ݼ�ʧ��"));
		g_IRControl.CloseApp();
		return Py_BuildValue("b", false);
	}

	return Py_BuildValue("b", true);
}

static PyObject* getSignalsName(PyObject* self, PyObject* args)
{
	std::string data = g_IRControl.getSignalsName();
	return Py_BuildValue("s", data.c_str());
}

static PyObject* sendSignal(PyObject* self, PyObject* args)
{
	const char* pszSignal = NULL;
	int send_times = 1, sleep_time = 1000;
	if (!PyArg_ParseTuple(args, "sii", &pszSignal, &send_times, &sleep_time))
		return NULL;

	if (!pszSignal || pszSignal[0] == '\0')
		return Py_BuildValue("b", false);

	return Py_BuildValue("b", g_IRControl.sendSignal(pszSignal, send_times, sleep_time));
}

static PyObject* sendSignals(PyObject* self, PyObject* args)
{
	const char* pszSignal = NULL;
	int sleep_time = 1000;
	if (!PyArg_ParseTuple(args, "si", &pszSignal, &sleep_time))
		return NULL;

	if (!pszSignal || pszSignal[0] == '\0')
		return Py_BuildValue("b", false);

	std::string signals = pszSignal;
	std::vector<std::string> vtSignals;
	int npos = -1;
	while (true)
	{
		npos = signals.find_first_of(';');
		if (npos == std::string::npos)
			break;

		vtSignals.push_back(signals.substr(0, npos));
		signals = signals.substr(npos + 1);
	}
	vtSignals.push_back(signals);

	return Py_BuildValue("b", g_IRControl.sendSignals(vtSignals, sleep_time));
}

static PyObject* sendRepeatsSignal(PyObject* self, PyObject* args)
{
	const char* pszSignal = NULL;
	int repeat_time = 2;
	if (!PyArg_ParseTuple(args, "si", &pszSignal, &repeat_time))
		return NULL;

	if (!pszSignal || pszSignal[0] == '\0')
		return Py_BuildValue("b", false);

	return Py_BuildValue("b", g_IRControl.sendRepeatsSignal(pszSignal, repeat_time));
}

static PyObject* sendDurationSignal(PyObject* self, PyObject* args)
{
	const char* pszSignal = NULL;
	int duration_time = 2;
	if (!PyArg_ParseTuple(args, "si", &pszSignal, &duration_time))
		return NULL;

	if (!pszSignal || pszSignal[0] == '\0')
		return Py_BuildValue("b", false);

	return Py_BuildValue("b", g_IRControl.sendDurationSignal(pszSignal, duration_time));
}

// ��������,��¶��python�ĺ���;
static PyMethodDef IRControl_Methods[] = {
	{"IsAppRunning",IsAppRunning,METH_VARARGS,"�����Ƿ�������"},
	{"StartApp", StartApp, METH_VARARGS, "��������"},
	{"StopApp", StopApp, METH_VARARGS, "�رս���"},
	{"ConnectDevice", ConnectDevice, METH_VARARGS, "�����豸"},
	{"DisconnectDevice", DisconnectDevice, METH_VARARGS, "�Ͽ��豸"},
	{"getDeviceNames", getDeviceNames, METH_VARARGS, "��ȡ�豸�б������ŷָ�"},
	{"loadSignalDataSet", loadSignalDataSet, METH_VARARGS, "����ָ��Ŀ¼���ź����ݼ�XML�ļ�"},
	{"getSignalsName", getSignalsName, METH_VARARGS, "��ȡĬ���ź����ݼ��ź��б�"},
	{"sendSignal", sendSignal, METH_VARARGS, "���͵����ź�"},
	{"sendSignals", sendSignals, METH_VARARGS, "���Ͷ���źţ��Էֺ�Ϊ�ָ���"},
	{"sendRepeatsSignal", sendRepeatsSignal, METH_VARARGS, "�����ظ��ź�"},
	{"sendDurationSignal", sendDurationSignal, METH_VARARGS, "����ʱ���ź�"},

	{NULL,NULL}
};

// ��ʼģ��;//��ʽ��init<ģ������>
PyMODINIT_FUNC initIRControl()
{
	// ��ʼ��pyd�����б�;
	PyObject* m, * d;
	m = Py_InitModule("IRControl", IRControl_Methods);
	d = PyModule_GetDict(m);
}
#endif