#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#include "JZsdkLib.h"
#include "./VideoMgmt.h"
#include "version_choose.h"
#include "BaseConfig.h"

#include "./VideoStreamPush/VideoStream_Push.h"
#include "./VideoStreamRecord/VideoStream_Record.h"
#include "./VideoStreamPhoto/VideoStream_ShootPhoto.h"
#include "UI_control/UI_control.h"
#include "../MediaParm.h"

#include "../StreamProc/RTK_mmp/RTK_mmp.h"

//额外头文件声明


#define DATA_SEND_FROM_VIDEO_STREAM_MAX_LEN  60000
#define VIDEO_FRAME_AUD_LEN                  6

static const unsigned char s_frameAudInfo[VIDEO_FRAME_AUD_LEN] = {0x00, 0x00, 0x00, 0x01, 0x09, 0x10};

JZ_VideoStreamUseStatus g_VideoStreamDealStatus = VIDEO_STREAM_IDLE;  //视频流的处理状态

/*视频流缓冲区地址说明
    留有三对缓冲区，一队中的数据分别为成型数据，以及原始数据

    如果设备只有一个摄像头，则使用一号视频流

    如果设备为 红外+光学 则红外为1号，光学为2号

*/
void *VideoMgmt_FirstVideo_index = NULL; //一号视频流的缓冲地址
void *VideoMgmt_SecondVideo_index = NULL; //二号视频流的缓冲地址
void *VideoMgmt_ThirdVideo_index = NULL; //三号视频流的缓冲地址

void *VideoMgmt_FirstRaw_index = NULL; //一号原始流的缓冲地址
void *VideoMgmt_SecondRaw_index = NULL; //二号原始流的缓冲地址
void *VideoMgmt_ThirdRaw_index = NULL; //三号原始流的缓冲地址

static int VideoFreezeFlag = JZ_FLAGCODE_OFF; //视频流冻结功能

//视频流缓冲区结构  
typedef struct JZsdk_VideoBuffer{  
    unsigned char *data;  //缓冲区数据
    unsigned int data_len;  
    int is_ready; // 标志位，表示数据是否准备好被读取  
    pthread_mutex_t lock; // 互斥锁，用于线程同步  
    pthread_cond_t cond; // 条件变量，用于通知读取线程数据已准备好  
} JZsdk_VideoBuffer; 

// 初始化缓冲区  
T_JZsdkReturnCode VideoMgmt_init_buffer(void **index) 
{  
    //从索引值获取对应的缓冲区
    //创建一个缓冲区
    struct JZsdk_VideoBuffer *VideoBuffer = NULL;

    //为编码器参数注册内存
    VideoBuffer = (struct JZsdk_VideoBuffer *)malloc(sizeof(struct JZsdk_VideoBuffer));  
    if (VideoBuffer == NULL) {  
        JZSDK_LOG_ERROR("视频流缓冲区注册失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  
    
    VideoBuffer->data = NULL;  
    VideoBuffer->data_len = 0;  
    VideoBuffer->is_ready = 0;  
    pthread_mutex_init(&VideoBuffer->lock, NULL);  
    pthread_cond_init(&VideoBuffer->cond, NULL);  

    if (*index != NULL)
    {
        free(*index);
    }

    *index = (void *)VideoBuffer;
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}  

//缓冲区清理
T_JZsdkReturnCode VideoMgmt_VideoBuffer_Deinit(void **index)
{
    if (index == NULL || *index == NULL) {  
        // 如果索引或缓冲区指针为空，则直接返回  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }  

    //从索引值获取对应的缓冲区
    struct JZsdk_VideoBuffer *VideoBuffer = (struct JZsdk_VideoBuffer *)*index; 

    if (VideoBuffer->data != NULL)
    {
        free(VideoBuffer->data);
        VideoBuffer->data = NULL;
    }
    
    VideoBuffer->data_len = 0;
    VideoBuffer->is_ready = 0;
    pthread_mutex_destroy(&VideoBuffer->lock);  
    pthread_cond_destroy(&VideoBuffer->cond);  

    free(VideoBuffer);
    index = NULL; // 防止悬挂指针  

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//缓冲区写入
T_JZsdkReturnCode VideoMgmt_write_data(void **index, unsigned char *data, unsigned int data_len)
{
    //从索引值获取对应的缓冲区
    struct JZsdk_VideoBuffer *VideoBuffer = (struct JZsdk_VideoBuffer *)*index; 

    pthread_mutex_lock(&VideoBuffer->lock);  

    // 释放旧数据  
    if (VideoBuffer->data) 
    {  
        free(VideoBuffer->data);  
        VideoBuffer->data = NULL;
    }  
      
    // 分配新内存并复制数据
    VideoBuffer->data = (unsigned char *)malloc(data_len);  
    memcpy(VideoBuffer->data, data, data_len);  
    VideoBuffer->data_len = data_len;  
    VideoBuffer->is_ready = 1; // 标记数据已准备好  
      
    // 通知读取线程数据已准备好  
    pthread_cond_signal(&VideoBuffer->cond);  
      
    pthread_mutex_unlock(&VideoBuffer->lock);  
}

//缓冲区读取
//输入的参数，缓冲区索引地址 回复的数据地址 回复的数据长度 帧头帧尾模式 帧头帧尾长度
T_JZsdkReturnCode VideoMgmt_read_data(void **index, unsigned char **data, unsigned int *data_len, unsigned int mode, unsigned int extra_len)
{
    //从索引值获取对应的缓冲区
    struct JZsdk_VideoBuffer *VideoBuffer = (struct JZsdk_VideoBuffer *)*index; 

    // 检查缓冲区指针是否有效  
    if (VideoBuffer == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; // 假设的错误码，表示参数无效  
    }  

    pthread_mutex_lock(&VideoBuffer->lock);  
        
    // 等待数据准备好  
    while (!VideoBuffer->is_ready) 
    {  
        pthread_cond_wait(&VideoBuffer->cond, &VideoBuffer->lock);  
    }  

    // 检查数据指针是否有效  
    if (VideoBuffer->data == NULL) 
    {  
        pthread_mutex_unlock(&VideoBuffer->lock);  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; // 假设的错误码，表示没有数据可供读取  
    }  

    // 返回数据和长度
    *data_len = VideoBuffer->data_len;
    if (mode == JZ_FLAGCODE_OFF)
    {
        *data = (unsigned char *)malloc(*data_len);  
        memcpy(*data, VideoBuffer->data, *data_len);
    }
    else if (mode == VIDEOMGMT_USE_FRAMEHEAD)
    {
        *data = (unsigned char *)malloc(*data_len + extra_len);  
        memcpy(*data+extra_len, VideoBuffer->data, VideoBuffer->data_len);
    }
    else if (mode == VIDEOMGMT_USE_FRAMEEND)
    {
        *data = (unsigned char *)malloc(*data_len + extra_len);  
        memcpy(*data, VideoBuffer->data, VideoBuffer->data_len);
    }   
    else
    {
        *data = (unsigned char *)malloc(*data_len);  
        memcpy(*data, VideoBuffer->data, *data_len);
    }
    
    VideoBuffer->is_ready = 0;
    pthread_mutex_unlock(&VideoBuffer->lock); 
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**********
 * 
 *  直接返回地址略有风险，暂时不考虑使用这个以下注释的方法
 * 
 * ************/
// //缓冲区读取
// T_JZsdkReturnCode VideoMgmt_read_data(void **index, unsigned char **data, unsigned int *data_len)
// {
//     //从索引值获取对应的缓冲区
//     struct JZsdk_VideoBuffer *VideoBuffer = (struct JZsdk_VideoBuffer *)*index; 

//     // 检查缓冲区指针是否有效  
//     if (VideoBuffer == NULL) 
//     {  
//         return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; // 假设的错误码，表示参数无效  
//     }  

//     pthread_mutex_lock(&VideoBuffer->lock);  
        
//     // 等待数据准备好  
//     while (!VideoBuffer->is_ready) 
//     {  
//         pthread_cond_wait(&VideoBuffer->cond, &VideoBuffer->lock);  
//     }  

//     // 检查数据指针是否有效  
//     if (VideoBuffer->data == NULL) 
//     {  
//         pthread_mutex_unlock(&VideoBuffer->lock);  
//         return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; // 假设的错误码，表示没有数据可供读取  
//     }  

//     // 返回数据和长度
//     *data = (VideoBuffer->data);
//     *data_len = VideoBuffer->data_len;

//     return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
// }

// //回复已经读取完成,在read函数，且数据处理完成后调用
// T_JZsdkReturnCode VideoMgmt_ReplyRead(void **index)
// {
//     //从索引值获取对应的缓冲区
//     struct JZsdk_VideoBuffer *VideoBuffer = (struct JZsdk_VideoBuffer *)*index; 

//     // 检查缓冲区指针是否有效  
//     if (VideoBuffer == NULL) 
//     {  
//         return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; // 假设的错误码，表示参数无效  
//     }  

//     VideoBuffer->is_ready = 0;
//     pthread_mutex_unlock(&VideoBuffer->lock); 

//     return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
// }



/*********************************************************************************************************************************************
 * 
 * 
 *  视频流流转部分
 * 
 * 
 * *********************************************************************************************************************************************/
struct VideoMgmt_VideoStreamFlow
{
    void **index; //用于提出画面流的缓冲区地址
    int  VideoStreamFlowIndex; //缓冲区的索引号，用于区分缓冲区
    int  FrameNumber; //推流的帧数
};

static int VideoStreamFlowIndexNum = JZ_FLAGCODE_OFF; //视频流转的索引值


//设置流转的视频流
T_JZsdkReturnCode VideoMgmt_VideoStreamFlowIndex(int index)
{
    switch (index)
    {
        case JZ_FLAGCODE_OFF:
        {
            JZSDK_LOG_INFO("切换视频流为关");
            VideoStreamFlowIndexNum = index;
        }
        break;
        
        case VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST:
        {
            JZSDK_LOG_INFO("切换视频流为一号");
            VideoStreamFlowIndexNum = index;
        }
        break;     

        case VIDEOMGMT_STREAMING_FLOW_INDEX_SECOND:
        {
            JZSDK_LOG_INFO("切换视频流为二号");
            VideoStreamFlowIndexNum = index;
        }
        break;   

        case VIDEOMGMT_STREAMING_FLOW_INDEX_THIRD:
        {
            JZSDK_LOG_INFO("切换视频流为三号");
            VideoStreamFlowIndexNum = index;
        }
        break;  

        default:
            JZSDK_LOG_ERROR("错误的视频流设置");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        break;
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**************
 * 
 *   视频流的录像流回放开关
 *  
=
 * ************/
static int Temp_LastVideoStatus = JZ_FLAGCODE_NORMAL;
T_JZsdkReturnCode VideoMgmt_VideoStreamFlow_RecordPlay(int status)
{
    if (status == JZ_FLAGCODE_ON && Temp_LastVideoStatus == JZ_FLAGCODE_NORMAL)
    {
        Temp_LastVideoStatus = VideoStreamFlowIndexNum;
        VideoStreamFlowIndexNum = VIDEOMGMT_STREAMING_FLOW_INDEX_RECORD;
    }
    else if (status == JZ_FLAGCODE_OFF && Temp_LastVideoStatus != JZ_FLAGCODE_NORMAL)
    {
        VideoStreamFlowIndexNum = Temp_LastVideoStatus;
        Temp_LastVideoStatus = JZ_FLAGCODE_NORMAL;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/******************************
 * 
 *  指定h264流产生一个i帧
 * 
 * *********************************/
T_JZsdkReturnCode VideoStramPhoto_DevelopH264FlowGenerateIDR()
{
#if DEVICE_VERSION == JZ_C1
    switch (VideoStreamFlowIndexNum)
    {
        case VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST:
        {
            JZsdk_Kt_CamMMPenc_SetNextFrame_IDR(0);
        }
        break;     

        case VIDEOMGMT_STREAMING_FLOW_INDEX_SECOND:
        {
            JZsdk_Kt_CamMMPenc_SetNextFrame_IDR(1);
        }
        break;

        default:
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        break;
    }
#endif

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**************
 * 
 *   视频流流转的线程 
 *  
 * 
 * ************/
static T_JZsdkReturnCode VideoStreamToDeal(unsigned char *data, unsigned int data_len)
{
    //拍照数据
    VideoStramPhoto_PhotoDataIn(data, data_len);

    //录像处理函数
    VideoStramRecord_RecordDataIn(data, data_len);

    //连拍处理函数
    //FrameDeal_ShootPhotoBurstDeal(FrameDealBuffer, FrameLength);

    //推流
    VideoStream_PushFrame(data, data_len);
    //JZSDK_LOG_INFO("推送一帧%d,数据大小%d\n",VideoPush->VideoStreamFlowIndex,data_len);
}

static void *VideoMgmt_VideoStreamFlow_Thread(void *args)
{
    struct VideoMgmt_VideoStreamFlow *VideoPush = (struct VideoMgmt_VideoStreamFlow *)args;  
    int delay_time_ms = (1000/VideoPush->FrameNumber); //得出延时的ms

    unsigned char *FreezeData = NULL;
    unsigned int FreezeDataLen = 0;
    int FreezeFlag = JZ_FLAGCODE_OFF;

    while (1)
    { 
        delayMs(delay_time_ms);

        //判断是否用视频流是否用的是当前这个
        if (VideoPush->VideoStreamFlowIndex != VideoStreamFlowIndexNum)
        {
            continue; 
        }

        //推流操作
        //读取数据
        unsigned char *data = NULL;  
        unsigned int data_len = 0;  
        
        //如果视频为大疆H264型 或 JZH264型
        if (VIDEOMGMT_VIDEO_TPYE == VIDEOMGMT_TPYE_DJIH264 || VIDEOMGMT_VIDEO_TPYE == VIDEOMGMT_TPYE_JZH264 ) 
        {
            VideoMgmt_read_data((void **)VideoPush->index, &data, &data_len, VIDEOMGMT_USE_FRAMEEND, VIDEO_FRAME_AUD_LEN); //读取
            memcpy(data + data_len, s_frameAudInfo, VIDEO_FRAME_AUD_LEN);
            data_len = data_len + VIDEO_FRAME_AUD_LEN;
        }
        else
        {
            VideoMgmt_read_data((void **)VideoPush->index, &data, &data_len, JZ_FLAGCODE_OFF, JZ_FLAGCODE_OFF); //读取
        }

        //冻结功能
        if (VideoFreezeFlag == JZ_FLAGCODE_ON)
        {
            //如果冻结数据为空，且 当前为i帧
            if (FreezeData == NULL && data[4] == 0x67)
            {
                FreezeDataLen = data_len;
                JZsdk_Malloc((void **)&FreezeData, data_len);
                memcpy(FreezeData, data, data_len);
            }
        }
        
        if (VideoFreezeFlag == JZ_FLAGCODE_ON && FreezeDataLen != 0)
        {
            VideoStreamToDeal(FreezeData, FreezeDataLen);
        }
        else
        {
            VideoStreamToDeal(data, data_len);
        }

        // 释放数据（如果有必要的话）  
        if (data) {  
            free(data);  
            data = NULL;  
        }  
        data_len = 0;

        if (VideoFreezeFlag == JZ_FLAGCODE_OFF)
        {
            if (FreezeData) {  
                free(FreezeData);  
                FreezeData = NULL;  
            }    
            FreezeDataLen = 0;
        }        
    }

    pthread_exit(NULL);  
    return NULL;  
}

//视频流流转模块的初始化
T_JZsdkReturnCode VideoMgmt_VideoStreamFlow_Init(int FrameNumber, void **index, int VideoStreamFlowIndex)
{
    struct VideoMgmt_VideoStreamFlow *VideoStreamFlow = NULL;
    
    // 分配新内存并复制数据
    VideoStreamFlow = (struct VideoMgmt_VideoStreamFlow *)malloc(sizeof(struct VideoMgmt_VideoStreamFlow));  
    if (VideoStreamFlow == NULL) {  
        JZSDK_LOG_ERROR("视频流流转模块注册失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    VideoStreamFlow->index = index;
    VideoStreamFlow->FrameNumber = FrameNumber;
    VideoStreamFlow->VideoStreamFlowIndex = VideoStreamFlowIndex;

    //创建视频流流转线程
    pthread_t ReadDataTask;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程分离属性
	int ret = pthread_create(&ReadDataTask,&task_attribute,(void *)VideoMgmt_VideoStreamFlow_Thread,VideoStreamFlow);		//线程
	if(ret != 0)
	{
		JZSDK_LOG_ERROR("创建视频流流转线程失败!");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

    JZSDK_LOG_INFO("视频流流转模块初始化完毕");

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/**************
 * 
 *  相机功能 录制功能传递函数    
 *  1开启录制 0关闭录制并进行转码
 * 
 * ************/
T_JZsdkReturnCode VideoRecord_TransMode(int status)
{
    JZSDK_LOG_INFO("录像功能被调用,模式:%d",status);
    
    return VideoStreamRecord_TransMode(status);
}

/**************
 * 
 *  相机功能 拍摄功能传递函数    
 *  注意，这里需要先检查相机的状态是否是空闲状态
 * 
 * ************/
T_JZsdkReturnCode VideoRecord_ShootPhotoNum(int num)
{
    //通知拍照张数    
    VideoStreamPhoto_SetShootPhotoNum(num);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**************
 * 
 *   视频流使用状态 
 *  
 * 
 * ************/
T_JZsdkReturnCode VideoStream_GetVideoStreamUseStatus(int *status)
{
    *status = g_VideoStreamDealStatus;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**************
 * 
 *   视频流冻结 
 *  
 * 
 * ************/
static T_JZsdkReturnCode VideoStream_FreezeVideo(int value)
{
    if (value == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_INFO("视频流冻结");
        VideoFreezeFlag = JZ_FLAGCODE_ON;
    }
    else if (value == JZ_FLAGCODE_OFF)
    {
        JZSDK_LOG_INFO("关闭视频流冻结");
        VideoFreezeFlag = JZ_FLAGCODE_OFF;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/*******************************
 * 
 *  设置视频流参数
 * 
 * 
 * *****************************/
T_JZsdkReturnCode VideoMgmt_param(int flagcode, enum VideoMgmtParm paramflag, int *value)
{
    T_JZsdkReturnCode ret;

    if (flagcode == JZ_FLAGCODE_GET)
    {
        switch (paramflag)
        {
            case VIDEO_MGMT_FREEZE:
            {
               *value = VideoFreezeFlag;
            }
            break;     

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }
    
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else if (flagcode == JZ_FLAGCODE_SET)
    {
        switch (paramflag)
        {
            case VIDEO_MGMT_FREEZE:
            {
                return VideoStream_FreezeVideo(*value);
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }
    
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    JZSDK_LOG_ERROR("参数获取出错");
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}


/**************
 * 
 *   用于对外发送视频流情况
 * 
 * **************/
T_JZsdkReturnCode VideoMgmt_Send_StreamStatus(JZ_VideoStreamUseStatus status)
{
    UIcontrol_Send_CameraStatus(status);
}

/************
 * 
 *  获取流的宽高信息
 * 
 * 
 * **********************/
T_JZsdkReturnCode VideoMgmt_Get_StreamWidthAndHeight(int *width, int *height)
{
#if DEVICE_VERSION  == JZ_C1
    if (VideoStreamFlowIndexNum == VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST)
    {
        *width = FIRST_WIDTH;
        *height = FIRST_HEIGHT;
    }
    else
    {
        *width = SECOND_WIDTH;
        *height = SECOND_HEIGHT;
    }
#endif
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}