#ifndef I_PERIPHERAL_MANAGER_H
#define I_PERIPHERAL_MANAGER_H
#include "VReturnCode.h"
#include "IHalCommon.h"
#include <iostream>
#include <memory>
#include <map>
enum class NetGeneration
{
    NET_2G = 0,
    NET_3G,
    NET_4G,
    END
};
enum class SimInitResult
{
    SIM_INIT_OK = 0,
    SIM_INIT_INSERTED,
    SIM_INIT_NOT_INSERTED,
    SIM_INIT_NOT_SUPPORT_MOBILE_NETWORK,
    SIM_INIT_END
};
enum class RegisterNetworkResult
{
    SUCCEED = 0,
    FAILED,
    ERROR_REG_NET,
    FAILED_NOT_SUPPORT,
    FAILED_NO_SIGNAL,
    END
};
enum class NetApnConfigResult
{
    SUCCEED = 0,
    FAILED,
    END
};
typedef enum sf_SIM_TYPE_E
{
    SF_SIM_MEGA = 0, // normal mega sim, use in abroad
    SF_SIM_MEGA_IOT, // special mega sim, only use in T110
    SF_SIM_OTHER,    // other sim
    SF_SIM_BUTT
} SF_SIM_TYPE_E;
class SimInitDataOut
{
public:
    SimInitDataOut()
    {
        mResult = SimInitResult::SIM_INIT_END;
        mType = SF_SIM_BUTT;
    }
    ~SimInitDataOut()
    {
    }
    SimInitResult mResult;
    std::string mIMEI;
    std::string mModuleSubVersion;
    std::string mIccid;
    SF_SIM_TYPE_E mType;
};
enum class SignalLevel
{
    LEVEL_0 = 0,
    LEVEL_1 = 2,
    LEVEL_2 = 3,
    LEVEL_3 = 4,
    END
};
class RegisterNetworkDataOut
{
public:
    RegisterNetworkDataOut()
    {
        result = RegisterNetworkResult::END;
        mGeneration = NetGeneration::END;
        mSimSignal = 0;
        mSignalLevel = SignalLevel::END;
    }
    ~RegisterNetworkDataOut()
    {
    }
    RegisterNetworkResult result;
    NetGeneration mGeneration;
    std::string mServiceProvider;
    unsigned char mSimSignal;
    SignalLevel mSignalLevel;
};
class NetApnConfigDataOut
{
public:
    NetApnConfigDataOut()
    {
        result = NetApnConfigResult::END;
    }
    ~NetApnConfigDataOut()
    {
    }
    NetApnConfigResult result;
};
enum class SfKeyAction
{
    SF_KEY_ACTION_SHORT_CLICK = 0,
    SF_KEY_ACTION_LONG_CLICK,
    SF_KEY_ACTION_HOLD_DOWN,
    SF_KEY_ACTION_HOLD_UP,
    SF_KEY_ACTION_GROUP,
    SF_KEY_ACTION_BUTT,
    SF_KEY_ACTION_END
};
// class KeysState
// {
// public:
//     KeysState()
//     {
//         mAction = SfKeyAction::SF_KEY_ACTION_END;
//         mHoldTimeMs = 0;
//     }
//     ~KeysState()
//     {
//     }
//     SfKeyAction mAction;
//     long int mHoldTimeMs;
// };
constexpr int TIME_MEANS_KEY_NOT_HOLD = 0;
class KeysState
{
public:
    KeysState(const SfKeyAction &action, const long int &holdTimeMs)
        : mAction(action), mHoldTimeMs(holdTimeMs)
    {
    }
    ~KeysState()
    {
    }
    const SfKeyAction mAction;
    const long int mHoldTimeMs;
};
class VKeyMonitor
{
public:
    VKeyMonitor() = default;
    virtual ~VKeyMonitor() = default;
    virtual RETURN_CODE KeyActionHappened(const SfKeyDefine &key, const SfKeyAction &event, const unsigned int holdTimeMs = 0) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
};
enum class GpioDevice
{
    PIR = 0,
    USB,
    END
};
enum class DeviceInput
{
    VALID = 0,
    INVALID,
    END
};
class VGpioMonitor
{
public:
    VGpioMonitor() = default;
    virtual ~VGpioMonitor() = default;
    virtual RETURN_CODE InputTransform(const GpioDevice &gpio, const DeviceInput &input) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
};
constexpr unsigned int LED_NOT_BLINK = 0;
constexpr unsigned int BLINKING_FAST_MS = 500;
constexpr unsigned int BLINKING_SLOW_MS = 1000;
constexpr long int KEEP_ALIVE_FOREVER = 0;
constexpr unsigned int DELETED_LED_STATE = -1;
constexpr unsigned int DO_NOT_KEEP_ALIVE = -2;
class VLedState
{
public:
    VLedState() = default;
    virtual ~VLedState() = default;
    virtual RETURN_CODE GetLedState(SfLedState &state) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual unsigned int GetKeepAliveTimeMs(void) { return KEEP_ALIVE_FOREVER; }
    virtual unsigned int GetBlinkTimeMs(void) { return LED_NOT_BLINK; }
};
using SimInitCallback = void (*)(const SimInitDataOut &);
using RegisterNetworkCallback = void (*)(const RegisterNetworkDataOut &);
using NetApnConfigCallback = void (*)(const NetApnConfigDataOut &);
class VNetworkHardwareHandle
{
public:
    VNetworkHardwareHandle() = default;
    virtual ~VNetworkHardwareHandle() = default;
    virtual RETURN_CODE Init(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE UnInit(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual bool IsModuleWorking(void) { return false; }
    virtual RETURN_CODE SimInit(SimInitCallback func) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE RegisterNetworkManual(RegisterNetworkCallback func) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE RegisterNetworkAuto(RegisterNetworkCallback func) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE NetApnConfig(NetApnConfigCallback func) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE KeepAliveForLive(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
};
class VRtcTime
{
public:
    VRtcTime() = default;
    virtual ~VRtcTime() = default;
    virtual int Set(const struct rtc_time &rtctm) { return -1; }
    virtual int Get(struct rtc_time &rtctm) { return -1; }
    virtual bool Check(const struct rtc_time &rtctm) { return false; }
    virtual int Reset(void) { return -1; }
};
typedef enum
{
    SF_SD_FORMAT_SUCUSS = 0,
    SF_SD_FORMAT_NO_CARD = 1,
    SF_SD_FORMAT_NOT_SUPPORT_FAT = 2,
    SF_SD_FORMAT_MAX = 3,
} SF_SD_FORMAT_RESULT_e;
typedef enum sfSD_STATUS_E
{
    SF_SD_UNPLUGED = 0x00,
    SD_MOUNT_FAILURE,
    SD_MOUNT_SUCCESS,
    SF_SD_FULL,
    SF_SD_ERROR,
    SF_SD_PLUGED,
    SF_SD_BUTT,
} SF_SD_STATUS_E;
typedef struct sf_STORE_ATTR_S
{
    unsigned int SDStatus;
    unsigned int SDFree;
    unsigned int SDTotalSize;
} SF_STORE_ATTR_S;
constexpr int SDLOOP_REMAIN_SPACE = 300; /*300MB*/
class VSDCardMonitor
{
public:
    VSDCardMonitor() = default;
    virtual ~VSDCardMonitor() = default;
    virtual void ReportSDCardStatus(const SF_SD_STATUS_E &status) {}
};
class VSDCardHandle
{
public:
    VSDCardHandle() = default;
    virtual ~VSDCardHandle() = default;
    virtual void GetInfo(SF_STORE_ATTR_S &pstoreattrs) {}
    virtual void RemoveFile(const char *path, const signed int &threshold) {}
    virtual void LoopRemove(const char *path) {}
    virtual void IsFull(signed int &Isfull) {}
    virtual SF_SD_STATUS_E GetStatus(void) { return SF_SD_BUTT; }
    virtual void SetStatus(SF_SD_STATUS_E enStatus) {}
    virtual void SetMonitor(const std::shared_ptr<VSDCardMonitor> &monitor) {}
    virtual RETURN_CODE Format(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE USBInsert(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
};
class IPeripheralManager
{
public:
    IPeripheralManager() = default;
    virtual ~IPeripheralManager() = default;
    static std::shared_ptr<IPeripheralManager> &GetInstance(std::shared_ptr<IPeripheralManager> *impl = nullptr);
    virtual RETURN_CODE Init(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE UnInit(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE SetKeyMonitor(std::shared_ptr<VKeyMonitor> monitor) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetAllKeysState(std::map<SfKeyDefine, KeysState> &state) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE SetGpioMonitor(std::shared_ptr<VGpioMonitor> monitor) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE SetLedState(const SfLedIndex &led, std::shared_ptr<VLedState> &state) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    // virtual RETURN_CODE LuckLed(const SfLedIndex &led, std::shared_ptr<VKeyMonitor> monitor) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    // virtual RETURN_CODE UnLuckLed(const SfLedIndex &led, std::shared_ptr<VKeyMonitor> monitor) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE SetLongClickPeriod(unsigned int period) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetNetworkModuleHandle(std::shared_ptr<VNetworkHardwareHandle> &module) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetRtcTimeHandle(std::shared_ptr<VRtcTime> &rtc) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetSDCardHandle(std::shared_ptr<VSDCardHandle> &sdCard) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
};
bool CreatePeripheralManager(void);
#endif // !I_PERIPHERAL_MANAGER_H