#include "StdAfx.h"
#include "ServiceUnits.h"
#include "ControlPacket.h"
#include "HttpThread.h"
#include "google/protobuf/stubs/common.h"
//////////////////////////////////////////////////////////////////////////////////

//静态变量
CServiceUnits * CServiceUnits::g_pServiceUnits = NULL; //对象指针

//////////////////////////////////////////////////////////////////////////////////

BEGIN_MESSAGE_MAP(CServiceUnits, CWnd)
    ON_MESSAGE(WM_UICONTROL_REQUEST, OnUIControlRequest)
END_MESSAGE_MAP()

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CServiceUnits::CServiceUnits()
{
    //设置变量
    m_ServiceStatus = ServiceStatus_Stop;

    //设置接口
    m_pIServiceUnitsSink = NULL;

    //设置对象
    ASSERT(g_pServiceUnits == NULL);
    if (g_pServiceUnits == NULL) g_pServiceUnits = this;

    return;
}

//析构函数
CServiceUnits::~CServiceUnits()
{
    ConcludeService();
}

//启动服务
bool CServiceUnits::StartService()
{
	Logger::GetInstance().InitDefaultLog("LoginServer", "daily_log.log");
	//效验状态
	ASSERT(m_ServiceStatus == ServiceStatus_Stop);
	if (m_ServiceStatus != ServiceStatus_Stop) return false;

    //设置状态
    SetServiceStatus(ServiceStatus_Config);

    //创建窗口
    if (m_hWnd == NULL)
    {
        CRect rcCreate(0, 0, 0, 0);
        Create(NULL, NULL, WS_CHILD, rcCreate, AfxGetMainWnd(), 100);
    }

    //配置服务
    if (InitializeService() == false)
    {
        ConcludeService();
        return false;
    }

    //启动内核
    if (StartKernelService() == false)
    {
        ConcludeService();
        return false;
    }

    //获取列表
    SendControlPacket(CT_LOAD_DB_GAME_LIST, NULL, 0);
	//启动GET请求队列
	CHttpClient::start(&m_AttemperEngineSink);
    return true;
}

//停止服务
bool CServiceUnits::ConcludeService()
{
	//停止GET请求队列
	CHttpClient::end();
    //设置变量
    SetServiceStatus(ServiceStatus_Stop);

    //停止服务
    if (m_TimerEngine.GetInterface() != NULL) m_TimerEngine->ConcludeService();
    if (m_AttemperEngine.GetInterface() != NULL) m_AttemperEngine->ConcludeService();
    if (m_DataBaseEngine.GetInterface() != NULL) m_DataBaseEngine->ConcludeService();
    if (m_TCPNetworkEngine.GetInterface() != NULL) m_TCPNetworkEngine->ConcludeService();
    if (m_TCPSocketService.GetInterface() != NULL) m_TCPSocketService->ConcludeService();
	//c++中使用google protobuf在关闭应用程序之前需要调用google::protobuf::ShutdownProtobufLibrary();要不然会有内存泄露
	google::protobuf::ShutdownProtobufLibrary();
	Logger::ShutDown();
	m_RedisClient->DisConnect();
    return true;
}

//设置接口
bool CServiceUnits::SetServiceUnitsSink(IServiceUnitsSink * pIServiceUnitsSink)
{
    //设置变量
    m_pIServiceUnitsSink = pIServiceUnitsSink;

    return true;
}

//投递请求
bool CServiceUnits::PostControlRequest(WORD wIdentifier, VOID * pData, WORD wDataSize)
{
    //状态判断
    ASSERT(IsWindow(m_hWnd));
    if (IsWindow(m_hWnd) == FALSE) return false;

    //插入队列
    CWHDataLocker DataLocker(m_CriticalSection);
    if (m_DataQueue.InsertData(wIdentifier, pData, wDataSize) == false) return false;

    //发送消息
    PostMessage(WM_UICONTROL_REQUEST, wIdentifier, wDataSize);

    return true;
}

//配置组件
bool CServiceUnits::InitializeService()
{
    //加载参数
    m_InitParameter.LoadInitParameter();

    //创建组件
    if ((m_TimerEngine.GetInterface() == NULL) && (m_TimerEngine.CreateInstance() == false)) return false;
    if ((m_AttemperEngine.GetInterface() == NULL) && (m_AttemperEngine.CreateInstance() == false)) return false;
    if ((m_DataBaseEngine.GetInterface() == NULL) && (m_DataBaseEngine.CreateInstance() == false)) return false;
    if ((m_TCPNetworkEngine.GetInterface() == NULL) && (m_TCPNetworkEngine.CreateInstance() == false)) return false;
    if ((m_TCPSocketService.GetInterface() == NULL) && (m_TCPSocketService.CreateInstance() == false)) return false;

    //组件接口
    IUnknownEx * pIAttemperEngine = m_AttemperEngine.GetInterface();
    IUnknownEx * pITCPNetworkEngine = m_TCPNetworkEngine.GetInterface();
    IUnknownEx * pIAttemperEngineSink = QUERY_OBJECT_INTERFACE(m_AttemperEngineSink, IUnknownEx);

    //数据引擎
    IUnknownEx * pIDataBaseEngineSink[CountArray(m_DataBaseEngineSink)];
    for (WORD i = 0; i < CountArray(pIDataBaseEngineSink); i++) pIDataBaseEngineSink[i] = QUERY_OBJECT_INTERFACE(m_DataBaseEngineSink[i], IUnknownEx);

    //内核组件
    if (m_TimerEngine->SetTimerEngineEvent(pIAttemperEngine) == false) return false;
    if (m_AttemperEngine->SetNetworkEngine(pITCPNetworkEngine) == false) return false;
    if (m_AttemperEngine->SetAttemperEngineSink(pIAttemperEngineSink) == false) return false;
    if (m_TCPNetworkEngine->SetTCPNetworkEngineEvent(pIAttemperEngine) == false) return false;
    if (m_DataBaseEngine->SetDataBaseEngineSink(pIDataBaseEngineSink, CountArray(pIDataBaseEngineSink)) == false) return false;

    //协调服务
    if (m_TCPSocketService->SetServiceID(NETWORK_CORRESPOND) == false) return false;
    if (m_TCPSocketService->SetTCPSocketEvent(pIAttemperEngine) == false) return false;

    //调度回调
    m_AttemperEngineSink.m_pInitParameter = &m_InitParameter;
    m_AttemperEngineSink.m_pITimerEngine = m_TimerEngine.GetInterface();
    m_AttemperEngineSink.m_pIDataBaseEngine = m_DataBaseEngine.GetInterface();
    m_AttemperEngineSink.m_pITCPNetworkEngine = m_TCPNetworkEngine.GetInterface();
    m_AttemperEngineSink.m_pITCPSocketService = m_TCPSocketService.GetInterface();

    //数据库回调
    for (INT i = 0; i < CountArray(m_DataBaseEngineSink); i++)
    {
        m_DataBaseEngineSink[i].m_pInitParameter = &m_InitParameter;
        m_DataBaseEngineSink[i].m_pIDataBaseEngineEvent = QUERY_OBJECT_PTR_INTERFACE(pIAttemperEngine, IDataBaseEngineEvent);
    }

    //配置网络
    WORD wMaxConnect = m_InitParameter.m_wMaxConnect;
    WORD wServicePort = m_InitParameter.m_wServicePort;
    if (m_TCPNetworkEngine->SetServiceParameter(wServicePort, wMaxConnect, szCompilation) == false) return false;

	//连接redis
	m_RedisClient = std::make_shared<RedisBase>();
	m_RedisClient->Connect(m_InitParameter.m_RedisHost, m_InitParameter.m_RedisPort, m_InitParameter.m_RedisDb, m_InitParameter.m_RedisTimeOut, m_InitParameter.m_RedisMaxReconnect, m_InitParameter.m_RedisReconnectInterval);
	m_AttemperEngineSink.m_RedisClient = m_RedisClient;
    return true;
}

//启动内核
bool CServiceUnits::StartKernelService()
{
    //时间引擎
    if (m_TimerEngine->StartService() == false)
    {
        ASSERT(FALSE);
        return false;
    }

    //调度引擎
    if (m_AttemperEngine->StartService() == false)
    {
        ASSERT(FALSE);
        return false;
    }

    //数据引擎
    if (m_DataBaseEngine->StartService() == false)
    {
        ASSERT(FALSE);
        return false;
    }

    //协调引擎
    if (m_TCPSocketService->StartService() == false)
    {
        ASSERT(FALSE);
        return false;
    }

    return true;
}

//启动网络
bool CServiceUnits::StartNetworkService()
{
    //网络引擎
    if (m_TCPNetworkEngine->StartService() == false)
    {
        ASSERT(FALSE);
        return false;
    }

    return true;
}

//设置状态
bool CServiceUnits::SetServiceStatus(enServiceStatus ServiceStatus)
{
    //状态判断
    if (m_ServiceStatus != ServiceStatus)
    {
        //错误通知
        if ((m_ServiceStatus != ServiceStatus_Service) && (ServiceStatus == ServiceStatus_Stop))
        {
            LPCTSTR pszString = TEXT("服务启动失败");
            CTraceService::TraceString(pszString, TraceLevel_Exception);
        }

        //设置变量
        m_ServiceStatus = ServiceStatus;

        //状态通知
        ASSERT(m_pIServiceUnitsSink != NULL);
        if (m_pIServiceUnitsSink != NULL) m_pIServiceUnitsSink->OnServiceUnitsStatus(m_ServiceStatus);
    }

    return true;
}

//发送控制
bool CServiceUnits::SendControlPacket(WORD wControlID, VOID * pData, WORD wDataSize)
{
    //状态效验
    ASSERT(m_AttemperEngine.GetInterface() != NULL);
    if (m_AttemperEngine.GetInterface() == NULL) return false;

    //发送控制
    m_AttemperEngine->OnEventControl(wControlID, pData, wDataSize);

    return true;
}

//控制消息
LRESULT CServiceUnits::OnUIControlRequest(WPARAM wParam, LPARAM lParam)
{
    //变量定义
    tagDataHead DataHead;
    BYTE cbBuffer[MAX_ASYNCHRONISM_DATA];

    //提取数据
    CWHDataLocker DataLocker(m_CriticalSection);
    if (m_DataQueue.DistillData(DataHead, cbBuffer, sizeof(cbBuffer)) == false)
    {
        ASSERT(FALSE);
        return NULL;
    }

    //数据处理
    switch (DataHead.wIdentifier)
    {
    case UI_LOAD_DB_LIST_RESULT: //列表结果
    {
                                     //效验消息
                                     ASSERT(DataHead.wDataSize == sizeof(CP_ControlResult));
                                     if (DataHead.wDataSize != sizeof(CP_ControlResult)) return 0;

                                     //变量定义
                                     CP_ControlResult * pControlResult = (CP_ControlResult *)cbBuffer;

                                     //失败处理
                                     if ((m_ServiceStatus != ServiceStatus_Service) && (pControlResult->cbSuccess == ER_FAILURE))
                                     {
                                         ConcludeService();
                                         return 0;
                                     }

                                     //成功处理
                                     if ((m_ServiceStatus != ServiceStatus_Service) && (pControlResult->cbSuccess == ER_SUCCESS))
                                     {
                                         //连接协调
                                         SendControlPacket(CT_CONNECT_CORRESPOND, NULL, 0);
                                     }

                                     return 0;
    }
    case UI_CORRESPOND_RESULT: //协调结果
    {
                                   //效验消息
                                   ASSERT(DataHead.wDataSize == sizeof(CP_ControlResult));
                                   if (DataHead.wDataSize != sizeof(CP_ControlResult)) return 0;

                                   //变量定义
                                   CP_ControlResult * pControlResult = (CP_ControlResult *)cbBuffer;

                                   //失败处理
                                   if ((m_ServiceStatus != ServiceStatus_Service) && (pControlResult->cbSuccess == ER_FAILURE))
                                   {
                                       ConcludeService();
                                       return 0;
                                   }

                                   //成功处理
                                   if ((m_ServiceStatus != ServiceStatus_Service) && (pControlResult->cbSuccess == ER_SUCCESS))
                                   {
                                       //启动网络
                                       if (StartNetworkService() == false)
                                       {
                                           ConcludeService();
                                           return 0;
                                       }

                                       //设置状态
                                       SetServiceStatus(ServiceStatus_Service);
                                   }

                                   return 0;
    }
    }

    return 0;
}

//////////////////////////////////////////////////////////////////////////////////