#ifndef _MOD_HSPSCANNER_H_
#define _MOD_HSPSCANNER_H_

#pragma once

#include "modVer.h"
#include "SpTest.h"
#include "HSPScannerFSM.h"
#include "DevEntityCommBase.hpp"

using namespace HSPScanner;

class CHSPScannerEntity;

class CHSPScannerServerSession: public HSPScannerService_ServerSessionBase
{

public:
	CHSPScannerServerSession(CHSPScannerEntity *pEntity):m_pEntity(pEntity){}
	virtual ~CHSPScannerServerSession(){}

	virtual void Handle_StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req, 
		HSPScannerService_StartPreview_Ans>::Pointer ctx);

	virtual void Handle_CancelPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx);

	virtual void Handle_ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req, 
		HSPScannerService_ScanImage_Ans>::Pointer ctx);

	virtual void Handle_ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Req,
		HSPScannerService_ScanImageEx_Ans>::Pointer ctx);

	virtual void Handle_SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req,
		HSPScannerService_SetProperty_Ans>::Pointer ctx);

	virtual void Handle_SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req, 
		HSPScannerService_SetWinPos_Ans>::Pointer ctx);

	virtual void Handle_ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req,
		HSPScannerService_ShowProperty_Ans>::Pointer ctx);

	virtual void Handle_GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req,
		HSPScannerService_GetDevStatus_Ans>::Pointer ctx);

	virtual void Handle_GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
		HSPScannerService_GetDevInfo_Ans>::Pointer ctx);

	virtual void Handle_Exit(SpOnewayCallContext<HSPScannerService_Exit_Info>::Pointer ctx);

private:
	CHSPScannerEntity *m_pEntity;
};


class CHSPScannerEntity : public CDevAdptEntityBase
{
public:
	CHSPScannerEntity() {}
	virtual ~CHSPScannerEntity() {}
	virtual const char *GetEntityName() const { return "HSPScanner"; }

    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

    ON_ENTITYT_TEST()
	virtual CServerSessionBase* OnNewSession(const char* , const char * )
	{
		//LOG_FUNCTION();
		return new CHSPScannerServerSession(this);
	}

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,
		CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum erroCode = m_fsm.Init(this);
		pTransactionContext->SendAnswer(erroCode);
	}
	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,
		CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();
		ErrorCodeEnum erroCode = m_fsm.OnExit();
		pTransactionContext->SendAnswer(erroCode);
	}

	void Preview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
		HSPScannerService_StartPreview_Ans>::Pointer ctx)
	{
		StartPreviewEvent* pEvent = new StartPreviewEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void CancelPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx)
	{
		StopPreviewEvent* pEvent = new StopPreviewEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req,
		HSPScannerService_ScanImage_Ans>::Pointer ctx)
	{
		ScanImageEvent* pEvent = new ScanImageEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Req,
		HSPScannerService_ScanImageEx_Ans>::Pointer ctx)
	{
		ScanImageExEvent* pEvent = new ScanImageExEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void Exit(SpOnewayCallContext<HSPScannerService_Exit_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_fsm.PostEventFIFO(new FSMEvent(USER_EVT_EXIT));
	}

	void GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
		HSPScannerService_GetDevInfo_Ans>::Pointer ctx)
	{
		GetDevInfoEvent* pEvent = new GetDevInfoEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req,
		HSPScannerService_GetDevStatus_Ans>::Pointer ctx)
	{
		GetDevStatusEvent* pEvent = new GetDevStatusEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req,
		HSPScannerService_SetWinPos_Ans>::Pointer ctx)
	{
		SetWinPosEvent* pEvent = new SetWinPosEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req,
		HSPScannerService_ShowProperty_Ans>::Pointer ctx)
	{
		ShowPropertyEvent* pEvent = new ShowPropertyEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req,
		HSPScannerService_SetProperty_Ans>::Pointer ctx)
	{
		SetPropertyEvent* pEvent = new SetPropertyEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType, pTransactionContext);
	}

	virtual bool IsService() const { return true; }
	virtual bool IsMultiThread() const { return true; }; 

private:
	CHSPScannerFSM m_fsm;
};

#endif