#ifndef GLOBALINFO_H
#define GLOBALINFO_H

#include <QString>
#include <vector>
#include "nlohmann/json.hpp"

/**
 * @brief 全局信息
 * 
 */

using nJson = nlohmann::json;


/* 算法相关信息 */
struct AlgorithmInfo
{
    int PKID;                   /* 主键ID */
    int ActionTaskID;           /* 算法任务ID */
    std::string ActionID;       /* 算法ID */
    std::string ActionName;     /* 算法名称 */
    

    AlgorithmInfo() = default;
    AlgorithmInfo(const AlgorithmInfo& other)
        : PKID(other.PKID), ActionID(other.ActionID), ActionName(other.ActionName), ActionTaskID(other.ActionTaskID) {}
    AlgorithmInfo& operator=(const AlgorithmInfo& other) {
        if (this != &other) {
            ActionID = other.ActionID;
            ActionName = other.ActionName;
            ActionTaskID = other.ActionTaskID;
            PKID = other.PKID;
        }
        return *this;
    }
    /* 对比是否相等 */
    bool operator==(const AlgorithmInfo& other) const {
        if(ActionID != other.ActionID)
        {
            return false;
        }
        if(ActionName != other.ActionName || ActionTaskID != other.ActionTaskID)
        {
            return false;
        }
        return true;
    }
};


/* 设备列表 */
struct DeviceInfo
{
    int PKID;                   /* 主键ID */
    int DeviceID;               /* 设备ID */
    int DevicePort;             /* 设备端口 */
    std::string DeviceName;     /* 设备名称 */
    std::string DeviceIP;       /* 设备IP */
    std::string DeviceSerial;   /* 设备序列号 */
    std::string DeviceType;     /* 设备类型 */
    std::string UserAccount;    /* 用户账号 */
    std::string UserPassword;   /* 用户密码 */
    std::vector<AlgorithmInfo> vecAlgorithmInfo; /* 算法信息 */

    DeviceInfo() = default;
    DeviceInfo(const DeviceInfo& other)
        : PKID(other.PKID), 
        DeviceID(other.DeviceID), 
        DevicePort(other.DevicePort), 
        DeviceName(other.DeviceName), 
        DeviceSerial(other.DeviceSerial), 
        DeviceType(other.DeviceType), 
        DeviceIP(other.DeviceIP),
        UserAccount(other.UserAccount), 
        UserPassword(other.UserPassword), 
        vecAlgorithmInfo(other.vecAlgorithmInfo) {}
    DeviceInfo& operator=(const DeviceInfo& other) {
        if (this != &other) {
            DeviceID = other.DeviceID;
            DevicePort = other.DevicePort;
            DeviceName = other.DeviceName;
            DeviceSerial = other.DeviceSerial;
            DeviceType = other.DeviceType;
            DeviceIP = other.DeviceIP;
            UserAccount = other.UserAccount;
            UserPassword = other.UserPassword;
            vecAlgorithmInfo = other.vecAlgorithmInfo;
        }
        return *this;
    }
    /* 对比是否相等 */
    bool operator==(const DeviceInfo& other) const {
        if(DeviceID != other.DeviceID) {
            return false;
        }
        else if(DeviceName != other.DeviceName || DeviceIP != other.DeviceIP) {
            return false;
        }
        else if(DeviceSerial != other.DeviceSerial || DeviceType != other.DeviceType) {
            return false;
        }
        else if(DevicePort != other.DevicePort || UserAccount != other.UserAccount || UserPassword != other.UserPassword) {
            return false;
        }

        return true;
    }
    /* 对比设备关联的算法信息是否相等 */
    bool isEqualAlgorithmInfo(const std::vector<AlgorithmInfo>& other) const {
        /* 算法数目不相等，直接返回false */
        if(vecAlgorithmInfo.size() != other.size()) {
            return false;
        }else {
            /* 算法数目相等，进一步对比算法信息 */
            bool isEquality = true;
            /* 逐步对比算法信息 */
            for(const auto& it0 : vecAlgorithmInfo) {
                bool isEq2 = true;
                for(const auto& it1 : other) {
                    if(it0 == it1) {
                        continue;
                    }else {
                        isEq2 = false;
                        break;
                    }
                }
                if(!isEq2) {
                    isEquality = false;
                    break;
                }
            }
            if(!isEquality) {
                return false;
            }
        }
        return true;
    }
};


/* 算法和设备关联的相关信息 */
struct DeviceAlgorithmInfo
{
    int DeviceID;               /* 设备ID */
    int ActionTaskID;           /* 算法任务ID */
    std::string ActionID;       /* 算法ID */
    std::string ActionName;     /* 算法名称 */
};



/**
 * @brief 摄像机线程需要的信息
 * 
 */
struct CameraThreadInfo
{
    std::string RedisIP;        /* Redis IP */
    int RedisPort;              /* Redis Port */
    std::string RedisPWD;       /* Redis Password */
    int DeviceID;               /* 设备ID */
    std::vector<std::string> vecAction;  /* Redis Key，一个设备可能会有多个算法ID */

    CameraThreadInfo() = default;
    CameraThreadInfo& operator=(const CameraThreadInfo& other) {
        if (this != &other) {
            RedisIP = other.RedisIP;
            RedisPort = other.RedisPort;
            RedisPWD = other.RedisPWD;
            DeviceID = other.DeviceID;
            vecAction = other.vecAction;
        }
        return *this;
    }
};

/**
 * @brief 人员信息
 * 
 */
struct PersonInfo
{
    std::string PersonID;       /* 人员ID */
    std::string PersonName;     /* 人员名称 */
};

/**
 * @brief 报警信息
 * 
 */
struct AlarmInfo
{
    bool Is_Alarm;              /* 是否报警 */
    int AlarmID;                /* 报警ID */
    int DeviceID;               /* 设备ID，数据库表格中对应的是CamerID */
    
    int RoomID;                 /* 房间ID */
    int ChannelID;              /* 通道ID */
    int OnWork;                 /* 是否在工作 */
    std::string ActionID;       /* 算法ID */
    std::string StartTime;      /* 报警开始时间 */
    std::string EndTime;        /* 报警结束时间 */
    std::string EventTime;      /* 事件时间（报警发生时间，在数据库里对应的是CreateTime） */
    std::string PicUrl;         /* 报警图片URL */
    std::string ImageInfo;      /* 图片信息 */
    std::string AppID;          /* 客户端应用ID */
    std::string ActionDes;      /* 算法描述信息 */
    std::string FaceIDList;     /* 人脸ID列表 */
    std::string FaceNameList;   /* 人脸名称列表 */
    std::string BboxList;       /* Bbox列表，应该图片中的报警位置 */
    std::vector<PersonInfo> vecPersonInfo;    /* 人员信息 */
};













#endif /* GLOBALINFO_H */