#include "deal.h"
#include "json/json.h"
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string>
#include "CheckUtil.hpp"
#include "LoadImage.hpp" // #include "LoadImage.h"
std::string ExtractFileNameWithoutExtension(const std::string &strImgPath)
{
    // 查找最后一个斜杠 '/' 或 '\' 的位置
    size_t lastSlashPos = strImgPath.find_last_of("/\\");

    // 如果没有找到斜杠，默认整个字符串是文件名
    std::string fileName = (lastSlashPos == std::string::npos)
                               ? strImgPath
                               : strImgPath.substr(lastSlashPos + 1);
    // 查找最后一个点 '.' 的位置
    size_t lastDotPos = fileName.find_last_of('.');
    // 如果没有找到点号，或者点号在第一个字符的位置，则返回完整文件名
    if (lastDotPos == std::string::npos || lastDotPos == 0)
    {
        return fileName;
    }

    // 返回去掉扩展名的部分
    return fileName.substr(0, lastDotPos);
}
std::string GetFileName(const std::string &strImgPath)
{
    // 查找最后一个斜杠 '/' 或 '\' 的位置
    size_t lastSlashPos = strImgPath.find_last_of("/\\");

    // 如果没有找到斜杠，默认整个字符串是文件名
    std::string fileName = (lastSlashPos == std::string::npos)
                               ? strImgPath
                               : strImgPath.substr(lastSlashPos + 1);
    // 查找最后一个点 '.' 的位置

    return fileName;
}

bool customSort(const AI_Det_Channel_ &a, const AI_Det_Channel_ &b)
{
    // 特定规则排序: "a" 排第一, "b" 排第二, "L" 排最后
    if (a.strChannel == "Up-Particle" && b.strChannel != "Up-Particle")
    {
        return true; // "a" 排在前面
    }
    if (a.strChannel != "Up-Particle" && b.strChannel == "Up-Particle")
    {
        return false;
    }

    if (a.strChannel == "Down-Particle" && b.strChannel != "Down-Particle" && b.strChannel != "Up-Particle")
    {
        return true; // "b" 排第二
    }
    if (a.strChannel != "Down-Particle" && b.strChannel == "Down-Particle")
    {
        return false;
    }

    if (a.strChannel == "L0" && b.strChannel != "L0" && b.strChannel != "Up-Particle" && b.strChannel != "Down-Particle")
    {
        return false; // "L" 排最后
    }
    if (a.strChannel != "L0" && b.strChannel == "L0")
    {
        return true;
    }

    // 对其他情况使用字典顺序排序
    return a.strChannel < b.strChannel;
}

// 定义图片读取函数
void readImage(const std::string &filename)
{
    cv::Mat image = cv::imread(filename);
    if (image.empty())
    {
        std::cerr << "Error: Unable to read image " << filename << std::endl;
        return;
    }

    // // 在这里可以添加对图像的处理操作
    // // 例如：显示图像、保存图像、进行其他处理等

    // // 示例：显示图像
    // cv::imshow(filename, image);
    // cv::waitKey(0);
    // cv::destroyWindow(filename);
}

int _sysmkdir_1(const std::string &dir)
{
    int ret = mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
    if (ret && errno == EEXIST)
    {
        // printf("dir[%s] already exist.\n", dir.c_str());
    }
    else if (ret)
    {
        printf("create dir[%s] error: %d %s\n", dir.c_str(), ret, strerror(errno));
        return -1;
    }
    else
    {
        printf("create dir[%s] success.\n", dir.c_str());
    }
    return 0;
}
std::string __getParentDir_1(const std::string &dir)
{
    std::string pdir = dir;
    if (pdir.length() < 1 || (pdir[0] != '/'))
    {
        return "";
    }
    while (pdir.length() > 1 && (pdir[pdir.length() - 1] == '/'))
        pdir = pdir.substr(0, pdir.length() - 1);

    pdir = pdir.substr(0, pdir.find_last_of('/'));
    return pdir;
}
int _sysmkdirs_1(const std::string &dir)
{
    int ret = 0;
    if (dir.empty())
        return -1;
    std::string pdir;
    if ((ret = _sysmkdir_1(dir)) == -1)
    {
        pdir = __getParentDir_1(dir);
        if ((ret = _sysmkdirs_1(pdir)) == 0)
        {
            ret = _sysmkdirs_1(dir);
        }
    }

    return ret;
}

long getcurTime()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return ((long)tv.tv_sec) * 1000 + ((long)tv.tv_usec) / 1000;
}
deal::deal()
{
    nLastCheckAnalysisyThreadIdx = 0;
    m_nCamIdx = 0;
    m_nCurUseCPUIDX = 0;
    m_DetResult.Init();
    for (int i = 0; i < READ_IMG_THREAD_NUM; i++)
    {
        m_nReadStausList[i] = ReadImg_Status_IDE;
    }
    m_nreadImg_Stop = false;
    m_strCurDate = "";
    m_nReadThread_type = READ_THREAD_TYPE_NULL;

    for (int i = 0; i < Status_Type_Count; i++)
    {
        m_DetStatusList[i] = Thread_Status_IDE;
    }
    m_nTestNum = 9999999;
    m_pALLImgCheckAnalysisy = NULL;

    // ✅ 新增：初始化产品检测线程池
    m_bProductReadExit = false;
    m_nProductReadThreadNum = READ_PRODUCT_THREAD_NUM;
    m_nProductQueueMaxSize = PRODUCT_QUEUE_MAX_SIZE;
    m_nCheckNotifiedCount = 0;
}

deal::~deal()
{
    // ✅ 新增：销毁产品检测线程池
    DestroyProductReadThreadPool();
}

int deal::start()
{

    std::string strdate = CheckUtil::getCurrentDate();
    printf("===== %s\n", strdate.c_str());
    int re = Init();
    // getchar();
    // 配置系统运行的cup核数。

    if (re != 0)
    {
        return 1;
    }
    // 解析图片，并保存
    if (Process_Run_SaveImg == runConfig.run_Type)
    {
        return 1;
    }
    else if (runConfig.run_Type == Process_Run_ReJson)
    {

        ReJson_ALL();
        return 0;
    }
    else
    {
        DetImg();
    }

    return 0;
}

int deal::Init()
{
    InitCPUIDX();
    // 读取系统配置文件
    int re = ReadSystemConfig(FILE_SYSTEM_RUN_CONFIG);
    if (re == false)
    {
        printf("ReadSystemConfig error\n");
        return 1;
    }
    // 加载 检测 的通道 图片名称
    std::string strchannlePath = m_system_param.config_Root_Path + "surface_list.json";
    m_image_ReadChannel.ReadJsonConfig(strchannlePath);
    // getchar();

    if (Process_Run_SaveImg == runConfig.run_Type)
    {
        return 0;
    }

    // getchar();
    // 初始化参数模块
    InitConfig();

    printf("\n\n\n\n\n\n\n\n\n\n\n**********************************************************LoadCheckImgConfig\n");
    // 载入参数
    re = LoadCheckImgConfig();
    if (re != 0)
    {
        printf("read config  error\n");
        return 2;
    }
    printf("\n\n**********************************************************InitCheckAnalysisy\n");

    // 初始化检测库
    InitCheckAnalysisy();
    printf("\n\n\n\n\n\n\n\n\n\n\n**********************************************************Check\n");
    return 0;
}

int deal::LoadCheckImgConfig()
{

    int re = LoadAnalysisConfig();
    if (re != 0)
    {
        return re;
    }
    return 0;
}

int deal::InitCheckAnalysisy()
{
    int re = 0;
    int m_nMAX_GPU_NUM = MAX_GPU_NUM;
    if (m_nMAX_GPU_NUM <= 0)
    {
        printf(">>>>error GPU error %d \n", m_nMAX_GPU_NUM);
        return 2;
    }
    int startidx = m_CPUInfo[THREAD_CPU_CheckSo].startIdx;
    int cpunum = m_CPUInfo[THREAD_CPU_CheckSo].num;
    m_RunConfig.nCpu_start_Idx = startidx;
    m_RunConfig.nCpu_num = cpunum;
    m_RunConfig.nWorkIdx = m_system_param.nWorkIdx;
    for (int i = 0; i < MAX_GPU_NUM; i++)
    {
        m_RunConfig.UseGPUList[i] = m_system_param.GPU_Device_ID_List[i];
        printf("gpu %d %d\n", i, m_RunConfig.UseGPUList[i]);
    }
    m_pALLImgCheckAnalysisy = ALLImgCheckBase::GetInstance();
    re = m_pALLImgCheckAnalysisy->UpdateConfig((void *)&m_RunConfig, CHECK_CONFIG_Run);
    re = m_pALLImgCheckAnalysisy->UpdateConfig((void *)m_pConfigManager, CHECK_CONFIG_Module);

    VERSION_INFO tm;
    tm.InterfaceVersion = ALL_INTERFACE_VERSION;
    tm.ConfigVersion = CONFIGBASE_VERSION;
    tm.ResultVersion = RESULT_VERSION;
    re = m_pALLImgCheckAnalysisy->RunStart(&tm);
    if (re != 0)
    {
        printf("RunStart Fail %d\n", re);
        return re;
    }

    printf(">>>> ImgCheckThread  Start Succ \n");
    return 0;
}

int deal::InitConfig()
{
    m_pConfigManager = ConfigManagerBase::GetInstance();

    return 0;
}

int deal::InitSaveImgPath()
{
    return 0;
}

int deal::LoadCheckConfig()
{

    return 0;
}
int deal::LoadAnalysisConfig()
{
    if (!m_pConfigManager)
    {
        return 1;
    }
    std::string folder = m_system_param.config_Root_Path;

    int re = m_pConfigManager->LoadAnalysisConfig(folder);

    for (const auto &pair : m_pConfigManager->Config_instances_)
    {
        std::cout << "cam: " << pair.first << std::endl;
    }
    // getchar();
    return re;
}
int deal::StartThread(THREAD_RUN_TYPE type)
{
    m_bExit = false;
    // 只读图线程
    if (type == THREAD_RUN_ALL)
    {

        // 开启检测线程
        ptr_DealImgthread = std::make_shared<std::thread>(&deal::DealImg, this);
        // 结果处理线程
        // ptr_Resultthread = std::make_shared<std::thread>(&deal::ResultThread, this);

        for (int i = 0; i < Save_IMG_THREAD_NUM; ++i)
        {
            // 创建线程，并使用 std::make_shared 创建 shared_ptr
            std::shared_ptr<std::thread> threadPtr = std::make_shared<std::thread>(&deal::ResultThread, this, i);
            // 将 shared_ptr 添加到 vector 中
            ptr_ResultthreadList.push_back(threadPtr);
        }

        // 结果拷贝线程
        ptr_GetResultthread = std::make_shared<std::thread>(&deal::GetResultThread, this);
    }

    InitProductReadThreadPool();

    // for (int i = 0; i < READ_IMG_THREAD_NUM; ++i)
    // {
    //     // 创建线程，并使用 std::make_shared 创建 shared_ptr
    //     std::shared_ptr<std::thread> threadPtr = std::make_shared<std::thread>(&deal::ReadImgThread, this, i);
    //     // 将 shared_ptr 添加到 vector 中
    //     threadArray.push_back(threadPtr);
    // }

    return 0;
}

int deal::StopThread()
{
    return 0;
}
int deal::preCheck()
{
    printf(">>> preCheck    start \n");

    std::string strRoot = "../data/img/t1";
    std::string strProductID = "";
    {

        READ_IMG_INFO read;
        readTestImg(read);
        strRoot = read.strpath;
        strProductID = read.strproduct;
        printf("strSearchImg strRoot %s\n", strRoot.c_str());

        std::ifstream file123(strRoot);
        bool bhave = file123.good();
        if (!bhave)
        {
            printf("read img path error %d %s\n", bhave, strRoot.c_str());
            return 1;
        }
    }

    // 获取图片路径
    std::string strSearchImg = strRoot;

    LoadImage loader;
    LoadConfig config;
    config.Init();

    printf("开始加载图片...\n\n");
    std::vector<LoadProductImages> products = loader.LoadALLImg(strSearchImg, config, &m_image_ReadChannel, strProductID);

    if (products.empty())
    {
        printf("未找到任何图片！\n");
        printf("错误信息：%s\n", loader.getLastError().c_str());
        return 1;
    }

    printf("加载完成!\n");
    printf("产品数量：%zu\n", products.size());
    printf("图片总数：%zu\n\n", loader.getTotalLoaded());
    for (size_t i = 0; i < products.size(); i++)
    {
        products[i].print("产品" + std::to_string(i + 1));
    }

    long t1 = getcurTime();

    for (size_t i = 0; i < products.size(); i++)
    {

        CheckProduct(products[i]); // 处理单个产品
        int getresultNum = 0;
        // getchar();
        while (true)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟消费过程
            // 处理结果

            std::shared_ptr<CheckResult> checkResult;
            int re = m_pALLImgCheckAnalysisy->GetCheckReuslt(checkResult);

            saveImg("/home/aidlux/BOE/FOG/testresult/", checkResult);
            getresultNum++;
            if (getresultNum == m_nProductSuccessCount)
            {

                break;
            }
        }
    }

    // }
    printf(">>> ALL preCheck    complete \n");
    return 0;
}

std::string deal::readTestImg()
{
    std::string strRoot = "../data/img/TestImg.json";
    printf("Reading Img config %s\n", strRoot.c_str());
    Json::CharReaderBuilder builder;
    builder["collectComments"] = true;
    Json::Value root;
    std::string err;
    std::ifstream ifs(strRoot);
    if (!ifs.is_open())
    {
        printf("error:file is open\n");
        return "";
    }
    if (!Json::parseFromStream(builder, ifs, &root, &err))
    {
        printf("error:parseFromStream\n");
        return "";
    }
    std::string imgpath = "";
    imgpath = root["TestImg_Path"].asString();

    return imgpath;
}

int deal::readTestImg(READ_IMG_INFO &read)
{
    std::string strRoot = "../data/img/TestImg.json";
    printf("Reading Img config %s\n", strRoot.c_str());
    Json::CharReaderBuilder builder;
    builder["collectComments"] = true;
    Json::Value root;
    std::string err;
    std::ifstream ifs(strRoot);
    if (!ifs.is_open())
    {
        printf("error:file is open\n");
        return 1;
    }
    if (!Json::parseFromStream(builder, ifs, &root, &err))
    {
        printf("error:parseFromStream\n");
        return 1;
    }
    std::string imgpath = "";
    read.strpath = root["TestImg_Path"].asString();
    read.strproduct = root["ProductID"].asString();
    return 0;
}

int deal::repeatCheck()
{

    return 0;
}

int deal::saveImg(std::string strpath, std::shared_ptr<CheckResult> result)
{
    std::string strroot = strpath;
    std::string strroot_qx = strpath;
    if (result->in_shareImage->imgstr != "")
    {
        strroot += result->in_shareImage->imgstr;
        strroot += "/";
        strroot_qx += result->in_shareImage->imgstr;
        strroot_qx += "/";
    }

    if (strpath != "")
    {

        strroot_qx += "qx/";

        if (result->nProductResult != 0)
        {
            strroot += "NG/";
        }
        else
        {
            strroot += "OK/";
        }

        if (result->in_shareImage->strImgProductID != "")
        {
            strroot += result->in_shareImage->strImgProductID + "/";
        }

        if (result->nresult != 0)
        {
            strroot += "NG/";
        }
        else
        {
            if (result->nYS_result != 0)
            {
                strroot += "OK/YS/";
            }
            else
            {
                strroot += "OK/OK/";
            }
        }
    }
    printf("result->nresult %d %d \n", result->nresult, result->nYS_result);
    printf("%s\n", strroot.c_str());
    _sysmkdirs_1(strroot);
    std::string str_saveName = "";
    // getchar();
    if (result->in_shareImage->strImgProductID != "")
    {
        strroot += result->in_shareImage->strImgProductID;
        str_saveName += result->in_shareImage->strImgProductID;
    }

    if (result->in_shareImage->strImgName != "")
    {
        strroot += "_" + result->in_shareImage->strImgName;
        str_saveName += "_" + result->in_shareImage->strImgName;
    }
    {
        strroot += "_" + result->in_shareImage->strCameraName;
        str_saveName += "_" + result->in_shareImage->strCameraName;
        strroot += "_" + result->in_shareImage->strChannel;
        str_saveName += "_" + result->in_shareImage->strChannel;
    }

    writeLog(strroot, result->det_LogList);
    WriteJsonString(strroot, result->strResultJson);
    // printf("%s \n", strroot.c_str());
    std::string str = strroot + "_RE_Resultimg.png";
    if (!result->resultimg.empty())
    {
        cv::imwrite(str, result->resultimg);
    }
    std::string str123 = strroot + "_RE_CutImg.png";
    if (!result->cutSrcimg.empty())
    {
        cv::imwrite(str123, result->cutSrcimg);
    }
    std::string str123r = strroot + "_RE_CutDrawImg.png";
    if (!result->SrcResultImg.empty())
    {
        cv::imwrite(str123r, result->SrcResultImg);
    }
    std::string strMask = strroot + "_RE_AIMask.png";

    if (!result->resultMaskImg.empty())
    {
        cv::imwrite(strMask, result->resultMaskImg);
    }
    std::string str_qx;
    printf("result->qxImageResult.size()  %ld \n", result->qxImageResult.size());
    for (int i = 0; i < result->qxImageResult.size(); i++)
    {
        std::string str = strroot + "_RE_" + std::to_string(i) + "_Src.png";

        if (!result->qxImageResult.at(i).srcImg.empty())
        {
            cv::imwrite(str, result->qxImageResult.at(i).srcImg);
        }

        str_qx = strroot_qx + result->qxImageResult.at(i).strTypeName + "/";
        printf("-1-- %s\n", str_qx.c_str());
        _sysmkdirs_1(str_qx);
        str_qx += str_saveName + "_RE_" + std::to_string(i) + "_Src.png";
        // printf("-2-- %s\n", str_qx.c_str());

        if (!result->qxImageResult.at(i).srcImg.empty())
        {
            cv::imwrite(str_qx, result->qxImageResult.at(i).srcImg);
        }
        str_qx = strroot_qx + result->qxImageResult.at(i).strTypeName + "/";
        str_qx += str_saveName + "_RE_" + std::to_string(i) + "_Small.png";

        if (!result->qxImageResult.at(i).resizeImg.empty())
        {
            cv::imwrite(str_qx, result->qxImageResult.at(i).resizeImg);
        }

        {
            str_qx = strroot_qx + result->qxImageResult.at(i).strTypeName + "/";
            str_qx += str_saveName + "_RE_" + std::to_string(i) + "_AI_In.png";
            if (!result->qxImageResult.at(i).AI_in_Img.empty())
            {
                cv::imwrite(str_qx, result->qxImageResult.at(i).AI_in_Img);
            }

            str_qx = strroot_qx + result->qxImageResult.at(i).strTypeName + "/";
            str_qx += str_saveName + "_RE_" + std::to_string(i) + "_AI_In_mask.png";
            if (!result->qxImageResult.at(i).AI_out_img.empty())
            {
                cv::imwrite(str_qx, result->qxImageResult.at(i).AI_out_img);
            }
        }

        // printf("-1111-- %s\n", str_qx.c_str());
        std::string str1 = strroot + "_RE_" + std::to_string(i) + "_Small.png";

        if (!result->qxImageResult.at(i).resizeImg.empty())
        {
            cv::imwrite(str1, result->qxImageResult.at(i).resizeImg);
        }
    }
    printf("result->YS_ImageResult.size() %ld\n", result->YS_ImageResult.size());
    for (int i = 0; i < result->YS_ImageResult.size(); i++)
    {
        std::string str = strroot + "_RE_" + std::to_string(i) + "_YS_Src.png";
        if (result->YS_ImageResult.at(i).srcImg.empty())
        {
            printf("resqwwwwwwwwwwwwwwwult->YS_ImageResult.size()  %ld \n", result->YS_ImageResult.size());
        }

        if (!result->YS_ImageResult.at(i).srcImg.empty())
        {
            cv::imwrite(str, result->YS_ImageResult.at(i).srcImg);
        }
        str_qx = strroot_qx + result->YS_ImageResult.at(i).strTypeName + "/";
        // printf("-3-- %s\n", str_qx.c_str());
        _sysmkdirs_1(str_qx);
        str_qx += str_saveName + "_RE_" + std::to_string(i) + "_YS_Src.png";
        // printf("-4-- %s\n", str_qx.c_str());

        if (!result->YS_ImageResult.at(i).srcImg.empty())
        {
            cv::imwrite(str_qx, result->YS_ImageResult.at(i).srcImg);
        }
        str_qx = strroot_qx + result->YS_ImageResult.at(i).strTypeName + "/";
        str_qx += str_saveName + "_RE_" + std::to_string(i) + "_YS_Small.png";

        if (!result->YS_ImageResult.at(i).resizeImg.empty())
        {
            cv::imwrite(str_qx, result->YS_ImageResult.at(i).resizeImg);
        }
        {
            str_qx = strroot_qx + result->YS_ImageResult.at(i).strTypeName + "/";
            str_qx += str_saveName + "_RE_" + std::to_string(i) + "_YS_AI_In.png";
            if (!result->YS_ImageResult.at(i).AI_in_Img.empty())
            {
                cv::imwrite(str_qx, result->YS_ImageResult.at(i).AI_in_Img);
            }

            str_qx = strroot_qx + result->YS_ImageResult.at(i).strTypeName + "/";
            str_qx += str_saveName + "_RE_" + std::to_string(i) + "_YS_AI_In_mask.png";
            if (!result->YS_ImageResult.at(i).AI_out_img.empty())
            {
                cv::imwrite(str_qx, result->YS_ImageResult.at(i).AI_out_img);
            }
        }
        // printf("-1111-- %s\n", str_qx.c_str());
        std::string str1 = strroot + "_RE_" + std::to_string(i) + "_YS_Small.png";

        if (!result->YS_ImageResult.at(i).resizeImg.empty())
        {
            cv::imwrite(str1, result->YS_ImageResult.at(i).resizeImg);
        }
    }
    return 0;
}

int deal::writeLog(std::string strSavePath, std::vector<std::string> logList)
{
    std::string str = strSavePath + ".txt";
    // 打开文件
    std::ofstream outFile(str);

    // 检查文件是否成功打开
    if (!outFile)
    {
        std::cerr << "Failed to open file." << std::endl;
        return 1;
    }

    // 将vector中的内容写入文件
    for (const auto &str : logList)
    {
        // printf("%s \n",str.c_str());
        outFile << str << std::endl;
    }

    // 关闭文件
    outFile.close();

    return 0;
}

int deal::WriteJsonString(std::string strSavePath, std::string strjson)
{

    std::string str = strSavePath + ".json";
    // 打开文件
    std::ofstream outFile(str);

    // 检查文件是否成功打开
    if (!outFile)
    {
        std::cerr << "Failed to open file." << std::endl;
        return 1;
    }

    // 将vector中的内容写入文件
    outFile << strjson << std::endl;

    // 关闭文件
    outFile.close();
    return 0;
}

void deal::ResultThread(int id)
{
    std::vector<int> vi;
    int startidx = m_CPUInfo[THREAD_CPU_Main_saveImg].startIdx;
    int cpunum = m_CPUInfo[THREAD_CPU_Main_saveImg].num;
    // for (int i = 0; i < cpunum; i++)
    // {
    //     vi.push_back(startidx + i);
    // }
    vi.push_back(startidx + id);
    auto nRet = set_cpu_id(vi);
    printf("THREAD_CPU_Main_saveImg %d bind cpu ret %d  startidx %d num %d\n", id, nRet, startidx + id, 1);

    int re = 0;
    cv::Mat detImg;
    int kkkkk = 0;
    static int saveidx = 0;
    while (!m_bExit)
    {
        std::shared_ptr<CheckResult> dealResult;
        mutex_Result_list.lock();
        if (m_Result_list.size() > 0)
        {
            dealResult = m_Result_list.front();
            m_Result_list.pop();
            if (m_Result_list.size() > 10)
            {
                printf("Result_list size %ld \n", m_Result_list.size());
            }

            mutex_Result_list.unlock();
        }
        else
        {
            mutex_Result_list.unlock();
            usleep(10000);
            continue;
        }

        {
            updataResltInfo(dealResult);
        }

        {
            if (true)
            {
                // 存图
                std::string savepath = "/home/aidlux/BOE/FOG/Detsave/";
                saveImg(savepath, dealResult);
                // saveImg("/home/aidlux/BOE/ResultImg/", dealResult);
            }

            {
                // 存 检测统计 日志
                mutex_DetResult_.lock();
                m_DetResult.print(false);
                std::string strlog = "/home/aidlux/BOE/FOG/ResultImg/";
                if (m_strCurDate != "")
                {
                    strlog += m_strCurDate;
                    strlog += "/result";
                }
                else
                {
                    strlog += "/result";
                }

                writeLog(strlog, m_DetResult.strlist);
                mutex_DetResult_.unlock();
            }
        }

        usleep(5 * 1000);
    }
}
int deal::set_cpu_id(const std::vector<int> &cpu_set_vec)
{
    // for cpu affinity
    int nRet = 0;
#ifdef __linux
    cpu_set_t _cur_cpu_set;
    CPU_ZERO(&_cur_cpu_set);
    for (auto _id : cpu_set_vec)
    {
        CPU_SET(_id, &_cur_cpu_set);
    }
    if (0 > pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &_cur_cpu_set))
    {
        perror("set cpu affinity failed: ");
        printf("Warning: set cpu affinity failed ... ...\n");
        nRet = -1;
    }
#endif //__linux
    return nRet;
}

void deal::GetDealResultToQueu()
{

    // 处理结果

    std::shared_ptr<CheckResult> checkResult;
    if (!m_pALLImgCheckAnalysisy)
    {
        return;
    }

    int re = m_pALLImgCheckAnalysisy->GetCheckReuslt(checkResult);

    if (re == 0)
    {
        mutex_Result_list.lock();
        m_Result_list.push(checkResult);
        mutex_Result_list.unlock();
    }
    else
    {
        printf("Check error >>>>>>>>>>>>>>>>> \n");
    }

    return;
}
bool deal::ReadSystemConfig(const std::string &strPath)
{

    printf("Reading system config %s\n", strPath.c_str());
    Json::CharReaderBuilder builder;
    builder["collectComments"] = true;
    Json::Value root;
    std::string err;
    std::ifstream ifs(strPath);
    if (!ifs.is_open())
    {
        printf("error:file is open\n");
        return false;
    }
    if (!Json::parseFromStream(builder, ifs, &root, &err))
    {
        printf("error:parseFromStream\n");
        return false;
    }
    m_system_param.Use_CPU_StartIdx = root["Use_CPU_StartIdx"].asInt();
    m_system_param.nWorkIdx = root["Detect_Work_Idx"].asInt();
    m_system_param.config_Root_Path = root["Config_Root_Path"].asString();

    for (int i = 0; i < 4; i++)
        m_system_param.GPU_Device_ID_List[i] = -1;
    if (root.isMember("GPU_Device_ID_List"))
    {
        auto &arr = root["GPU_Device_ID_List"];
        for (int i = 0; i < arr.size() && i < 4; i++)
        {
            m_system_param.GPU_Device_ID_List[i] = arr[i].asInt();
        }
    }

    m_nCurUseCPUIDX = m_system_param.Use_CPU_StartIdx;

    return m_system_param.valid();
}
int deal::GetJcImageInfo(std::string strpath, std::vector<JC_IMAGE_INFO_> &jcImageInfoList)
{
    LoadOfflineCheckImg(strpath);
    jcImageInfoList.erase(jcImageInfoList.begin(), jcImageInfoList.end());

    // 遍历每一套图片
    for (int idx = 0; idx < m_OffLineCheckImgNameList.size(); idx++)
    {
        std::string path = m_OffLineCheckImgNameList.at(idx);
        JC_IMAGE_INFO_ tem;
        int re = GetImgInfo_POL_ET(path, &tem);
    }
    // getchar();
    return 0;
}
int deal::GetDetImageInfo(std::string strProductID, std::string strSearchImg, std::vector<JC_IMAGE_INFO_> &jcImageInfoList)
{
    // 1、获取图片路径
    std::vector<cv::String> img_paths;
    std::string strs1 = strSearchImg + "/*.ytimage";
    cv::glob(strs1, img_paths, true);
    printf("%ld \n", img_paths.size());

    jcImageInfoList.erase(jcImageInfoList.begin(), jcImageInfoList.end());

    // 遍历每一套图片
    for (int idx = 0; idx < img_paths.size(); idx++)
    {
        // printf("---- %d /  %d         %s----\n", idx, m_OffLineCheckImgNameList.size(), m_OffLineCheckImgNameList.at(idx).c_str());

        std::string path = img_paths.at(idx);

        JC_IMAGE_INFO_ tem;
        int re = 0;
        {
            re = GetImgInfo_POL_ET(path, &tem);
            if (re != 0)
            {
                continue;
            }
        }
        tem.strProductID = strProductID;

        jcImageInfoList.push_back(tem);
    }

    return 0;
}
int deal::GetImgInfo_POL_ET(std::string strImgPath, JC_IMAGE_INFO_ *pImageInfo)
{

    if (pImageInfo == NULL)
    {
        return 1;
    }

    string strName = ExtractFileNameWithoutExtension(strImgPath);
    printf("strName  %s \n", strName.c_str());
    size_t lastUnderscore = strName.rfind('_');
    if (lastUnderscore == std::string::npos)
        return 1; // 没有找到最后一个 '_'

    std::string strImageChannel = strName.substr(0, lastUnderscore);

    printf("strImageChannel %s\n", strImageChannel.c_str());

    if (strImageChannel == "CA" || strImageChannel == "TA")
    {
    }
    else
    {
        return 1;
    }

    pImageInfo->strchannelName = strImageChannel;
    pImageInfo->strName = strName;
    pImageInfo->strPath = strImgPath;
    pImageInfo->strCamID = "0";
    printf("strImgPath  %s strName %s strChannel %s\n", strImgPath.c_str(), strName.c_str(), strImageChannel.c_str());

    // 使用 find 函数检查是否包含 "_左"

    return 0;
}
int deal::GetImgInfo_POL_ET_PNG(std::string strImgPath, JC_IMAGE_INFO_ *pImageInfo)
{

    if (pImageInfo == NULL)
    {
        return 1;
    }

    string strImageChannel = ExtractFileNameWithoutExtension(strImgPath);
    printf("strImageChannel %s\n", strImageChannel.c_str());
    std::string strChannle = m_image_ReadChannel.strDetName(strImageChannel);
    if (strChannle == "")
    {
        return 1;
    }

    pImageInfo->strchannelName = strChannle;
    pImageInfo->strName = strChannle;
    pImageInfo->strPath = strImgPath;
    pImageInfo->strCamID = "0";
    // printf("strImgPath  %s strChannel %s\n", strImgPath.c_str(), strChannle.c_str());

    // 使用 find 函数检查是否包含 "_左"
    if (strImgPath.find("_工位右") != std::string::npos)
    {
        pImageInfo->strCamID = "1";
        ;
    }
    return 0;
}
int deal::ReadTestImgaData()
{
    std::string strPath = "../data/testImg.json";
    printf("ReadTestImgaData config %s\n", strPath.c_str());
    Json::CharReaderBuilder builder;
    builder["collectComments"] = true;
    Json::Value root;
    std::string err;
    std::ifstream ifs(strPath);
    if (!ifs.is_open())
    {
        printf("error:file is open\n");
        return false;
    }
    if (!Json::parseFromStream(builder, ifs, &root, &err))
    {
        printf("error:parseFromStream\n");
        return false;
    }
    m_TestJC_ImageDate.erase(m_TestJC_ImageDate.begin(), m_TestJC_ImageDate.end());
    {
        auto value = root["img_date"];
        if (value.isObject())
        {
            auto arr = value["date"];
            std::cout << arr << std::endl;
            if (arr.isArray())
            {

                // 遍历数组中的每个元素
                for (int i = 0; i < arr.size(); i++)
                {

                    // 读取对象中的属性值
                    std::string strdata = arr[i].asString();
                    m_TestJC_ImageDate.push_back(strdata);

                    // 输出属性值
                    std::cout << "date: " << strdata << std::endl;
                }
            }
        }
    }
    // getchar();
    return 0;
}
int deal::InitDetData()
{
    m_read_ImgNum = 0;
    return 0;
}
int deal::InsertDetResult(ReadImgInfo tem)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_DetResult]);
    m_DetResultList.push_back(tem);

    return 0;
}
int deal::GetUpMaskImg(cv::Mat inImg, cv::Rect roi, cv::Mat &maskimg)
{
    // 定义滑动窗口的大小和步长
    int windowWidth = 128;
    int windowHeight = 128;
    int stepX = 110; // 横向步长
    int stepY = 110; // 纵向步长

    maskimg = cv::Mat(roi.height, roi.width, CV_8U, cv::Scalar(0));
    int sx = roi.x;
    int ex = roi.x + roi.width;
    int sy = roi.y;
    int ey = roi.y + roi.height;

    cv::Rect detroi;
    detroi.width = windowWidth;
    detroi.height = windowHeight;
    cv::Rect maskroi;
    maskroi.width = windowWidth;
    maskroi.height = windowHeight;
    cv::Mat temmask;
    // 遍历图像，使用滑动窗口
    for (int y = sy; y <= ey; y += stepY)
    {
        detroi.y = y;
        if (detroi.y + windowHeight > ey)
        {
            detroi.y = ey - windowHeight;
        }
        maskroi.y = detroi.y - sy;

        for (int x = sx; x <= ex; x += stepX)
        {
            detroi.x = x;
            if (detroi.x + windowWidth > ex)
            {
                detroi.x = ex - windowWidth;
            }
            maskroi.x = detroi.x - sx;
            int thresholdValue = 30; // 初始阈值，OTSU将自动计算
            int maxVal = 255;        // 最大值
            double otsuThreshold;

            cv::Scalar mean, stddev;
            cv::meanStdDev(inImg(detroi), mean, stddev);

            int varianceImg;
            varianceImg = mean[0] + 1 * mean[0];
            if (mean[0] > 100)
            {
                continue;
            }

            // 使用 OTSU 阈值处理
            otsuThreshold = cv::threshold(inImg(detroi), temmask, thresholdValue, maxVal, cv::THRESH_BINARY | cv::THRESH_OTSU);
            thresholdValue = otsuThreshold;

            if (thresholdValue < 30)
            {
                thresholdValue = 30;
            }
            if (thresholdValue < varianceImg)
            {
                thresholdValue = varianceImg;
            }

            if (thresholdValue > 100)
            {
                continue;
            }
            //  std::cout << "varianceImg value is: " << varianceImg << std::endl;
            // std::cout << "OTSU threshold value is: " << otsuThreshold << std::endl;
            // std::cout << "stddev[0] value is: " << stddev[0] << std::endl;
            otsuThreshold = cv::threshold(inImg(detroi), maskimg(maskroi), thresholdValue, maxVal, cv::THRESH_BINARY);
            // cv::threshold(inImg(detroi), maskimg(maskroi), thresholdValue, maxVal, cv::THRESH_BINARY + cv::THRESH_OTSU);
            // 提取当前窗口

            // cv::rectangle(inImg, detroi, cv::Scalar(255, 0, 0));
        }
    }
    // cv::imwrite("inImg1123.png", inImg);
    // cv::imwrite("maskimg.png", maskimg);
    // getchar();
    return 0;
}
int deal::ReJson()
{
    return 0;
}
int deal::ReJson_ALL()
{
    printf(">>> ReJson ALL     start \n");

    // 1、获取所有的json
    std::vector<cv::String> img_paths;
    cv::glob(runConfig.filePath + "/*.json", img_paths, true);
    if (img_paths.size() <= 0)
    {
        printf("json file is NULL \n");
        return 1;
        /* code */
    }
    // 用map存储每个id对应的vector
    std::unordered_map<std::string, std::vector<cv::String>> ProductJsonList;
    // 遍历路径并按照ID分组
    for (const auto &path : img_paths)
    {
        // 获取路径中的 ID 部分（即文件夹名部分）
        size_t start_pos = path.find_last_of("/") + 1;
        size_t end_pos = path.find("_", start_pos);
        std::string id = path.substr(start_pos, end_pos - start_pos);
        // printf("id %s\n",id.c_str());
        // 将文件路径加入对应 ID 的vector中
        ProductJsonList[id].push_back(path);
    }
    for (const auto &product : ProductJsonList)
    {
        std::cout << product.first << " => " << product.second.size() << std::endl;
        std::vector<Json_Det_Path> jsonList;
        std::string strProductName = product.first;
        for (const auto &str : product.second)
        {
            {
                // 2、获取第一个 名称
                std::string strPath = str;
                size_t lastSlashPos = strPath.find_last_of('/');
                // 提取文件名（从最后一个斜杠之后的部分）
                std::string filename = strPath.substr(lastSlashPos + 1);
                // 查找文件名中的第一个下划线位置
                size_t firstUnderscorePos = filename.find('_');
                // 提取文件名中的名称部分（下划线之前的字符串）
                std::string strProduct = filename.substr(0, firstUnderscorePos);
                // printf("strProduct %s \n", strProduct.c_str());
                if (strProduct == strProductName)
                {
                    Json_Det_Path tem;
                    tem.strPath_Json = str;
                    tem.strPath_CutImg = str;
                    size_t pos = tem.strPath_CutImg.rfind(".json");

                    if (pos != std::string::npos)
                    {
                        // 替换 ".json" 为 "_RE_CutImg.png"
                        tem.strPath_CutImg.replace(pos, 5, "_RE_CutImg.png");
                    }
                    std::cout << " Path: " << tem.strPath_Json << std::endl;
                    std::cout << " Path: " << tem.strPath_CutImg << std::endl;
                    jsonList.push_back(tem);
                }
            }
        }

        ReJson_product(jsonList, strProductName);
    }

    // 获取要检测的  json 图片 list

    printf(">>>>>>>>>>>>>>>>>>>> rejson ALL  is Complete \n");
    return 0;
}
int deal::DetImg()
{
    // 单张检测
    if (runConfig.det_Type == RUNTYPE_RUN_Pre)
    {
        m_nReadThread_type = READ_THREAD_TYPE_READIMG;
        StartThread(THREAD_RUN_Only_ReadImg);
        preCheck();
        return 0;
    }

    m_nReadThread_type = READ_THREAD_TYPE_READIMG;
    m_nSystemCheckType = CHECK_TYPE_OFFLING;

    StartThread(THREAD_RUN_ALL);
    // 文件夹套图处理
    if (RUNTYPE_RUN_File == runConfig.det_Type ||
        runConfig.det_Type == RUNTYPE_RUN_File_AI_TEST ||
        runConfig.det_Type == RUNTYPE_RUN_File_Edge_Test_Save_Qx ||
        runConfig.det_Type == RUNTYPE_RUN_File_Edge_Test_Save_ALL)
    {
        CheckFileImg(); // 检查文件图片
    }
    // getchar();

    return 0;
}

/// @brief 检查文件图片
/// @detail 后续实现具体功能
/// @return 0 表示成功
int deal::CheckFileImg()
{
    std::string root_dir = runConfig.filePath;
    printf("测试目录：%s\n\n", root_dir.c_str());

    LoadImage loader;
    LoadConfig config;
    config.Init();
    config.max_products = runConfig.m_nTestNum;
    if (config.max_products <= 0)
    {
        config.max_products = 9999999;
    }

    printf("开始加载图片...\n\n");
    std::vector<LoadProductImages> products = loader.LoadALLImg(root_dir, config, &m_image_ReadChannel);

    if (products.empty())
    {
        printf("未找到任何图片！\n");
        printf("错误信息：%s\n", loader.getLastError().c_str());
        return 1;
    }

    printf("加载完成!\n");
    printf("产品数量：%zu\n", products.size());
    printf("图片总数：%zu\n\n", loader.getTotalLoaded());
    for (size_t i = 0; i < products.size(); i++)
    {
        products[i].print("产品" + std::to_string(i + 1));
    }
    // getchar();
    for (size_t i = 0; i < products.size(); i++)
    {

        CheckProduct(products[i]); // 处理单个产品
    }
    printf("\n");

    // TODO: 后续实现具体功能
    // getchar();
    return 0;
}

/// @brief 检查单个产品
/// @param product 产品信息（包含图片对列表）
/// @return 0 表示成功
int deal::CheckProduct(const LoadProductImages &product)
{
    // 1. 统计图片对总数
    size_t totalImgNum = product.images.size();

    if (runConfig.det_Type == RUNTYPE_RUN_File_AI_TEST)
    {
        totalImgNum = 0;
        for (const auto &image : product.images)
        {
            if (image.channel_name == "L255")
            {
                totalImgNum++;
            }
        }
    }

    if (totalImgNum == 0)
    {
        printf("[产品] %s 没有图片对\n", product.product_id.c_str());
        return 0;
    }

    // 2. 重置计数器（重要！每个产品独立计数）
    m_nProductPendingTasks = 0;
    m_nProductSuccessCount = 0;
    m_nProductFailCount = 0;
    m_ProductFailedList.clear();
    m_nCheckNotifiedCount = 0;

    // 3. 打印产品信息
    printf("\n");
    printf("╔══════════════════════════════════════════════════════════\n");
    printf("║ 产品：%s\n", product.product_id.c_str());
    printf("║ 图片对数：%zu\n", totalImgNum);
    printf("╚══════════════════════════════════════════════════════════\n\n");

    // 4. 分发读图任务
    printf("[任务分发] 开始向读图线程分发 %zu 个任务...\n", totalImgNum);
    DistributeProductTasks(product);
    printf("[任务分发] 完成\n\n");

    // 5. 使用条件变量等待并处理通知队列
    int processed = 0;
    {
        IN_IMG_Status_ temstatus = IN_IMG_Status_Start;
        std::unique_lock<std::mutex> lock(m_checkNotifyMutex);

        while (processed < (int)totalImgNum)
        {
            // 等待通知：队列非空 或 所有任务已完成
            m_checkNotifyCV.wait_for(lock, std::chrono::milliseconds(100),
                                     [this, &processed, totalImgNum]()
                                     {
                                         return !m_checkNotifyQueue.empty() || m_nCheckNotifiedCount.load() >= (int)totalImgNum;
                                     });

            // 消费队列中的所有通知
            while (!m_checkNotifyQueue.empty())
            {
                auto info = m_checkNotifyQueue.front();
                m_checkNotifyQueue.pop();

                // 处理图片对
                SendCheckImg(info, temstatus, false);
                processed++;

                if (IN_IMG_Status_Start == temstatus)
                {
                    temstatus = IN_IMG_Status_Other;
                }
            }
        }
        // 注：不需要第二个 while 清理，因为第一个 while 退出时 processed == totalImgNum
        // 队列中不可能还有未处理的项目（内层 while 已经消费完）
    }
    CheckImgNotifyInfo info;
    info.productId = product.product_id;
    SendCheckImg(info, IN_IMG_Status_End, true);
    printf("\n");

    // 6. 打印统计（不清理线程，继续下一个产品）
    PrintProductStatistics(product);
    //  getchar();
    return 0;
}

int deal::SendCheckImg(const CheckImgNotifyInfo &info, IN_IMG_Status_ status, bool bComplete)
{

    // 发送结束标志
    if (bComplete)
    {
        std::shared_ptr<shareImage> tem = std::make_shared<shareImage>();
        tem->strImgProductID = info.productId;
        tem->Status = -1;
        if (m_pALLImgCheckAnalysisy)
        {
            m_pALLImgCheckAnalysisy->SetDataRun_SharePtr(tem);
        }
        return 0;
    }

    // 图片读取有异常，处理失败的图片对
    if (!info.success)
    {
        // 记录失败
        FailedImgRecord record;
        record.left_path = info.left_path;
        record.right_path = info.right_path;
        record.productId = info.productId;
        record.channelName = info.channelName;
        record.errorReason = info.errorReason;
        RecordFailedImg(record);

        m_nProductFailCount.fetch_add(1);

        printf("[失败-%3d] %s | %s | %s\n",
               info.taskIndex,
               info.productId.c_str(),
               info.channelName.c_str(),
               info.errorReason.c_str());
        return -1;
    }

    // printf("[%3d] %s | %d | %s | %s | %s | 左：%dx%d 右：%dx%d | 耗时：%ldms\n",
    //        info.taskIndex,
    //        info.productId.c_str(),
    //        info.camera_Num,
    //        info.cameraSide.c_str(),
    //        info.channelName.c_str(),
    //        info.imageName.c_str(),
    //        info.left_img.cols, info.left_img.rows,
    //        info.right_img.cols, info.right_img.rows,
    //        info.readTimeMs);

    m_nProductSuccessCount.fetch_add(1);

    std::shared_ptr<shareImage> tem = std::make_shared<shareImage>();

    tem->strChannel = info.channelName;

    // cv::imwrite(tem->strChannel + "_new_debug.png", info.left_img);
    // return 0;
    // cv::imwrite(tem->strChannel+".png",pDetImageInfo->img);
    tem->nImgBigIdx = 0;
    tem->strImgName = info.imageName;
    tem->strImgProductID = info.productId;
    tem->imgstr = m_strCurDate;

    if (runConfig.bDebugSaveImg == 1)
    {
        tem->otherValue = 9;
    }
    tem->getImgTimeMs = getcurTime();
    tem->Status = status;
    tem->Det_Mode = DET_MODE_Det;
    if (runConfig.det_Type == RUNTYPE_RUN_File_AI_TEST)
    {
        tem->Det_Mode = DET_MODE_EDGE;
    }
    if (runConfig.det_Type == RUNTYPE_RUN_File_Edge_Test_Save_Qx || runConfig.det_Type == RUNTYPE_RUN_File_Edge_Test_Save_ALL)
    {
        tem->ninstruct = 767;
        if (runConfig.det_Type == RUNTYPE_RUN_File_Edge_Test_Save_ALL)
        {
            tem->ninstruct = 768;
        }
    }


    {
        if (!info.left_img.empty())
        {
            tem->img = info.left_img;
        }
        else if (!info.right_img.empty())
        {
            tem->img = info.right_img;
        }
    }

    tem->strCameraName = info.cameraSide;
    tem->camera_ID = 0;

    if (runConfig.bDebugSaveImg == 1)
    {
        tem->bDebugsaveImg = true;
    }

    int re = 0;
    if (m_pALLImgCheckAnalysisy)
    {
        bool bcontinue = false;
        do
        {
            re = m_pALLImgCheckAnalysisy->SetDataRun_SharePtr(tem);
            if (re == 8)
            {
                bcontinue = true;
                std::this_thread::sleep_for(std::chrono::milliseconds(500));
            }
            else
            {
                bcontinue = false;
            }

        } while (bcontinue);
    }

    return re;
}

// ============ 产品检测线程池相关函数 ============

void deal::InitProductReadThreadPool()
{
    printf("[线程池] 初始化产品检测线程池...\n");

    // 创建 8 个读图线程
    for (int i = 0; i < m_nProductReadThreadNum; i++)
    {
        auto thread = std::make_shared<std::thread>(
            &deal::ProductReadImgThreadFunc, this, i);
        m_productReadThreads.push_back(thread);
    }

    printf("[线程池] 创建完成 (%d 读图线程)\n", m_nProductReadThreadNum);
}

void deal::DestroyProductReadThreadPool()
{
    printf("[线程池] 销毁产品检测线程池...\n");

    // 通知所有线程退出
    m_bProductReadExit = true;
    m_productTaskCV.notify_all();
    m_checkNotifyCV.notify_all();

    // 等待读图线程结束
    for (auto &thread : m_productReadThreads)
    {
        if (thread && thread->joinable())
        {
            thread->join();
        }
    }

    m_productReadThreads.clear();

    printf("[线程池] 销毁完成\n");
}

void deal::DistributeProductTasks(const LoadProductImages &product)
{
    int taskIndex = 0;

    for (const auto &image : product.images)
    {
        if (runConfig.det_Type == RUNTYPE_RUN_File_AI_TEST)
        {
            if (image.channel_name != "L255")
            {
                continue;
            }
        }

        auto task = std::make_shared<ReadImgTask>();
        task->productId = product.product_id;
        task->channelName = image.channel_name;
        task->imageName = image.image_name; // 图片名称
        task->left_path = image.left_path;
        task->right_path = image.right_path;
        task->camera_Num = product.camera_Num;
        task->cameraSide = image.camera_side;
        task->taskIndex = taskIndex++;

        // 如果队列满了，等待
        {
            std::unique_lock<std::mutex> lock(m_productTaskMutex);

            m_productTaskCV.wait(lock, [this]()
                                 { return m_productTaskQueue.size() < (size_t)m_nProductQueueMaxSize || m_bProductReadExit; });

            if (m_bProductReadExit)
            {
                break;
            }

            m_productTaskQueue.push(task);
            m_nProductPendingTasks.fetch_add(1);
        }
        m_productTaskCV.notify_one();
    }
}

std::shared_ptr<ReadImgTask> deal::GetProductTask()
{
    std::shared_ptr<ReadImgTask> task;

    std::unique_lock<std::mutex> lock(m_productTaskMutex);
    if (m_productTaskCV.wait_for(lock, std::chrono::milliseconds(10),
                                 [this]()
                                 { return !m_productTaskQueue.empty() || m_bProductReadExit; }))
    {

        if (m_productTaskQueue.empty())
        {
            return nullptr;
        }

        task = m_productTaskQueue.front();
        m_productTaskQueue.pop();
    }

    return task;
}

void deal::ProductReadImgThreadFunc(int threadId)
{
    while (!m_bProductReadExit)
    {
        auto task = GetProductTask();
        if (task == nullptr)
        {
            continue;
        }

        CheckImgNotifyInfo info;
        info.taskIndex = task->taskIndex;
        info.productId = task->productId;
        info.channelName = task->channelName;
        info.imageName = task->imageName;
        info.left_path = task->left_path;
        info.right_path = task->right_path;
        info.cameraSide = task->cameraSide; // 复制相机方位
        info.camera_Num = task->camera_Num;

        try
        {
            // 读取左图
            long startTime = getcurTime();
            cv::Mat left_img;
            cv::Mat img16 = cv::imread(task->left_path, cv::IMREAD_UNCHANGED);

            if (!img16.empty())
            {

                if (img16.type() != CV_8U)
                {
                    // printf("=========== 1 %s\n", info.channelName.c_str());
                    cv::Mat img8;
                    cv::normalize(img16, img8, 0, 255, cv::NORM_MINMAX);
                    img8.convertTo(img8, CV_8U);
                    left_img = img8;
                }
                else if (img16.type() == CV_8U)
                {
                    // printf("=========== 2%s\n", info.channelName.c_str());
                    left_img = img16;
                }
            }
            // cv::imwrite(info.channelName+"_ddddd.png", left_img);
            // getchar();

            // 读取右图
            cv::Mat right_img;
            img16 = cv::imread(task->right_path, cv::IMREAD_UNCHANGED);

            if (!img16.empty())
            {

                if (img16.type() != CV_8U)
                {
                    // printf("=========== 1 %s\n", info.channelName.c_str());
                    cv::Mat img8;
                    cv::normalize(img16, img8, 0, 255, cv::NORM_MINMAX);
                    img8.convertTo(img8, CV_8U);
                    right_img = img8;
                }
                else if (img16.type() == CV_8U)
                {
                    // printf("=========== 2%s\n", info.channelName.c_str());
                    right_img = img16;
                }
            }

            long endTime = getcurTime();

            info.width = left_img.cols;
            info.height = left_img.rows;
            info.readTimeMs = endTime - startTime;
            info.left_img = left_img;
            info.right_img = right_img;

            // 检查是否成功读取
            info.success = !left_img.empty() || !right_img.empty();

            if (!info.success)
            {
                // 记录失败原因
                if (left_img.empty() && right_img.empty())
                {
                    info.errorReason = "左右图都读取失败";
                }
                else if (left_img.empty())
                {
                    info.errorReason = "左图读取失败：" + task->left_path;
                }
                else
                {
                    info.errorReason = "右图读取失败：" + task->right_path;
                }

                printf("[读图错误-%3d] %s\n", task->taskIndex, info.errorReason.c_str());
            }
        }
        catch (const cv::Exception &e)
        {
            // OpenCV 异常处理
            info.success = false;
            info.errorReason = std::string("OpenCV 异常：") + e.what();
            info.width = 0;
            info.height = 0;
            info.readTimeMs = 0;

            printf("[读图异常-%3d] %s\n", task->taskIndex, e.what());
        }
        catch (const std::exception &e)
        {
            // 标准异常处理
            info.success = false;
            info.errorReason = std::string("异常：") + e.what();
            info.width = 0;
            info.height = 0;
            info.readTimeMs = 0;

            printf("[读图异常-%3d] %s\n", task->taskIndex, e.what());
        }
        catch (...)
        {
            // 未知异常处理
            info.success = false;
            info.errorReason = "未知异常";
            info.width = 0;
            info.height = 0;
            info.readTimeMs = 0;

            printf("[读图未知异常-%3d]\n", task->taskIndex);
        }

        // 推送到通知队列并通知主线程
        {
            std::lock_guard<std::mutex> lock(m_checkNotifyMutex);
            m_checkNotifyQueue.push(info);
        }
        m_checkNotifyCV.notify_one(); // 立即唤醒主线程

        // 更新计数器
        m_nCheckNotifiedCount.fetch_add(1);
    }
}

void deal::RecordFailedImg(const FailedImgRecord &record)
{
    std::lock_guard<std::mutex> lock(m_productFailedMutex);
    m_ProductFailedList.push_back(record);
}

void deal::PrintProductStatistics(const LoadProductImages &product)
{
    printf("\n");
    printf("╔══════════════════════════════════════════════════════════\n");
    printf("║ 产品：%s - 处理完成\n", product.product_id.c_str());
    printf("║ ───────────────────────────────────────────────────────  \n");
    printf("║ 总计：%zu 对图片\n", product.images.size());
    printf("║ 成功：%d 对\n", m_nProductSuccessCount.load());
    printf("║ 失败：%d 对\n", m_nProductFailCount.load());

    int totalProcessed = m_nProductSuccessCount.load() + m_nProductFailCount.load();
    float successRate = (totalProcessed > 0) ? (m_nProductSuccessCount.load() * 100.0f / totalProcessed) : 0;
    printf("║ 成功率：%.1f%%\n", successRate);

    if (!m_ProductFailedList.empty())
    {
        printf("║ ───────────────────────────────────────────────────────  \n");
        printf("║ 失败列表:\n");
        for (size_t i = 0; i < m_ProductFailedList.size() && i < 10; i++)
        {
            const auto &record = m_ProductFailedList[i];
            printf("║   [%zu] 左：%s\n", i, record.left_path.c_str());
            printf("║         右：%s\n", record.right_path.c_str());
            printf("║         错误：%s\n", record.errorReason.c_str());
        }
        if (m_ProductFailedList.size() > 10)
        {
            printf("║   ... 还有 %zu 条失败记录\n", m_ProductFailedList.size() - 10);
        }
    }
    printf("╚══════════════════════════════════════════════════════════\n");
    printf("\n");
}
int deal::ReJson_product(std::vector<Json_Det_Path> &jsonList, std::string strProductName)
{
    // 获取要检测的  json 图片 list

    int temstatus = IN_IMG_Status_Start;
    int PushNum = 0;
    // 开始逐一复测
    for (int i = 0; i < jsonList.size(); i++)
    {
        std::string strJson = jsonList.at(i).strPath_Json;
        std::string strimg = jsonList.at(i).strPath_CutImg;
        std::ifstream file(strJson);

        if (!file.is_open())
        {
            std::cerr << "Unable to open file!" << std::endl;
            return -1;
        }
        // 读取文件内容到 std::string
        std::stringstream buffer;
        buffer << file.rdbuf();
        std::string json_str = buffer.str(); // 获取 JSON 文件的内容作为字符串
        // 显示读取到的 JSON 字符串
        // std::cout << "JSON content: " << json_str << std::endl;
        cv::Mat cutimg = cv::imread(strimg, 0);
        int f0 = strJson.rfind('_');
        int f1 = strJson.rfind('.');
        int f2 = strJson.rfind('/');

        std::string str1 = strJson.substr(f2 + 1, f1 - f2 - 1);
        std::string str2 = strJson.substr(f0 + 1, f1 - f0 - 1);
        // std::string str3 = strJson.substr(f2 + 1, strJson.size() - f2);

        std::cout << str1 << std::endl;
        std::cout << str2 << std::endl;
        if (str1.find("CA") != std::string::npos)
        {
            str2 = "CA";
        }
        else if (str1.find("TA") != std::string::npos)
        {
            str2 = "TA";
        }
        else
        {
            continue;
        }

        std::cout << "start " << strJson << std::endl;

        std::shared_ptr<CheckResult> result;
        // 多线程 互斥 作用域
        {

            std::shared_ptr<shareImage> temdet = std::make_shared<shareImage>();
            temdet->strCameraName = str2;
            temdet->strImgProductID = strProductName;
            temdet->strChannel = str2;
            temdet->strImgName = str1;

            std::cout << "strChannel " << temdet->strChannel << std::endl;

            temdet->Det_Mode = DET_MODE_ReJson;
            temdet->img = cutimg;
            temdet->resultJson = json_str;

            {
                if (i == 0)
                {
                    temdet->Status = IN_IMG_Status_Start;
                }
                else if (i == jsonList.size() - 1)
                {
                    temdet->Status = IN_IMG_Status_End;
                }
                else
                {
                    temdet->Status = IN_IMG_Status_Other;
                }
            }

            int re = m_pALLImgCheckAnalysisy->SetDataRun_SharePtr(temdet);
            if (re != 0)
            {
                printf("reJson Error %d \n", re);
                continue;
            }
            PushNum++;
            // 结果异常
        }
    }
    int getresultNum = 0;
    while (true)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟消费过程
        // 处理结果

        std::shared_ptr<CheckResult> checkResult;
        int re = m_pALLImgCheckAnalysisy->GetCheckReuslt(checkResult);
        printf("********************** Get result  %d   -- %s  \n", getresultNum, checkResult->in_shareImage->strChannel.c_str());
        saveImg("/home/aidlux/BOE/ReJsonresult/", checkResult);
        getresultNum++;
        if (getresultNum == PushNum)
        {
            break;
        }
    }
    return 0;
}
void deal::GetResultThread()
{
    std::vector<int> vi;
    vi.push_back(18);
    auto nRet = set_cpu_id(vi);
    printf("bind cpu ret %d, %d\n", nRet, 18);
    int re = 0;

    int nsleep1 = 2 * 1000;

    while (!m_bExit)
    {
        // 1、拷贝检测结果到队列
        GetDealResultToQueu();
        usleep(nsleep1);
    }
}
void deal::ReadImgThread(int id)
{

    int nsleep1 = 200 * 1000;
    int readThreadIdx = id;
    while (!m_bExit)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟消费过程

        // 读图模式
        if (READ_THREAD_TYPE_READIMG == m_nReadThread_type)
        {
            Thread_ReadImg(readThreadIdx);
        }
        else if (READ_THREAD_Detect == m_nReadThread_type)
        {
        }
    }
}
void deal::testimg(cv::Mat img)
{
}

int deal::updataResltInfo(std::shared_ptr<CheckResult> result)
{

    mutex_DetResult_.lock();
    std::string productID = result->in_shareImage->strImgProductID;
    std::string imgName = result->in_shareImage->strChannel;
    // printf("add  productID %s  imgName %s %d\n", productID.c_str(), imgName.c_str(), result->nresult);
    long t1 = getcurTime();
    m_DetResult.updata(productID, imgName, result->nresult, t1);
    for (int i = 0; i < ERROR_TYPE_COUNT; i++)
    {
        if (result->defectResultList[i].nresult == 1)
        {
            m_DetResult.update_qx(result->defectResultList[i].keyName, result->defectResultList[i].num);
        }
    }
    mutex_DetResult_.unlock();
    return 0;
}
// 滑动窗口二值化函数
void deal::slidingWindowAutoThreshold(const cv::Mat &src, cv::Mat &dst, int windowSize, int step, double C)
{
    // 确保窗口大小为奇数
    // if (windowSize % 2 == 0)
    // {
    //     windowSize++;
    // }

    // 创建目标图像
    dst = cv::Mat::zeros(src.size(), CV_8UC1);

    // 获取源图像的尺寸
    int rows = src.rows;
    int cols = src.cols;
    int xs = 0;
    int xe = windowSize;
    int ys = 0;
    int ye = windowSize;
    for (int y = ye; y < rows;)
    {
        int xs = 0;
        int xe = windowSize;
        for (int x = xe; x < cols;)
        {

            cv::Rect roi;
            roi.x = xs;
            roi.width = windowSize;
            roi.y = ys;
            roi.height = windowSize;

            cv::Mat window = src(roi);

            // 计算窗口中的平均值和标准差
            cv::Scalar mean, stdDev;
            cv::meanStdDev(window, mean, stdDev);
            // printf(" x %d %d y %d %d  %f  %f \n", xs, xe, ys, ye, mean[0], stdDev[0]);
            int T = mean[0] + 20 * stdDev[0];
            cv::threshold(window, dst(roi), T, 255, cv::THRESH_BINARY);

            // cv::rectangle(src, roi, cv::Scalar(255, 0, 255));
            if (xe == cols)
            {
                break;
            }
            xs = xs + step;
            xe = xs + windowSize;
            if (xs < cols && xe > cols)
            {
                xe = cols;
                xs = xe - windowSize;
            }
        }
        if (ye == rows)
        {
            break;
        }
        ys = ys + step;
        ye = ys + windowSize;
        if (ys < rows && ye > rows)
        {
            ye = rows;
            ys = ye - windowSize;
        }
    }
}
int deal::SetStatus(int type, int status)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_DetStatus]);
    m_DetStatusList[type] = status;

    return 0;
}
int deal::GetStatus(int type)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_DetStatus]);

    return m_DetStatusList[type];
}
bool deal::IsStatus(int type, int status)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_DetStatus]);
    if (m_DetStatusList[type] == status)
    {
        return true;
    }

    return false;
}
int deal::SetStatus_List(int idx, Thread_Status_ status)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_ReadImgThread]);
    m_nReadStausList[idx] = status;
    return 0;
}
int deal::GetStatus_List(int idx)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_ReadImgThread]);
    return m_nReadStausList[idx];
}
bool deal::IsStatus_List(int idx, Thread_Status_ status)
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_ReadImgThread]);
    if (idx < 0 || idx >= READ_IMG_THREAD_NUM)
    {
    }
    else
    {
        if (m_nReadStausList[idx] == status)
        {
            return true;
        }
    }

    return false;
}

int deal::setReadThreadStart()
{
    for (int i = 0; i < READ_IMG_THREAD_NUM; i++)
    {
        SetStatus_List(i, Thread_Status_READY);
    }
    return 0;
}

int deal::GetReadImgCompleteThreadIdx()
{
    for (int i = 0; i < READ_IMG_THREAD_NUM; i++)
    {
        if (IsStatus_List(i, Thread_Status_COMMPLET))
        {
            return i;
        }
    }
    return -1;
}

bool deal::IsALLComplete()
{
    std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_DetStatus]);

    for (size_t i = 0; i < READ_IMG_THREAD_NUM; i++)
    {
        if (m_nReadStausList[i] == ReadImg_Status_COMMPLET)
        {
            return false;
        }
    }
    return true;
}

int deal::InitCPUIDX()
{
    int start = 3;
    m_CPUInfo[THREAD_CPU_Main_Det].set(start, 4);
    start += 4;
    m_CPUInfo[THREAD_CPU_Main_readImg].set(start, READ_IMG_THREAD_NUM);
    start += READ_IMG_THREAD_NUM;
    m_CPUInfo[THREAD_CPU_Main_saveImg].set(start, Save_IMG_THREAD_NUM);
    start += Save_IMG_THREAD_NUM;
    m_CPUInfo[THREAD_CPU_CheckSo].set(start, 15);
    return 0;
}

void deal::Thread_ReadImg(int id)
{
    if (!IsStatus_List(id, Thread_Status_READY))
    {
        return;
    }

    int re = 0;
    std::shared_ptr<JC_IMAGE_INFO_> pImageInfo = nullptr;
    re = GetReadImgInfo(pImageInfo);
    if (pImageInfo == nullptr)
    {
        printf("pImageInfo ==  nullptr=================id %d=============\n", id);
        return;
    }
    pImageInfo->img = cv::imread(pImageInfo->strPath, 0);
    m_ReadImgThread_Result[id] = pImageInfo;

    // 线程完成读图，设置现场状态为 完成
    SetStatus_List(id, Thread_Status_COMMPLET);

    // printf("Thread_ReadImg=================id %d  %s=============\n", id, pImageInfo->strPath.c_str());
}

int deal::InsertReadImgInfo(std::shared_ptr<JC_IMAGE_INFO_> pImageInfo)
{
    std::lock_guard<std::mutex> lock(mutex_ReadImgList);
    m_ReadImg_queue.push(pImageInfo);
    cv_ReadImgList.notify_one(); // 唤醒等待的线程
    return 0;
}

int deal::GetReadImgInfo(std::shared_ptr<JC_IMAGE_INFO_> &pImageInfo)
{
    // printf("===============waite img info ===============\n");
    std::unique_lock<std::mutex> lock(mutex_ReadImgList);

    cv_ReadImgList.wait(lock, [this]()
                        { return !m_ReadImg_queue.empty(); });

    pImageInfo = m_ReadImg_queue.front(); // 获取队首数据
    if (pImageInfo == NULL)
    {
        return 1;
    }
    m_ReadImg_queue.pop(); // 弹出队首数据
    return 0;
}

int deal::LoadOfflineCheckImg(std::string strImgPath)
{
    std::vector<cv::String> img_paths;
    cv::glob(strImgPath, img_paths, true);
    m_OffLineCheckImgList.erase(m_OffLineCheckImgList.begin(), m_OffLineCheckImgList.end());
    m_OffLineCheckImgNameList.erase(m_OffLineCheckImgNameList.begin(), m_OffLineCheckImgNameList.end());
    for (int i = 0; i < img_paths.size(); i++)
    {

        size_t found = img_paths[i].find_last_of("/\\");

        // std::cout << img_paths[i] << std::endl;
        std::string str = img_paths[i];
        m_OffLineCheckImgNameList.push_back(str);
    }
    return 0;
}
int deal::LoadImgPath_JCSN(std::string strImgPath)
{

    std::cout << strImgPath << std::endl;
    std::vector<cv::String> img_paths;

    cv::glob(strImgPath, img_paths, true);

    m_OffImageSNPathList.erase(m_OffImageSNPathList.begin(), m_OffImageSNPathList.end());

    for (int i = 0; i < img_paths.size(); i++)
    {

        std::string path = img_paths[i];
        // std::cout << img_paths[i] << std::endl;

        // 提取所有文件夹名称
        std::vector<std::string> allDirectories = extractAllDirectories(path);
        std::string strSN = "";
        // 输出所有文件夹名称
        std::string strAllPath = "/";

        for (const auto &dir : allDirectories)
        {
            strAllPath += dir;
            if (isValidString(dir))
            {
                strSN = dir;
                // std::cout << strSN << std::endl;
                break;
            }
            strAllPath += "/";
        }

        bool bh = false;
        for (int j = 0; j < m_OffImageSNPathList.size(); j++)
        {
            if (m_OffImageSNPathList.at(j) == strAllPath)
            {
                bh = true;
                break;
            }
        }
        if (!bh)
        {
            if (m_OffImageSNPathList.size() < m_nTestNum)
            {
                m_OffImageSNPathList.push_back(strAllPath);
                std::cout << strAllPath << std::endl;
            }

            // std::cout << strSN << std::endl;
        }
    }

    return 0;
}

bool deal::isValidString(const std::string &str)
{
    // 检查字符串长度是否为10
    if (str.length() < 14 || str.length() > 19)
    {
        return false;
    }

    // 检查字符串中的每个字符是否都是字母或数字
    for (char c : str)
    {
        if (!std::isalnum(c))
        { // 如果字符不是字母或数字
            return false;
        }
    }

    // 字符串满足条件
    return true;
}
int deal::LoadProductID(std::string strImgPath)
{
    m_product_ID_List.erase(m_product_ID_List.begin(), m_product_ID_List.end());
    std::vector<cv::String> img_paths;

    // tif 格式
    {
        std::string str_bmp = strImgPath + "/*.ytimage";
        std::cout << str_bmp << std::endl;

        cv::glob(str_bmp, img_paths, true);
        for (int i = 0; i < img_paths.size(); i++)
        {

            std::string path = img_paths[i];
            // 提取所有文件夹名称
            std::vector<std::string> allDirectories = extractAllDirectories(path);
            std::string strSN = "";
            // 输出所有文件夹名称
            std::string strAllPath = "/";

            for (const auto &dir : allDirectories)
            {
                // std::cout << dir << std::endl;
                strAllPath += dir;
                if (isValidString(dir))
                {
                    strSN = dir;
                    break;
                }
                strAllPath += "/";
            }

            bool bh = false;
            for (int j = 0; j < m_product_ID_List.size(); j++)
            {
                if (m_product_ID_List.at(j) == strAllPath)
                {
                    bh = true;
                    break;
                }
            }
            if (!bh)
            {
                if (m_product_ID_List.size() < m_nTestNum)
                {
                    m_product_ID_List.push_back(strAllPath);
                    std::cout << strAllPath << std::endl;
                }
            }
        }
    }

    return 0;
}
int deal::RandDrawImg(cv::Mat srcimg, cv::Mat &randErrorImg)
{

    randErrorImg = srcimg.clone();
    cv::Rect roi;
    roi.x = (rand() % (srcimg.cols - 20 - 20)) + 20;
    roi.y = (rand() % (srcimg.rows - 20 - 20)) + 20;
    roi.width = (rand() % (100 - 5)) + 5;
    roi.height = roi.width;

    if (roi.x + roi.width >= srcimg.cols)
    {
        roi.x = srcimg.cols - roi.width - 1;
        /* code */
    }
    if (roi.y + roi.height >= srcimg.rows)
    {
        roi.y = srcimg.rows - roi.height - 1;
        /* code */
    }
    randErrorImg(roi).setTo(30);
    return 0;
}
void deal::DealImg()
{
}
// 提取所有文件夹名称函数
std::vector<std::string> deal::extractAllDirectories(const std::string &path)
{
    std::vector<std::string> directories;
    std::string directory;

    // 遍历路径中的每个字符
    for (char c : path)
    {
        // 如果遇到路径分隔符，则将当前文件夹名称存储起来
        if (c == '/' || c == '\\')
        {
            if (!directory.empty())
            { // 确保文件夹名称不为空
                directories.push_back(directory);
                directory.clear(); // 清空当前文件夹名称
            }
        }
        else
        {
            directory += c; // 将字符添加到当前文件夹名称中
        }
    }

    // 将最后一个文件夹名称添加到列表中
    if (!directory.empty())
    {
        directories.push_back(directory);
    }

    return directories;
}