#pragma once

#define LOGICCLIENT_API 

#include <string>
#include <vector>
#include <iostream>
#include <chrono>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <cstdint>
#include <unistd.h>
#include <sys/syscall.h>
#include <pthread.h>
#include <uuid/uuid.h>

#include "MsgQueue.h"
#include "CcosFileHandle.h"
#include "LogicDevice.h"
#include "CcosThread.h"

using namespace std;

const int CLIENT_TIMOUT = 10000;

class LOGICCLIENT_API LogicClient : public Thread_Base
{
    void* m_ClientLock;
    ACTION_SYNC_MODE m_SyncMode;
    pthread_t m_OwnerThreadId;

    MsgQueue<ResDataObject>* m_pPacketWaitQue;
    MsgQueue<ResDataObject>* m_pPacketReceivedQue;
    MsgQueue<ResDataObject>* m_pPacketNotifyQue;

    bool InitClient(const char* pPath, int flags);

    bool DeQueuePacket_Internal(ResDataObject& Packet);
    void ClearQueue_Internal();

protected:
    virtual bool OnStartThread() override;
    virtual bool OnEndThread()  override;
    virtual bool Exec(void)  override;

    volatile bool m_ClosedFlag;

    std::shared_ptr<LinuxEvent> m_hDeviceCloseOK;
    std::shared_ptr<LinuxEvent> m_hDeviceOpenOK;
    std::shared_ptr<LinuxEvent> m_hReOpen;

    string m_strDevicePath;
    ccos_mqtt_connection* m_pMqttConn;
    ccos_mqtt_callback m_pPacketArrivedCallbackFunc;

    string m_strCurTransaction;
    unsigned long m_ReqIdx;
    string* m_pActionName;
    LogicDevice* pLogicDeivce;
    int m_FileFlags;
    string* m_pLastMsgInfo;
    string* m_pFilePath;

    string m_strClientName;
    string m_strDefaultTopic;

    bool m_bNeedNotify;
    string m_strWS;

    ResDataObject m_DeviceResource;
    CcosDevFileHandle* m_pFileHandle;
    CcosDevFileHandle* m_pEbusHandle;

    RET_STATUS ProcessClose(ResDataObject& packet);
    RET_STATUS ProcessOpenResponse(ResDataObject& packet);
    RET_STATUS ProcessResource(ResDataObject& packet);
    RET_STATUS ProcessActionResponse(ResDataObject& packet, ResDataObject& OutputParam);
    RET_STATUS UpdateDeviceResource(int cmdType, ResDataObject& packet);

public:
    std::shared_ptr<LinuxEvent> m_ResponseEvent;
    std::shared_ptr<LinuxEvent> m_NotifyEvent;

    LogicClient(string szClientName, string szTransaction, string szType = "", bool bNeedNotify = true);
    virtual ~LogicClient(void);

    string GetDefaultTopic() { return m_strDefaultTopic; }
    string GetWS() { return m_strWS; }

    CCOS_PACKET_ROUTE m_Router;
    bool SetRouter(CCOS_PACKET_ROUTE Route);

    using logic_client_open_callback = std::function<void(LogicClient*, const  char*, int)>;
    virtual int Open(const char* pPath, int flags, const char* pszWS = "", DWORD timeout = 9000, logic_client_open_callback = nullptr);
    int ReOpenDevice();
    virtual int Close();

    RET_STATUS CloseDevice();
    RET_STATUS OpenDevice(bool bAsync = false);

    bool GetFilePath(ResDataObject& path);
    bool HasAction(const char* pszAction);
    bool HasProperty(const char* pszProperty);
    bool GetProperty(const char* pszProperty, ResDataObject& resRet);

    bool Lock(DWORD timeout = 6000);
    void UnLock();

    RET_STATUS UpdateDeviceResource(DWORD timeout = 7000);
    bool IsClosed();
    std::shared_ptr<LinuxEvent> GetOpenOKHandle() {
        return m_hDeviceOpenOK;
    }
    bool IsThreadSafe();
    const char* GetLastErrorInfo();
    bool IsAllReqFinished();
    bool SetRequestSyncMode(ACTION_SYNC_MODE Sync);
    ACTION_SYNC_MODE GetRequestSyncMode();

    RET_STATUS GetDeviceType(GUID &DevType);
    RET_STATUS GetDeviceResource(ResDataObject* pDeviceResource);
    void PacketArrived(ResDataObject* pResponse);
    void SetPacketArrivedCallback(ccos_mqtt_callback func) { m_pPacketArrivedCallbackFunc = func; }

    void SetCurrentTransaction(string strTransaction) { m_strCurTransaction = strTransaction; }
    void SubScribeTopic(const char* pszTopic, bool bSubscribe = true);
    virtual int Action(const char* pActionName, ResDataObject& ReqParams, ResDataObject& ResParams, DWORD timeout = 11000, const char* pszDevicePath = nullptr);
    virtual int Action_Req(const char* pActionName, ResDataObject& ReqParams, DWORD timeout = 11010, const char* pszDevicePath = nullptr);
    virtual int Action_Res(const char* pActionName, ResDataObject& ResParams, DWORD timeout = 11020);
    virtual int Action_Trans(ResDataObject* pOrgReq, DWORD timeout = 11030);

    std::shared_ptr<LinuxEvent> GetResponseHandle();

    bool GetFileHandle(CcosDevFileHandle& Handle);
    std::shared_ptr<LinuxEvent> GetNotifyHandle();
    void CleanupQueue();
    bool IsDataArrived();
    virtual PACKET_CMD ReadCmd(ResDataObject& CmdObject);
    PACKET_CMD ReadNotify(ResDataObject& CmdObject);
    RET_STATUS SYSTEM_CALL WaitForState(const char* state, DWORD timeout = 11100);
    void SetEbusFileHandle(CcosDevFileHandle* pHandle) { m_pEbusHandle = pHandle; }
    CcosDevFileHandle* GetEbusFileHanle(void) { return m_pEbusHandle; }
    string GetClientName() { return m_strClientName; };

protected:
    logic_client_open_callback m_openCallbackFunc;
};