#include <qpixmap.h>
#include <opencv.hpp>
#include <qdebug.h>
#include <memory>
#include <string>
#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <filesystem>
#include <ctime>
#include <QDir>
#include <systemConfig.h>
#include <windows.h>
//#define DISPLAY_ICON_PATH ":/icon/icon/logo_Dongsheng.png" //DS
#define DISPLAY_ICON_PATH ":/icon/icon/jinyuan.png" //JY
static const std::string getExeDirectory();
#pragma execution_character_set("utf-8")
inline const std::string softwareVersion = "20260829-2.6.1";
const std::string euiJsonVersion = "1.0.6";//json标准版本
#define GigaByte 1073741824//1GB字节大小
static const std::string globalDatabasePth = getExeDirectory() + "/sqlDatabase/eui_db.db"; //全局数据库路径
#define savePathToDataBase true //是否将存储路径存入到数据库中
#define saveImgEnable true//是否存储图片
#define skipLogin 1 //是否跳过登录界面
#define ROOT_LOGIN_USE_OTP true //ROOT 使用 TOTP 动态码登录
#define jsonRpcEnable false //是否启用JSON RPC服务器
#define minimumWindowSize 1280, 720//最小窗口大小
#define histogramLabelTiltFontSize 8 //柱状图标签字体大小
#define windowMoveFreshRate 60//窗口移动每秒的刷新率
#define pathDataBaseSaveDays 180//存储存图路径的数据库其数据保留的日期
#define detDataBaseSaveDays 730//存储检测数据的数据库其数据保留的日期
#define logSaveDays 330 //日志储存的日期
#define offlineMode 0//启用离线测试模式 不连接PLC 不与PLC交互 不连接相机 不对重复启动进行检测
#define sColor_Blue "51, 56, 69"
#define sColor_BlueWithWhite "64, 68, 81"
#define sColor_BlueWithBlack "46, 50, 52"

#define sColor_Red "232, 17, 35"
#define sColor_RedWithWhite "241, 112, 122"

#define sColor_Green "17, 232, 35"
#define sColor_GreenWithWhite "112, 241, 122"

#define sColor_GoldWithBlack "200, 165, 100"
#define sColor_Gold "223, 185, 146"
#define sColor_GoldWithWhite "250, 222, 189"

#define sColor_Black "22, 22, 22"
#define sColor_BlackWithWhite "45, 45, 45"

struct showImgPack {
    cv::Mat img;
    QString name = "";
    QString type;
    showImgPack() {};
    showImgPack(QString name, QString type) : type(type), name(name) {}
};

enum initStatus {
    NotInit,
    InitFailure,
    InitOK
};

enum valueType {
    finsShort,
    finsFloat
};

// PLC 值查看器的配置结构体
struct PlcValueViewerStruct {
    QString valueName;
    int valueAddr;
    valueType type = finsShort;
    QVariant value = -999;
};
enum runCommandWidgetType {
    PlcSim,
    Direct,
    Setting
};
enum backendError
{
	dllNotFound,
	triggerInitFailure,
	triggerConnectionError,
	camerInitFailure
};

static QImage cvMatToQImage(const cv::Mat& src)
{
    if (src.channels() == 1) { // if grayscale image
        return QImage((uchar*)src.data, src.cols, src.rows, static_cast<int>(src.step), QImage::Format_Grayscale8).copy();
    }
    if (src.channels() == 3) { // if 3 channel color image
        cv::Mat rgbMat;
        cv::cvtColor(src, rgbMat, cv::COLOR_BGR2RGB); // invert BGR to RGB
        return QImage((uchar*)rgbMat.data, src.cols, src.rows, static_cast<int>(src.step), QImage::Format_RGB888).copy();
    }
    return QImage();
}
static cv::Mat qImageToCvMat(const QImage& inImage)
{
    switch (inImage.format())
    {
    case QImage::Format_RGB32:
    case QImage::Format_RGB888:
    {

        QImage   swapped = inImage;
        if (inImage.format() == QImage::Format_RGB32)
        {
            swapped = swapped.convertToFormat(QImage::Format_RGB888);
        }
        cv::Mat matImg = cv::Mat(swapped.height(), swapped.width(),
            CV_8UC3,
            const_cast<uchar*>(swapped.bits()),
            static_cast<size_t>(swapped.bytesPerLine())
        );
        cv::cvtColor(matImg, matImg, cv::COLOR_RGB2BGR);
        return matImg.clone();
    }
    case QImage::Format_Indexed8:
    {
        cv::Mat  mat(inImage.height(), inImage.width(),
            CV_8UC1,
            const_cast<uchar*>(inImage.bits()),
            static_cast<size_t>(inImage.bytesPerLine())
        );
        return mat.clone();
    }
    default:
        break;
    }
    return cv::Mat();
}
static void cvMatToQPixMap(const cv::Mat& src,QPixmap& pixmap)
{
    pixmap = QPixmap::fromImage(cvMatToQImage(src));
}
static QPixmap cvMatToQPixMap(const cv::Mat& src)
{
    return QPixmap::fromImage(cvMatToQImage(src));
}
static cv::Mat QPixmapToMat(const QPixmap& pixmap)
{
    // 将 QPixmap 转换为 QImage
    QImage img = pixmap.toImage();

    // 确保 QImage 是有效的
    if (img.isNull()) {
        return cv::Mat();
    }

    // 将 QImage 转换为 cv::Mat
    if (img.format() == QImage::Format_RGB888) {
        // 对于 RGB888 格式，直接转换为 cv::Mat
        return cv::Mat(img.height(), img.width(), CV_8UC3, (void*)img.bits(), img.bytesPerLine()).clone();
    }
    else if (img.format() == QImage::Format_RGBA8888) {
        // 如果是 RGBA 格式，转换为 CV_8UC4 格式
        return cv::Mat(img.height(), img.width(), CV_8UC4, (void*)img.bits(), img.bytesPerLine()).clone();
    }
    else {
        // 对于其他格式，转换为灰度图像
        QImage imgGray = img.convertToFormat(QImage::Format_Grayscale8);
        return cv::Mat(imgGray.height(), imgGray.width(), CV_8UC1, (void*)imgGray.bits(), imgGray.bytesPerLine()).clone();
    }
}
static std::string getCurrentDateTime() {

    // 获取当前时间点
    auto now = std::chrono::system_clock::now();

    // 转换为字符串
    auto currentTime = std::chrono::system_clock::to_time_t(now);
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 100;
    std::tm localTime{};
#if defined(_WIN32)
    if (localtime_s(&localTime, &currentTime) != 0) {
        return {};
    }
#else
    if (localtime_r(&currentTime, &localTime) == nullptr) {
        return {};
    }
#endif
    std::stringstream ss;
    ss << std::put_time(&localTime, "%H-%M-%S") << "-" << std::setfill('0') << std::setw(2) << ms.count();
    return ss.str();
}

static void createDirectoryIfNotExists(const std::string& path) {
    // 检查路径是否存在
    if (!std::filesystem::exists(path)) {
        // 创建路径
        try {
            std::filesystem::create_directories(path);
            //std::cout << "已创建文件夹: " << path << std::endl;
        }
        catch (...) {
            qCritical() << "创建文件夹失败!" << QString::fromStdString(path);
        }
    }
}
static void createDirectoryIfNotExists(const QString& path) {
        QDir dir;
        dir.mkpath(path);
}
static const std::string getExeDirectory() {
    char buffer[MAX_PATH];
    if (GetModuleFileNameA(nullptr, buffer, MAX_PATH) == 0) {
        return "";  // 失败时返回空字符串，不打印任何日志
    }
    std::filesystem::path exePath(buffer);
    return exePath.parent_path().string();
}
static std::wstring stdstringToWstring(const std::string& str) {
    int sizeNeeded = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), nullptr, 0);
    std::vector<wchar_t> wstr(sizeNeeded);
    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), wstr.data(), sizeNeeded);
    return std::wstring(wstr.begin(), wstr.end());
}
#define REGISTER_META_TYPE_LIST \
    qRegisterMetaType<cv::Mat*>("matPtr"); \
    qRegisterMetaType<std::string>("stdString"); \
    qRegisterMetaType<Qt::GlobalColor>("QtGlobalColor"); \
    qRegisterMetaType<showImgPack>("showImgPack"); \
    qRegisterMetaType<initStatus>("initStatus"); \
    qRegisterMetaType<cv::Mat>("mat"); \
    qRegisterMetaType<std::vector<cv::Mat>*>("vecmatptr"); \
    qRegisterMetaType<std::vector<std::string>>("vectorstring"); \
    qRegisterMetaType<std::vector<std::pair<QString, int>>>("constvpqi"); \
    qRegisterMetaType<PlcValueViewerStruct>("PlcValueViewerStruct"); \
    qRegisterMetaType<std::vector<std::pair<QString, QVariant>>>("vecQStringQVarint"); \
    qRegisterMetaType<std::vector<QString>>("vecQString");\
    qRegisterMetaType<runCommandWidgetType>("runCommandWidgetType");\
    qRegisterMetaType<std::shared_ptr<std::atomic<int>>>("shared_ptrAtomicInt");\
    qRegisterMetaType<std::shared_ptr<std::atomic<bool>>>("shared_ptrAtomicBool");\
    qRegisterMetaType<PlcValueViewerRows>("PlcValueViewerRows");\
    qRegisterMetaType<std::vector<std::pair<QString, QVariant>>*>("vecQStringQVarintPtr");



Q_DECLARE_METATYPE(cv::Mat*)
Q_DECLARE_METATYPE(cv::Mat)
Q_DECLARE_METATYPE(std::string)
Q_DECLARE_METATYPE(Qt::GlobalColor)
Q_DECLARE_METATYPE(std::shared_ptr<std::atomic<int>>)
Q_DECLARE_METATYPE(std::shared_ptr<std::atomic<bool>>)



#pragma once