// DPC.cpp : 定义 DLL 应用程序的导出函数。
//

#include "DPC.h"
#include "RawCircleBuff.h"

/*
DPC::DPC()
{
	m_pLog = NULL;
};
DPC::~DPC()
{
};

//DPC入口，根据配置进行初始化
//配置的格式要复合JSON规则，具体内容由各个驱动执行定义
//配置内容是加载前驱动所需要的配置内容
bool DPC::DpcEntry(ResDataObject& PARAM_IN Configuration)
{
	//err log here
	return false;
}

//获取连接属性
//多个SCF的情况下，将会有多个连接属性
ResDataObject DPC::GetConnectionType()
{
	//err log here
	return ResDataObject();
}

//进行跟设备连接
bool SYSTEM_CALL DPC::Connect(ResDataObject& PARAM_IN Connection)
{
	//err log here
	return false;
}

//判断设备的存在性.
//检索成功后，返回【硬件信息资源】
bool SYSTEM_CALL DPC::Probe(ResDataObject& PARAM_OUT HardwareInfo)
{
	//err log here
	return false;

}

bool SYSTEM_CALL DPC::OnNotify(HANDLE ExitNotify)
{
	//get SCF Notify
	//get Exit Notify
	//wait for SCF+Exit Notify
	//try lock scf
		//try get data.
		//translate it
		//dispatch it
	//unlock


	return false;
}

//给硬件驱动设置Unique工作路径
//如果是同一设备同一连接情况下，硬件多次接入，系统会保证工作路径是一样的.
//连接后，单一硬件相关的数据要保存在此.
bool SYSTEM_CALL DPC::SetWorkPath(const char * PARAM_IN pWorkPath)
{
	//err log here
	return false;

}

//逻辑设备树的加载和卸载
PVOID SYSTEM_CALL DPC::LoadLogicDevices()
{
	//err log here
	return NULL;

}

void SYSTEM_CALL DPC::UnloadLogicDevices(PVOID PARAM_IN p)
{
	//err log here
}

bool SYSTEM_CALL DPC::DisConnect()
{
	//err log here
	return false;
}

void SYSTEM_CALL DPC::SetLogHandle(Logger PARAM_IN *pLogger)
{
	m_pLog = pLogger;
}
*/


//----------------------------------------------------------------------------

DriverDPC::DriverDPC()
{
	//m_pLog = NULL;
	//m_pDynLog = NULL;
	m_pDriverTree = new DevTree();//for static 
	m_pDeviceTree = new DevTree();//for dyn


	m_pCircleBuff = new CircleBuff();

	m_pDriverConfigFilepath = new ResDataObject();

};
DriverDPC::~DriverDPC()
{
	delete m_pDriverTree;
	delete m_pDeviceTree;
	delete (CircleBuff*)m_pCircleBuff;

	delete m_pDriverConfigFilepath;

	m_pDriverTree = NULL;
	m_pDeviceTree = NULL;
	m_pCircleBuff = NULL;



};

const char *DriverDPC::GetDriverConfigFilePath()
{
	return (const char *)(*m_pDriverConfigFilepath);
}

void DriverDPC::SetDriverConfigFilePath(const char *pfilepath)
{
	(*m_pDriverConfigFilepath) = pfilepath;
}



bool DriverDPC::BuffSetNotifyBuffSize(DWORD newSize, DWORD Limit)
{
	((CircleBuff*)m_pCircleBuff)->SetBuffMaxLimit(Limit);

	return (((CircleBuff*)m_pCircleBuff)->ReSetBuffSize(newSize));
}

DWORD DriverDPC::BuffQueNotify(const char *pBuff, DWORD Size)
{
	return ((CircleBuff*)m_pCircleBuff)->Push(pBuff, Size);
}

INT DriverDPC::BuffDequeNotify(char *pBuff, DWORD Size)
{
	return ((CircleBuff*)m_pCircleBuff)->Pop(pBuff, Size);
}

PVOID DriverDPC::GetDriverTree()
{
	return m_pDriverTree;
}

PVOID DriverDPC::GetDeviceTree()
{
	return m_pDeviceTree;
}


bool SYSTEM_CALL DriverDPC::DriverEntry(ResDataObject& PARAM_IN Configuration)
{

	return false;
}

//进行跟设备连接,断开
bool  DriverDPC::Connect()
{
	return false;
}

void  DriverDPC::DisConnect()
{

}

//返回【驱动信息资源】
bool SYSTEM_CALL DriverDPC::Driver_Probe(ResDataObject& PARAM_OUT DriverInfo)
{
	return false;

}

RET_STATUS SYSTEM_CALL DriverDPC::GetDriverDictionary(ResDataObject& PARAM_OUT DriverInfo)
{
	return RET_FAILED;
}

//给驱动设置Unique工作路径
bool SYSTEM_CALL DriverDPC::SetDriverWorkPath(const char * PARAM_IN pWorkPath)
{
	return false;

}


//逻辑驱动树的加载和卸载
//根节点就是 this
PVOID SYSTEM_CALL DriverDPC::LoadDriver()
{
	return NULL;
}

void SYSTEM_CALL DriverDPC::UnloadDriver()
{

}


//判断设备的存在性.
//检索成功后，返回【硬件信息资源】
bool SYSTEM_CALL DriverDPC::Device_Probe(ResDataObject& PARAM_OUT HardwareInfo)
{
	return false;
}


//给硬件驱动设置Unique工作路径
//如果是同一设备同一连接情况下，硬件多次接入，系统会保证工作路径是一样的.
//连接后，单一硬件相关的数据要保存在此.
bool SYSTEM_CALL DriverDPC::SetDeviceWorkPath(const char * PARAM_IN pWorkPath)
{
	return false;
}

//逻辑设备树的加载和卸载
PVOID SYSTEM_CALL DriverDPC::LoadLogicDevices()
{
	return NULL;
}

void SYSTEM_CALL DriverDPC::UnloadLogicDevices()
{

}


//void SYSTEM_CALL DriverDPC::SetLogHandle(Logger PARAM_IN *pLogger)
//{
//	m_pLog = pLogger;
//}
//
//void SYSTEM_CALL DriverDPC::SetDynLogHandle(Logger PARAM_IN *pLogger)
//{
//	m_pDynLog = pLogger;
//}


DWORD DriverDPC::OnNotify(std::vector<std::shared_ptr<LinuxEvent>> evtList, DWORD count) {
	return (LinuxEvent::WaitForMultipleEvents(evtList,-1) - 0);
}

DPCDRIVERTYPE SYSTEM_CALL DriverDPC::GetDPCType()
{
	return DPCDRIVER_NORMAL;
}

void  DriverDPC::FirstAction()
{
	printf("DPC Thread First Action...\n");
}