#include <jni.h>
#include <string>
#include <thread>
#include <android/log.h>
#include <dlfcn.h>
#include <unwind.h>
#include "server_global.h"
#include "yuv_data.h"

extern "C"{
#include "libavutil/avutil.h"
#include "librtmp/rtmp.h"
#include <libyuv.h>
}

struct BacktraceState {
    void** current;
    void** end;
};

static _Unwind_Reason_Code unwindCallback(struct _Unwind_Context* context, void* arg) {
    BacktraceState* state = (BacktraceState*)arg;
    uintptr_t pc = _Unwind_GetIP(context);
    if (pc) {
        if (state->current == state->end) {
            return _URC_END_OF_STACK;
        } else {
            *state->current++ = (void*)pc;
        }
    }
    return _URC_NO_REASON;
}

size_t captureBacktrace(void** buffer, size_t max) {
    BacktraceState state = {buffer, buffer + max};
    _Unwind_Backtrace(unwindCallback, &state);
    return state.current - buffer;
}

void printBacktrace() {
    const size_t max = 30;
    void* buffer[max];
    size_t size = captureBacktrace(buffer, max);

    for (size_t i = 0; i < size; i++) {
        const void* addr = buffer[i];
        const char* symbol = "";
        Dl_info info;
        if (dladdr(addr, &info) && info.dli_sname) {
            symbol = info.dli_sname;
        }
        __android_log_print(ANDROID_LOG_ERROR, "NativeCrash", "  #%zu pc %p %s", i, addr, symbol);
    }
}

void signalHandler(int sig) {
    __android_log_print(ANDROID_LOG_ERROR, "NativeCrash", "Caught signal: %d", sig);
    printBacktrace();  // 打印崩溃时的调用栈

    signal(sig, SIG_DFL);
    raise(sig);
}

void setupSignalHandlers() {
    signal(SIGSEGV, signalHandler); // 捕获段错误
    signal(SIGABRT, signalHandler); // 捕获 abort 信号
    signal(SIGFPE, signalHandler);  // 捕获浮点运算异常
    signal(SIGILL, signalHandler);  // 捕获非法指令
}

void *task_load_main_surface(void *args){
    while (TRUE){
        YUVData *data;
        int result = mainSurfaceFrames.pop(data);
        if(!result){
            continue;
        }
        pthread_mutex_lock(&loadSurfaceMutex);
        loadSurface(nativeMainWindow,data->yuvData,data->width,data->height);
        pthread_mutex_unlock(&loadSurfaceMutex);

        releaseYuvData(data->yuvData);
        if(mainSurfaceFrames.size() > 1){
            int result = mainSurfaceFrames.pop(data);
            if(result){
                releaseYuvData(data->yuvData);
            }
        }
        delete data;
    }
    return 0;
}

void *task_count_down(void *args){
    const double frameInterval = 1000.0 / FRAME_PS; // 每帧 16.67 毫秒 (60 FPS)
    while (TRUE){
        auto startTime = std::chrono::high_resolution_clock::now();
        YUVData *yuv = new YUVData;
        yuv->timestamp = RTMP_GetTime() - start_time;
        pushFrames.push(yuv);
        // 计算时间间隔和实际执行时间
        auto endTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed = endTime - startTime;
        auto waitTime = std::chrono::milliseconds(static_cast<int>(frameInterval)) - elapsed;

        if (waitTime.count() > 0) {
            // 等待剩余的时间，确保每秒 60 帧
            std::this_thread::sleep_for(waitTime);
        }

    }
    return 0;
}

void *task_pushFrames(void *args){
    int64_t time = getCurrentTimestamp();
    while (TRUE){
        int result = pushFrames.pop(mainYuvData);
        if(!result){
            continue;
        }
        //LOGI("开始编辑画面");
        float rate = 0;
        int width = 0;
        int height = 0;
        pthread_mutex_lock(&pushVideoMutex);
        bool flag = mainView && (mainView->yuvFrames.size() > 0 || mainView->yuvFrame);
        //当前有主画面
        if(flag){
            if(mainView->yuvFrames.size() > 0){
                releaseYuvFrameData(mainView->yuvFrame);
                mainView->yuvFrames.pop(mainView->yuvFrame);
                //清除缩放画面
                if(mainView->scaledYuvFrames.size() > 5){
                    if(!mainView->scaledYuvFrame){
                        mainView->scaledYuvFrames.pop(mainView->scaledYuvFrame);
                    }
                    while (mainView->scaledYuvFrame->timestamp < mainView->yuvFrame->timestamp && mainView->scaledYuvFrames.size() > 5 ){
                        releaseYuvFrameData(mainView->scaledYuvFrame);
                        mainView->scaledYuvFrames.pop(mainView->scaledYuvFrame);
                    }
                }
            }else{
                LOGE("主窗丢帧");
            }
            rate = mainView->yuvFrame->width * 1.0 / mainView->yuvFrame->height;
            width = mainView->yuvFrame->width;
            height = mainView->yuvFrame->height;
        } else {
            rate = FRAME_WIDTH * 1.0 / FRAME_HEIGHT;
            width = FRAME_WIDTH;
            height = FRAME_HEIGHT;
        }
        int64_t t = getCurrentTimestamp();
        //LOGI("pushMainYUV");
        //画面比例不一致,需要裁切
        if(flag && rate != FRAME_WIDTH*1.0/FRAME_HEIGHT){

            if (rate < FRAME_WIDTH*1.0/FRAME_HEIGHT){
                width = width;
                height = (width / 9 * 16);
            }else{
                height = height;
                width = (height / 16 * 9);
            }
            int64_t t1 = getCurrentTimestamp();
            cutYUV(mainView->yuvFrame->yuvData,mainView->yuvFrame->width,mainView->yuvFrame->height,mainView->yuvFrame->mainPositionRate,mainYuvData->yuvData);
            //LOGI("cutYUV 裁切 耗时：%d",getCurrentTimestamp() - t1);

        }else if(flag){
            int64_t t1 = getCurrentTimestamp();
            copyYUV(mainView->yuvFrame->yuvData,width,height,mainYuvData->yuvData);
            //LOGI("copyYUV 耗时：%d",getCurrentTimestamp() - t1);
        }else{
            copyYUV(blackYUV,width,height,mainYuvData->yuvData);
        }
        if(nativeMainWindow && mainView){
            YUVData *mainYUV = new YUVData;
            mainYUV->width = width;
            mainYUV->height = height;
            copyYUV(mainYuvData->yuvData,width,height,mainYUV->yuvData);
            mainSurfaceFrames.push(mainYUV);
        }
        do {
            if(pushers.size() == 0){
                break;
            }

            if(width != FRAME_WIDTH){
                //缩放至1080
                uint8_t *dstData[3];
                copyYUV(mainYuvData->yuvData,width,height,dstData);
                delete mainYuvData->yuvData[0];
                delete mainYuvData->yuvData[1];
                delete mainYuvData->yuvData[2];
                //LOGI("缩放至1080");
                int64_t t1 = getCurrentTimestamp();
                scaleYUV(dstData,width,height,FRAME_WIDTH,FRAME_HEIGHT,mainYuvData->yuvData);
                //LOGI("缩放至1080 耗时：%d",getCurrentTimestamp() - t1);
                delete dstData[0];
                delete dstData[1];
                delete dstData[2];
            }
            //加水印
            //LOGI("加水印");
            int64_t t2 = getCurrentTimestamp();
            waterYUV(mainYuvData->yuvData);
            //LOGI("加水印 耗时：%d",getCurrentTimestamp() - t2);
            //主画面
            //LOGI("pushYUV pushYUV %d",pushers.size());
            int64_t t1 = getCurrentTimestamp();
            videoChannel->pushYUV(mainYuvData->yuvData);
            //LOGI("pushYUV 编码 耗时：%d", getCurrentTimestamp() - t1);
            //LOGI("pushYUV 耗时：%d", getCurrentTimestamp() - t);
        } while (0);
        releaseYuvFrameData(mainYuvData);
        pthread_mutex_unlock(&pushVideoMutex);
    }
    return 0;
}

pthread_t mainFrameStart;
pthread_t countDownStart;
pthread_t pushFrameStart;
jint JNI_OnLoad(JavaVM *vm,void *reserved){
    // 计算每个平面的大小
    size_t y_size = FRAME_WIDTH * FRAME_HEIGHT;         // Y 平面大小
    size_t u_size = (FRAME_WIDTH / 2) * (FRAME_HEIGHT / 2); // U 平面大小
    size_t v_size = (FRAME_WIDTH / 2) * (FRAME_HEIGHT / 2); // V 平面大小
    blackYUV[0] = new uint8_t[y_size];
    blackYUV[1] = new uint8_t[u_size];
    blackYUV[2] = new uint8_t[v_size];
    // 填充 Y 平面（黑色，Y = 0）
    memset(blackYUV[0], 0,y_size);
    // 填充 U 平面（中性色度，U = 128）
    memset(blackYUV[1], 128, u_size);
    // 填充 V 平面（中性色度，V = 128）
    memset(blackYUV[2], 128, v_size);
    setupSignalHandlers();
    pthread_mutex_init(&pushVideoMutex,0);
    pthread_mutex_init(&pushAudioMutex,0);
    pthread_mutex_init(&pushNV21Mutex,0);
    pthread_mutex_init(&loadSurfaceMutex,0);
    mainSurfaceFrames.setWork(1);
    mainSurfaceFrames.setReleaseCallback(releaseYuvDataCallBack);
    pthread_create(&mainFrameStart,0, task_load_main_surface,NULL);
    pushFrames.setWork(1);
    pushFrames.setReleaseCallback(releaseYuvDataCallBack);
    pthread_create(&countDownStart,0, task_count_down,NULL);
    pthread_create(&pushFrameStart,0, task_pushFrames,NULL);
    //记录开始推流的时间戳
    start_time = RTMP_GetTime();
    videoChannel = new VideoChannel();
    audioChannel = new AudioChannel();
    videoChannel->setVideoCallback(packetCallBack);
    videoChannel->initVideoEncoder(FRAME_WIDTH,FRAME_HEIGHT,FRAME_PS,FRAME_RATE);
    audioChannel->setAudioCallback(packetCallBack);
    LOGI("encoderInit");
    audioChannel->initAudioEncoder(44100,2);
    return JNI_VERSION_1_6;
}

extern "C"
JNIEXPORT jstring JNICALL
Java_com_runt_live_native_LivePlayer_ffpeg_1version(JNIEnv *env, jobject thiz) {
    //return env->NewStringUTF(av_version_info());
    char version[50];
    sprintf(version,"librtmp version :%d",RTMP_LibVersion());
    return env->NewStringUTF(version);
}


extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1set_1main_1stream_1code(JNIEnv *env, jclass clazz, jint stream_code) {
    pthread_mutex_lock(&pushVideoMutex);
    mainStreamCode = stream_code;
    mainView = getMainViewData();
    LOGI("主窗口变更 %d",stream_code);
    pthread_mutex_unlock(&pushVideoMutex);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1remove_1mini_1view(JNIEnv *env, jclass clazz,  jint stream_code) {
    pthread_mutex_lock(&pushVideoMutex);
    LOGI("%d 关闭窗口",stream_code);
    if(!pushMiniDatas.empty() && pushMiniDatas.size()>0){
        for(int i = 0 ; i < pushMiniDatas.size() ; i ++ ){
            if(pushMiniDatas[i]->streamCode == stream_code){
                releaseYuvFrameData(pushMiniDatas[i]->yuvFrame);
                releaseYuvFrameData(pushMiniDatas[i]->scaledYuvFrame);
                pushMiniDatas[i]->yuvFrame = 0;
                pushMiniDatas[i]->scaledYuvFrame = 0;
                pushMiniDatas[i]->yuvFrames.setWork(0);
                //pushMiniDatas[i]->yuvFrames.clear();
                pushMiniDatas[i]->scaledYuvFrames.setWork(0);
                //pushMiniDatas[i]->scaledYuvFrames.clear();
                DELETE(pushMiniDatas[i])
                pushMiniDatas.erase(pushMiniDatas.begin() + i);
                break;
            }
        }
    }
    if(mainStreamCode == stream_code){
        mainView = 0;
    }
    pthread_mutex_unlock(&pushVideoMutex);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1update_1mini_1view(JNIEnv *env, jclass clazz, jint stream_code,  jint sn,
                                                                jint width, jint height,float p_x_rate, float p_y_rate,jboolean audioOn,jboolean videoOn,
                                                                jlong videoDelay,jint stream_type,
                                                                jfloat main_position_rate, jfloat view_rate) {
    pthread_mutex_lock(&pushVideoMutex);
    //LOGI("%d 窗口变化",stream_code);
    MiniViewData *data = 0;
    if(pushMiniDatas.size() > sn && pushMiniDatas[sn]){
        data = pushMiniDatas[sn];
        //LOGI("%d 更新窗口",stream_code);
        //LOGI("%d 窗口变化 %dx%d => %dx%d",stream_code,data->width,data->height,width,height);
    }else{
        data = new MiniViewData;
        pushMiniDatas.push_back(data);
        data->scaledYuvFrame = 0;
        data->yuvFrame = 0;
        data->yuvFrames.setWork(1);
        data->scaledYuvFrames.setWork(1);
        //LOGI("%d 新增窗口 %f %f",stream_code,data->viewRate , view_rate);
    }
    data->streamCode = stream_code;
    data->width = width;
    data->sn = sn;
    data->audioOn = audioOn;
    data->videoOn = videoOn;
    data->videoDelay = videoDelay;
    data->height = height;
    data->pYrate = p_y_rate;
    data->pXrate = p_x_rate;
    data->mainPositionRate = main_position_rate;
    data->viewRate = view_rate;
    data->streamType = stream_type;
    pthread_mutex_unlock(&pushVideoMutex);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1push_1nv21(JNIEnv *env, jclass clazz, jint stream_code, jbyteArray bytes) {
    jbyte *data = env->GetByteArrayElements(bytes,NULL);
    //LOGI("native_1push_1nv21 ");
    pushNV21(stream_code,data);
    env->ReleaseByteArrayElements(bytes,data,0);
}
extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1set_1main_1surface(JNIEnv *env, jclass clazz,
                                                               jobject surface) {
    pthread_mutex_lock(&loadSurfaceMutex);
    nativeMainWindow = ANativeWindow_fromSurface(env, surface);
    pthread_mutex_unlock(&loadSurfaceMutex);
    if(!nativeMainWindow){
        LOGE("nativeWindow 回收");
    }
    if(!jvmMainCall){
        jvmMainCall = new JavaMainCall(env,clazz);
    }

}
extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1release_1main_1surface(JNIEnv *env, jclass clazz) {
    pthread_mutex_lock(&loadSurfaceMutex);
    if(nativeMainWindow){
        ANativeWindow_release(nativeMainWindow);
        nativeMainWindow = 0 ;
    }
    pthread_mutex_unlock(&loadSurfaceMutex);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1push_1rgba(JNIEnv *env, jclass clazz, jint stream_code,
                                                       jbyteArray bytes) {
    jbyte *data = env->GetByteArrayElements(bytes, NULL);
    pushRGBA(stream_code, reinterpret_cast<uint8_t *>(data));
    env->ReleaseByteArrayElements(bytes,data,0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1push_1nv_121_1data(JNIEnv *env, jclass clazz, jint stream_code,
                                                               jobject y_data,jobject u_data, jobject v_data,
                                                               jint y_stride, jint u_stride,jint v_stride, jint uv_stride,
                                                               jint angle,jint width,jint height) {
    uint8_t *yData = (uint8_t *)env->GetDirectBufferAddress(y_data);
    uint8_t *uData = (uint8_t *)env->GetDirectBufferAddress(u_data);
    uint8_t *vData = (uint8_t *)env->GetDirectBufferAddress(v_data);
    pushNV21(stream_code, (uint8_t *)(yData), (uint8_t *)uData, (uint8_t *)vData,y_stride,u_stride,v_stride,uv_stride,angle,width,height);
    LOGI("native_1push_1nv_121_1data ,y_stride:%d,u_stride:%d,v_stride:%d,uv_stride:%d ",y_stride,u_stride,v_stride,uv_stride);
}
extern "C"
JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1push_1pcm(JNIEnv *env, jclass clazz, jbyteArray bytes) {
    jbyte  *data = env->GetByteArrayElements(bytes,NULL);
    pushPCM(data);
    //LOGI("native_1push_1pcm safequeue packets：%d",&pusher->audioPackets);
    env->ReleaseByteArrayElements(bytes,data,0);
}
extern "C"
JNIEXPORT jbyteArray JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1convert_1nv21_1to_1rgba(JNIEnv *env, jclass clazz,
                                                                    jbyteArray bytes, jint width,
                                                                    jint height) {
    // TODO: implement native_convert_nv21_to_rgba()
}
extern "C" JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1push_1yuyv(JNIEnv *env, jclass clazz, jint stream_code, jbyteArray bytes) {

    jbyte *data = env->GetByteArrayElements(bytes, NULL);
    pushYUYV(stream_code, data);
    env->ReleaseByteArrayElements(bytes,data,0);
}
extern "C" JNIEXPORT void JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1push_1yuv(JNIEnv *env, jclass clazz, jint stream_code, jbyteArray bytes) {

    jbyte *data = env->GetByteArrayElements(bytes, NULL);
    uint8_t *yuv[3];
    MiniViewData *view = getMiniView(stream_code);
    // 获取 jbyteArray 的大小
    int ySize = view->width * view->height;
    int uSize = ySize / 4;
    int vSize = ySize / 4;
    int totalSize = ySize + uSize + vSize;

    // 让 data[3] 指向适当的位置
    yuv[0] = reinterpret_cast<uint8_t *>(data);             // Y 平面
    yuv[1] = reinterpret_cast<uint8_t *>(data + ySize);     // U 平面
    yuv[2] = reinterpret_cast<uint8_t *>(data + ySize + uSize); // V 平面
    pushYUV(stream_code,yuv);
    env->ReleaseByteArrayElements(bytes,data,0);
}
extern "C" JNIEXPORT jbyteArray JNICALL
Java_com_runt_live_cpp_LiveMiniView_native_1get_1cut_1frame(JNIEnv *env, jclass clazz, jint index, jint stream_code) {
    uint8_t *yuvData[3];
    if(mainYuvData){
        pthread_mutex_lock(&pushVideoMutex);
        copyYUV(mainYuvData->yuvData,FRAME_WIDTH,FRAME_HEIGHT,yuvData);
        pthread_mutex_unlock(&pushVideoMutex);
    }else{
        copyYUV(blackYUV,FRAME_WIDTH,FRAME_HEIGHT,yuvData);
    }
    waterYUV(index,yuvData);
    //*****裁切画面
    MiniViewData *miniView = getMiniView(stream_code);
    int scaleWidth = (FRAME_WIDTH * miniView->viewRate);
    int scaleHeight = (FRAME_WIDTH / (miniView->width * 1.0 / miniView->height) * miniView->viewRate);
    //涉及到 YUV 4:2:0 格式的图像时，宽度和高度通常需要是 2 的倍数
    if(scaleWidth % 2 == 1){
        scaleWidth+=1;
    }
    if(scaleHeight % 2 == 1){
        scaleHeight+=1;
    }
    if(scaleWidth > FRAME_WIDTH){
        scaleWidth = FRAME_WIDTH;
    }
    if(scaleHeight > FRAME_HEIGHT){
        scaleHeight = FRAME_HEIGHT;
    }
    if(!miniView->scaledYuvFrame){
        miniView->scaledYuvFrame = new YUVData;
    }
    miniView->scaledYuvFrame->width = scaleWidth;
    miniView->scaledYuvFrame->height = scaleHeight;
    miniView->scaledYuvFrame->pYrate = miniView->pYrate;
    miniView->scaledYuvFrame->pXrate = miniView->pXrate;
    uint8_t *dstData[3];
    //位置
    int offsetY = (FRAME_HEIGHT - scaleHeight) * miniView->pYrate;
    int offsetX = (FRAME_WIDTH - scaleWidth) * miniView->pXrate;
    cutYUV(yuvData,FRAME_WIDTH,FRAME_HEIGHT,offsetX,offsetY,dstData,scaleWidth,scaleHeight);
    LOGE("index:%d x:%d y:%d %dx%d view:%dx%d",index,offsetX,offsetY,scaleWidth,scaleHeight,miniView->width,miniView->height);
    copyYUV(dstData,scaleWidth,scaleHeight,miniView->scaledYuvFrame->yuvData);
    addBlackBorder(miniView->scaledYuvFrame->yuvData,scaleWidth,scaleHeight,3);
    //源数据没用了
    delete yuvData[0];
    delete yuvData[1];
    delete yuvData[2];
    //******转为rgba
    int size = scaleWidth * scaleHeight * 4;
    uint8_t *rgba_data = yuvToRGBA(dstData,scaleWidth,scaleHeight);
    //yuv数据没用了
    delete dstData[0];
    delete dstData[1];
    delete dstData[2];
    //转为java字节数组
    jbyteArray java_array = env->NewByteArray(size);
    env->SetByteArrayRegion(java_array, 0, size, (jbyte *)rgba_data);
    delete[] rgba_data;
    return java_array;
}