#include "JZsdkLib.h"
#include "BaseConfig.h"
#include <pthread.h>
#include <math.h>

#include "IRCUT/ircut.h"

#include "MediaProc/IRC_funtion/SatIrcLibProc/Sat_Irc.h"

#ifdef RTK_MPP_STATUS_ON
#include "MediaProc/MultProc/RTK_mmp/RTK_mmp.h"
#include "MediaProc/MultProc/RTK_mmp/Dec/RTK_mmp_dec.h"
#include "MediaProc/MultProc/RTK_mmp/Enc/RTK_mmp_enc.h"
#include "MediaProc/Camera/Camera.h"

#endif

#ifdef RTK_RGA_STATUS_ON

#include "MediaProc/RgaProc/RK_Rga/RK_Rga.h"

#endif

#include "MediaProc/MediaProc.h"
#include "UI_control/UI_control.h"
#include "CommonMod/PowerManger/PowerManger.h"

typedef struct ST_RgaInfo
{
    //源图像
    RK_RgaImage *src_img;

    //裁剪图像
    RK_RgaImage *corp_img;

    //目标图像
    RK_RgaImage *dst_img;

    //放大倍数
    int scale;

}ST_RgaInfo;


typedef struct T_JZST_info
{
/*************************************************************/
    //红外相机的编码器信息
    T_rtk_mmp_enc_info *IRC_enc_info; 

    //红外相机的rga信息
    ST_RgaInfo *IRC_rga_info;

/*************************************************************/
    //光学相机的解码器信息
    T_rtk_mmp_dec_info *Opt_dec_info;

    //光学相机的编码器信息
    T_rtk_mmp_enc_info *Opt_enc_info; 

    //光学相机的相机信息
    JZsdk_CameraInfo *Opt_Camera_info;

    //光学相机的rga信息
    ST_RgaInfo *Opt_rga_info;   
/*************************************************************/
    //融合相机的编码器信息
    T_rtk_mmp_enc_info *Fuse_enc_info;

}T_JZST_info;


#define JZ_IRC_WIDTH 320
#define JZ_IRC_HEIGHT 256
#define JZ_IRC_FRAMERATE 25
#define JZ_IRC_INDEX VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST
#define JZ_IRC_BPS 500000


static T_JZST_info g_JZST_info;



T_JZsdkReturnCode JZST_SetNextFrame_IDR(unsigned int index)
{
    if (index == JZ_IRC_INDEX)
    {
        RTK_mmp_enc_SetNextFrame_IDR(g_JZST_info.IRC_enc_info);
    }
    // else if (index == JZ_C1_OPT_INDEX)
    // {
    //     RTK_mmp_enc_SetNextFrame_IDR(g_JZC1_info.Opt_enc_info);
    // }
    // else if (index == JZ_C1_FUSE_INDEX)
    // {
    //     RTK_mmp_enc_SetNextFrame_IDR(g_JZC1_info.Fuse_enc_info);
    // }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    
}

//数据推送函数
static T_JZsdkReturnCode JZST_PushFrame(int CameraIndex, unsigned char* data, unsigned int data_len)
{
    int currentIndex = VideoMgmt_GetVideoStreamFlowIndexNum(); //获取当前视频流索引
    //无视频流
    if (currentIndex == 0)
    {
        //不推送视频
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    //红外相机
    if (currentIndex == JZ_IRC_INDEX && CameraIndex == JZ_IRC_INDEX)
    {

        //推送数据到流转模块
        VideoMgmt_Single_FrameIn(data, data_len);
    }

    // //光学相机
    // if(CameraIndex == JZ_C1_OPT_INDEX && currentIndex == JZ_C1_OPT_INDEX)
    // {
    //     //推送数据到流转模块
    //     VideoMgmt_Single_FrameIn(data, data_len);
    // }

    // //组合视频流
    // if (currentIndex == JZ_C1_FUSE_INDEX && CameraIndex == JZ_C1_FUSE_INDEX)
    // {
    //     //推送数据到流转模块
    //     VideoMgmt_Single_FrameIn(data, data_len);
    // }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


static T_JZsdkReturnCode rgb32_to_yuv420sp(uint8_t *rgb32, uint8_t *yuv420sp, int width, int height) 
{
    int frame_size = width * height;
    uint8_t *y_plane = yuv420sp;              // Y分量
    uint8_t *uv_plane = yuv420sp + frame_size; // UV交错分量（NV12）

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            // 假设RGB32内存布局为[B,G,R,A]（小端序常见）
            int idx = (y * width + x) * 4;
            uint8_t B = rgb32[idx];
            uint8_t G = rgb32[idx + 1];
            uint8_t R = rgb32[idx + 2];
            // uint8_t A = rgb32[idx + 3]; // Alpha通道忽略

            // 计算YUV（BT.601标准）
            int Y = 0.257 * R + 0.504 * G + 0.098 * B + 16;
            int U = -0.148 * R - 0.291 * G + 0.439 * B + 128;
            int V = 0.439 * R - 0.368 * G - 0.071 * B + 128;

            // 写入Y分量
            y_plane[y * width + x] = (uint8_t)fmin(fmax(Y, 0), 255);

            // 仅偶数行和偶数列采样UV分量（420下采样）
            if (y % 2 == 0 && x % 2 == 0) {
                int uv_idx = (y / 2) * (width / 2) + (x / 2);
                uv_plane[uv_idx * 2] = (uint8_t)fmin(fmax(U, 0), 255);     // U
                uv_plane[uv_idx * 2 + 1] = (uint8_t)fmin(fmax(V, 0), 255); // V
            }
        }
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

static void *JZ_ircDataThread(void *args)
{
#ifdef SATIRC_LIB_STATUS_ON
    U8_t *buf = NULL;
    int PixelNum = JZ_IRC_WIDTH * JZ_IRC_HEIGHT;

    buf = (U8_t *)malloc(JZ_IRC_WIDTH * JZ_IRC_HEIGHT * 4);
    U8_t *yuv420sp = (U8_t *)malloc(JZ_IRC_WIDTH * JZ_IRC_HEIGHT * 3 / 2);

    int test_i = 0;
    int color = 0;

    JZSDK_LOG_INFO("红外相机线程启动！");
    
    FILE  *fp = fopen("image.h264", "wb");

    while (1)
    {
        delayMs(1000/JZ_IRC_FRAMERATE);

        //每25张更换一次颜色
        if (test_i % 25 == 0)
        {
            color++;
            if (color == 12)
            {
                color = 0;
            }
            
            SatIrc_SetColorPalette(color);  //可以测0~11
        }       

        //获取红外数据
        memset(buf, 0, JZ_IRC_WIDTH * JZ_IRC_HEIGHT * 4);
        SatIrc_GetIRImage(buf, PixelNum);

        //将红外数据转换为yuv
        memset(yuv420sp, 0, 320 * 256 * 3 / 2);
        rgb32_to_yuv420sp(buf, yuv420sp, JZ_IRC_WIDTH, JZ_IRC_HEIGHT);    

        //将红外数据送去编码器
        unsigned char *h264Data = NULL;
        unsigned int h264DataLen = 0;

        MppPacket Packet = NULL;

        //进行编码
        RTK_mmp_enc_data_to_h264(g_JZST_info.IRC_enc_info, yuv420sp, 320 * 256 * 3 / 2, &Packet);

        h264DataLen = mpp_packet_get_length(Packet);
        h264Data   = (unsigned char *)mpp_packet_get_pos(Packet);
        
        //释放掉packet
        mpp_packet_deinit(&Packet);

        //将h264数据推送
        JZST_PushFrame(JZ_IRC_INDEX, h264Data, h264DataLen);
        fwrite(h264Data, h264DataLen, 1, fp);
        fflush(fp);

        JZSDK_LOG_DEBUG("红外相机线程执行中！, 长度 %d", h264DataLen);

        test_i++;
    }

    fclose(fp);
#endif // #ifdef SATIRC_LIB_STATUS_ON
}

static T_JZsdkReturnCode JZ_IrcCameraInit()
{
    T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

    //初始化红外参数   
    ret = IRC_ParamInit(JZ_IRC_HEIGHT, JZ_IRC_WIDTH, JZ_IRC_FRAMERATE, IRC_DEAL_MODE_SAT);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("红外参数初始化失败！");
        return ret;
    }

    //初始化红外相机
    ret = SatIrc_init();
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("红外相机初始化失败！");
        return ret;
    }

    //初始化接收相机数据的线程
    T_JZsdkOsalHandler *osal_handle = JZsdk_Platform_GetOsalHandler();

    T_JZTaskHandle JZ_ircDataTask = NULL;
    osal_handle->TaskCreate("JZ_ircDataThread", JZ_ircDataThread, 8192, NULL, &JZ_ircDataTask);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode JZ_ST_Init(int mode)
{
    //网口初始化
    if (mode == APP_UART)
    {
        //网口初始化
        JZsdk_NetWork_Init();
    }

    T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

#ifdef RTK_MPP_STATUS_ON

    //初始化相机流管理器
    T_JZsdkVideoMgmtHandler VideoMgmtHandler = {
        .SetNextFrame_IDR = JZST_SetNextFrame_IDR,
    };
    VideoMgmt_Init(VideoMgmtHandler);

    //初始化红外的编码器
    g_JZST_info.IRC_enc_info = (T_rtk_mmp_enc_info *)malloc(sizeof(T_rtk_mmp_enc_info));

    //配置参数
    g_JZST_info.IRC_enc_info->Input_fmt = MPP_FMT_YUV420SP;
    g_JZST_info.IRC_enc_info->encType = MPP_VIDEO_CodingAVC;
    g_JZST_info.IRC_enc_info->width = JZ_IRC_WIDTH;
    g_JZST_info.IRC_enc_info->height = JZ_IRC_HEIGHT;
    g_JZST_info.IRC_enc_info->FrameNum = JZ_IRC_FRAMERATE;
    g_JZST_info.IRC_enc_info->IDR_gop = 5;
    g_JZST_info.IRC_enc_info->bps_target = JZ_IRC_BPS;

    g_JZST_info.IRC_enc_info->hor_stride = JZ_ALIGN(g_JZST_info.IRC_enc_info->width, 16);
    g_JZST_info.IRC_enc_info->ver_stride = JZ_ALIGN(g_JZST_info.IRC_enc_info->height, 16);

    //初始化编码器
    RTK_mmp_enc_Init(g_JZST_info.IRC_enc_info);

    //初始化红外相机
    ret = JZ_IrcCameraInit();
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("红外相机初始化失败！");
    }

    //设置默认推送红外摄像头
    VideoMgmt_VideoStreamFlowIndex(JZ_IRC_INDEX);
    
    return ret;

#endif

    JZSDK_LOG_INFO("红外相机初始化完成");
}