#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "JZsdkLib.h"

#include "BaseConfig.h"

#ifdef KTIRC_LIB_STATUS_ON

#include "../IRC_data_deal/IRC_data_deal.h"

#include <vector>
#include <mutex>

#include "M330Interface.h"

#include "MediaProc/MediaProc_Param.h"

#include "KtLibProc.h"
#include "MediaProc/ImageProc/PseudoColor/PseudoColor.h"

// 定义互斥锁
static std::mutex MarkDataMutex;
 
T_JZsdkReturnCode KtLib_Init(struct IRC_param *dealInfo)
{
    InitM330();
    
    KtLib_writeMarkData(HIGH_TEMP_DATA,dealInfo->HighT_NineFrame_Avg ,dealInfo->PixelNum);
    KtLib_writeMarkData(LOW_TEMP_DATA, dealInfo->LowT_NineFrame_Avg ,dealInfo->PixelNum);
    KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->SPC_Mark_Data ,dealInfo->PixelNum);

    JZSDK_LOG_INFO("KtLib_Init success");
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**************************************
 * 
 *  ktlib写入 气体阈值
 * 
 * 
 * *************************************/
T_JZsdkReturnCode KtLib_writeEnhanceThreshold(int maxValue,int minValue)
{

    U16_t threshold[2] = {maxValue, minValue};

    T_JZsdkReturnCode ret =  KtLib_writeMarkData(TEMP_CHOOSE_ENHANCE_THRESHOLD, threshold, 2);
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_INFO("LoadMarkData ENHANCE_THRESHOLD_DATA success");
    }
    else
    {
        JZSDK_LOG_ERROR("LoadMarkData ENHANCE_THRESHOLD_DATA error");
    }
    
    return ret;
}

/***********************
 * 
 * 
 *  ktLib写入 气体着色颜色
 *  DGCE_ColorType; //色彩模式 0 红 1 绿 2 蓝
 * 
 * ********************/
T_JZsdkReturnCode KtLib_writeColorData(int DGCE_ColorType)
{
    U16_t color[3] = { 0,0,0}; //B G R

    if (DGCE_ColorType == 0)
    {
        color[2] = 255;
    }
    else if (DGCE_ColorType == 1)
    {
        color[1] = 255;
    }
    else if (DGCE_ColorType == 2)
    {
        color[0] = 255;
    }

    T_JZsdkReturnCode ret = KtLib_writeMarkData(TEMP_CHOOSE_ENHANCE_COLOR, color, 3);
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_INFO("LoadMarkData TEMP_CHOOSE_ENHANCE_COLOR success");
    }
    else
    {
        JZSDK_LOG_ERROR("LoadMarkData TEMP_CHOOSE_ENHANCE_COLOR error");
    }

    return ret;
}

/***********************
 * 
 * 
 *  ktLib写入  伪彩颜色
 * 
 * ********************/
T_JZsdkReturnCode KtLib_writePseoColorData()
{
    const int rows = 256;
    const int cols = 3;
    U16_t array[rows][cols]; //请确保是256*3*sizeof(int)为连续内存

    //1、获取颜色数组
    int r_color[256] = { 0 };
    int g_color[256] = { 0 };
    int b_color[256] = { 0 };

    PseudoColor_GetColor_toIntArray(r_color, g_color, b_color);

    //2、将颜色数组赋值给array
    for (int i = 0; i < rows; i++)
    {
        array[i][0] = b_color[i];
        array[i][1] = g_color[i];
        array[i][2] = r_color[i];
    }
    
    T_JZsdkReturnCode ret = KtLib_writeMarkData(TEMP_CHOOSE_PSEUDEO_COLOR, (U16_t *)array, 3*256);
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_INFO("LoadMarkData TEMP_CHOOSE_PSEUDEO_COLOR success");
    }
    else
    {
        JZSDK_LOG_ERROR("LoadMarkData TEMP_CHOOSE_PSEUDEO_COLOR error");
    }

    return ret;
}

/**********************************************
 * 
 * 
 *  ktlib 写入标定的数据
 * 
 * 
 * **********************************************/
T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size)
{
    bool bool_ret;

    // 加锁
    std::lock_guard<std::mutex> lock(MarkDataMutex);

    int TempBuffer[size];

    for (int i = 0; i < size; i++)
    {
        TempBuffer[i] = in[i];
    }

    switch (type)
    {
        //高温标记数据
        case HIGH_TEMP_DATA:
            bool_ret = LoadMarkData(TempBuffer ,size,HIGH_MARK_DATA);
            if (bool_ret == false)
            {
                JZSDK_LOG_ERROR("LoadMarkData HIGH_TEMP_DATA error");
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
            }
            else
            {
                JZSDK_LOG_INFO("LoadMarkData HIGH_TEMP_DATA success");
            }
            
        break;

        //低温标记数据
        case LOW_TEMP_DATA:
            bool_ret = LoadMarkData(TempBuffer ,size,LOW_MARK_DATA);
            if (bool_ret == false)
            {
                JZSDK_LOG_ERROR("LoadMarkData LOW_TEMP_DATA error");
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
            }
            else
            {
                JZSDK_LOG_INFO("LoadMarkData LOW_TEMP_DATA success");
                return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            }

        break;

        //单点标记数据
        case SPC_MARK_DATA:
            bool_ret = LoadMarkData(TempBuffer ,size, SINGLE_MARK_DATA);
            if (bool_ret == false)
            {
                JZSDK_LOG_ERROR("LoadMarkData SPC_MARK_DATA error");
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
            }

            else
            {
                JZSDK_LOG_INFO("LoadMarkData SPC_MARK_DATA success");
                return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            }
        break;

        case TEMP_CHOOSE_ENHANCE_THRESHOLD:
            bool_ret = LoadMarkData(TempBuffer ,size,ENHANCE_THRESHOLD);
            if (bool_ret == false)
            {
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
            }
            else
            {
                return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            }
        break;

        case TEMP_CHOOSE_ENHANCE_COLOR:

            bool_ret = LoadMarkData(TempBuffer ,size,ENHANCE_COLOR_DATA);
            if (bool_ret == false)
            {
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
            }
            else
            {
                return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            }
        break;

        case TEMP_CHOOSE_PSEUDEO_COLOR:
            bool_ret = LoadMarkData(TempBuffer ,size,PSEUDO_COLOR_DATA);
            if (bool_ret == false)
            {
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
            }
            else
            {
                return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            }
        break;

        default:
            break;
    }
    
}

static int lastCorrectMode = JZ_FLAGCODE_OFF;
static int LastColorMode = JZ_FLAGCODE_OFF;
static int ColorMode = JZ_FLAGCODE_OFF;


T_JZsdkReturnCode KtLib_DataDeal(U16_t* U16_data, unsigned int U16_dataSize, 
                                U8_t **RGB_data, unsigned int *RGB_dataSize,      
                                struct IRC_param *dealInfo)
{
    // 加锁
    std::lock_guard<std::mutex> lock(MarkDataMutex);

    T_JZsdkReturnCode ret;
    bool bool_ret;

    // 如果打开了单点校正
    if (dealInfo->FrameCorrectMode == IRC_CORRCTION_SPC && lastCorrectMode != IRC_CORRCTION_SPC)
    {
        JZSDK_LOG_INFO("sdk开启单点校正");

        //关闭两点校正
        CloseDoubleNuc();

        //打开单点校正
        OpenSingleNuc();

        lastCorrectMode = IRC_CORRCTION_SPC;
    }


    // 如果打开了两点校正
    if (dealInfo->FrameCorrectMode == IRC_CORRCTION_TPC && lastCorrectMode != IRC_CORRCTION_TPC)
    {

        JZSDK_LOG_INFO("sdk开启两点校正");

        //关闭单点校正
        CloseSingleNuc(); 
        
        //打开两点校正
        OpenDoubleNuc();

        lastCorrectMode = IRC_CORRCTION_TPC;
    }

    // 如果关闭了校正
    if (dealInfo->FrameCorrectMode == JZ_FLAGCODE_OFF && lastCorrectMode != JZ_FLAGCODE_OFF)
    {
        JZSDK_LOG_INFO("sdk无校正");

        //关闭单点校正
        CloseSingleNuc(); 

        //关闭两点校正
        CloseDoubleNuc();

        lastCorrectMode = JZ_FLAGCODE_OFF;
    }

    //将u16数据转为char 数据 以用于输入库
    char* inputDataChar = new char[U16_dataSize*2];
    int inputDataSize = U16_dataSize*2;
    for (int i = 0; i < U16_dataSize; i++)
    {
        inputDataChar[i*2+1] = (U16_data[i] & 0xFF00) >> 8;
        inputDataChar[i*2] = (U16_data[i] & 0x00FF);
    }

    //注册一个输出数组
    *RGB_data = new U8_t[dealInfo->PixelNum*3];
    *RGB_dataSize = 0;

    //检查图像输入模式
    ColorMode = dealInfo->OutputPixelColorMode;
    if (LastColorMode != ColorMode)
    {
        //上次色彩模式为无
        if (LastColorMode == 0)
        {
            //不用管
        }
        //上次为伪彩模式
        else if (LastColorMode == 1)
        {
            //关闭伪彩
            ClosePseudoColor();
        }
        //上次为气体增强模式1
        else if (LastColorMode == 2)
        {
            //关闭气体增强
            CloseDynamicGasesColorEnhance();
        }
        //上次为气体增强模式2
        else if (LastColorMode == 3)
        {
            //关闭气体增强
            CloseDynamicGasesColorEnhance2();
        }
        
        //根据当前模式选择打开模式
        if (ColorMode == 0)
        {
            //不用管
        }
        else if (ColorMode == 1)
        {
            //打开伪彩
            OpenPseudoColor();
        }
        else if (ColorMode == 2)
        {
            //打开气体增强模式1
            OpenDynamicGasesColorEnhance();
        }
        else if (ColorMode == 3)
        {
            //打开气体增强模式2
            OpenDynamicGasesColorEnhance2();
        }
        
        LastColorMode = ColorMode;
    }
    
    bool_ret = GetImageSynchronous(inputDataChar, inputDataSize, (char *)*RGB_data, dealInfo->PixelNum*3, (int *)RGB_dataSize); //同步处理数据
        
    if (bool_ret == false)
    {
        JZSDK_LOG_ERROR("sdk处理错误");
    }
    

    //JZSDK_LOG_DEBUG("ktlib pixnum*3:%d rgbsize:%d",dealInfo->PixelNum*3 ,*RGB_dataSize);

    delete[] inputDataChar;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

#endif