#ifndef HXVIDEODECODER_H
#define HXVIDEODECODER_H

#include <string.h>

#include <QDebug>

#include "HxUtils.h"

#include <opencv2/opencv.hpp>

extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/pixfmt.h"
#include "libavutil/imgutils.h"
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
}

#if USE_ALGORITHM
#include "rk_mpi.h"
#include "mpp_mem.h"
#include "mpp_time.h"
#include "mpp_env.h"
#include "mpp_common.h"
#include "mpp_frame.h"
#include "mpp_buffer_impl.h"
#include "RgaUtils.h"
#include "im2d.hpp"
#endif

class HxVideoDecoder
{
public:
    HxVideoDecoder(void) {}

#ifndef USE_ALGORITHM
    bool initialization(AVFormatContext* ifmt_ctx)
    {
        auto video_stream_index = -1;
        for (uint i = 0; i < ifmt_ctx->nb_streams; i++)
        {
            if (ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
                video_stream_index = static_cast<int>(i);
        }

        if (video_stream_index == -1)
            return false;

        /* 配置解码器 */
        video_dec_ctx = avcodec_alloc_context3(nullptr);
        if (video_dec_ctx == nullptr)
        {
            printf("Could not allocate AVCodecContext");
            return false;
        }

        /* 拷贝 */
        avcodec_parameters_to_context(video_dec_ctx, ifmt_ctx->streams[video_stream_index]->codecpar);

        /* 查找解码器 */
        auto codec = avcodec_find_decoder(video_dec_ctx->codec_id);
        if (!codec)
            return false;

        /* 打开解码器 */
        if (avcodec_open2(video_dec_ctx, codec, nullptr) < 0)
        {
            codec = nullptr;
            avcodec_free_context(&video_dec_ctx);
            return false;
        }

        video_dec_frame = av_frame_alloc();

        video_picture_frame = av_frame_alloc();

        /* 通过指定像素格式、图像宽、图像高来计算所需的内存大小 */
        auto numBytes = av_image_get_buffer_size(AV_PIX_FMT_BGR24, video_dec_ctx->width, video_dec_ctx->height, 1);
        /* 创建 video_out_buffer */
        video_out_buffer = static_cast<uint8_t*>(av_malloc(static_cast<ulong>(numBytes) * sizeof(uint8_t)));
        /* 填充数据 */
        av_image_fill_arrays(video_picture_frame->data, video_picture_frame->linesize, video_out_buffer, AV_PIX_FMT_BGR24, video_dec_ctx->width, video_dec_ctx->height, 1);

        auto pix_fmt = video_dec_ctx->pix_fmt;
        if (video_dec_ctx->pix_fmt == AVPixelFormat::AV_PIX_FMT_NONE)
            pix_fmt = AV_PIX_FMT_YUV420P;

        /* 将解码后的YUV数据转换成RGB32 */
        video_sws_context = sws_getContext(
            video_dec_ctx->width,  /* 输入图像的宽度 */
            video_dec_ctx->height, /* 输入图像的高度 */
            pix_fmt,               /* 输入图像的像素格式 */
            video_dec_ctx->width,  /* 输出图像的宽度 */
            video_dec_ctx->height, /* 输出图像的高度 */
            AV_PIX_FMT_BGR24,      /* 输出图像的像素格式 */
            SWS_BICUBIC,           /* 选择缩放算法(只有当输入输出图像大小不同时有效),一般选择SWS_FAST_BILINEAR */
            nullptr,               /* 输入图像的滤波器信息, 若不需要传NULL */
            nullptr,               /* 输出图像的滤波器信息, 若不需要传NULL */
            nullptr                /* 特定缩放算法需要的参数(?)，默认为NULL */
        );

        return true;
    }
#else
    bool initialization(void)
    {
        MPP_RET ret = MPP_OK;

        RK_U32 need_split = 1;

        /* 创建 MPP context 和 MPP api 接口 */
        ret = mpp_create(&mpp_ctx, &mpp_mpi);
        if (ret != MPP_OK)
        {
            release();

            HxLog::append("mpp", QString("mpp_create failed"));

            return false;
        }

        /* 配置解器 按帧输入码流 */
        ret = mpp_mpi->control(mpp_ctx, MPP_DEC_SET_PARSER_SPLIT_MODE, (MppParam*)&need_split);
        if (MPP_OK != ret)
        {
            release();

            HxLog::append("mpp", QString("mpi->control failed"));

            return false;
        }

        /* 配置解器 队列输入 */
        ret = mpp_mpi->control(mpp_ctx, MPP_SET_INPUT_BLOCK, (MppParam*)&need_split);
        if (MPP_OK != ret)
        {
            release();

            HxLog::append("mpp", QString("mpi->control failed"));

            return false;
        }

        /* 初始化 MPP （固定为H264） */
        ret = mpp_init(mpp_ctx, MPP_CTX_DEC, MPP_VIDEO_CodingAVC);
        if (MPP_OK != ret)
        {
            release();

            HxLog::append("mpp", QString("mpp_init failed"));

            return false;
        }

        return true;
    }
#endif

    void release(void)
    {
#ifndef USE_ALGORITHM
        if (video_dec_ctx)
        {
            avcodec_free_context(&video_dec_ctx);
            avcodec_close(video_dec_ctx);

            av_frame_free(&video_dec_frame);
            av_frame_free(&video_picture_frame);
            sws_freeContext(video_sws_context);

            if (video_out_buffer)
                av_free(video_out_buffer);
            video_out_buffer = nullptr;
        }
#else
        if (mpp_ctx)
        {
            mpp_mpi->reset(mpp_ctx);
            mpp_destroy(mpp_ctx);
            mpp_ctx = nullptr;
        }

        if (mpp_frame_group)
        {
            mpp_buffer_group_put(mpp_frame_group);
            mpp_frame_group = nullptr;
        }
#endif
    }

    void decode(AVPacket* packet, cv::Mat* mat)
    {
#ifndef USE_ALGORITHM
        /* 发送数据到ffmepg，放到解码队列中 */
        if (avcodec_send_packet(video_dec_ctx, packet) == 0)
        {
            /* 将成功的解码队列中取出1个frame */
            if (avcodec_receive_frame(video_dec_ctx, video_dec_frame) == 0)
            {
                /* 开始转换 */
                sws_scale(video_sws_context, static_cast<const uint8_t* const*>(video_dec_frame->data), video_dec_frame->linesize, 0, video_dec_ctx->height, video_picture_frame->data, video_picture_frame->linesize);

                (*mat) = cv::Mat(cv::Size(video_dec_ctx->width, video_dec_ctx->height), CV_8UC3);
                (*mat).data = video_out_buffer;
            }
        }
#else
        RK_U32 pkt_done = 0;
        RK_U32 pkt_eos = 0;
        RK_U32 err_info = 0;
        MPP_RET ret = MPP_OK;
        MppPacket mpp_packet = nullptr;
        MppFrame mpp_frame = nullptr;

        ret = mpp_packet_init(&mpp_packet, packet->data, packet->size);
        if (ret < 0)
            return;

        mpp_packet_set_pts(mpp_packet, packet->pts);

        //        qDebug("av_packet->data:%hhn", packet->data);

        do
        {
            // msleep(1);

            RK_S32 count = 5;
            // send the packet first if packet is not done
            if (!pkt_done)
            {
                ret = mpp_mpi->decode_put_packet(mpp_ctx, mpp_packet);
                if (MPP_OK == ret)
                    pkt_done = 1;
            }

            // then get all available frame and release
            do
            {
                // msleep(1);

                RK_S32 get_frm = 0;
                RK_U32 frame_eos = 0;

            try_again:
                ret = mpp_mpi->decode_get_frame(mpp_ctx, &mpp_frame);
                if (MPP_ERR_TIMEOUT == ret)
                {
                    if (count > 0)
                    {
                        count--;
                        msleep(2);
                        goto try_again;
                    }
                    qDebug("decode_get_frame failed too much time");
                }

                // qDebug("get MPP_OK:%d", MPP_OK);
                // qDebug("get ret:%d", ret);
                if (MPP_OK != ret)
                {
                    qDebug("decode_get_frame failed ret %d", ret);
                    break;
                }

                // qDebug("get  frame:%p", mpp_frame);

                if (mpp_frame)
                {
                    if (mpp_frame_get_info_change(mpp_frame))
                    {
                        RK_U32 width = mpp_frame_get_width(mpp_frame);
                        RK_U32 height = mpp_frame_get_height(mpp_frame);
                        RK_U32 hor_stride = mpp_frame_get_hor_stride(mpp_frame);
                        RK_U32 ver_stride = mpp_frame_get_ver_stride(mpp_frame);
                        RK_U32 buf_size = mpp_frame_get_buf_size(mpp_frame);

                        qDebug("decode_get_frame get info changed found");
                        qDebug("decoder require buffer w:h [%d:%d] stride [%d:%d] buf_size %d", width, height, hor_stride, ver_stride, buf_size);

                        ret = mpp_buffer_group_get_internal(&mpp_frame_group, MPP_BUFFER_TYPE_ION);
                        if (ret)
                        {
                            qDebug("get mpp buffer group  failed ret %d", ret);
                            break;
                        }
                        mpp_mpi->control(mpp_ctx, MPP_DEC_SET_EXT_BUF_GROUP, mpp_frame_group);

                        mpp_mpi->control(mpp_ctx, MPP_DEC_SET_INFO_CHANGE_READY, nullptr);
                    }
                    else
                    {
                        err_info = mpp_frame_get_errinfo(mpp_frame) | mpp_frame_get_discard(mpp_frame);
                        if (err_info)
                        {
                            qDebug("decoder_get_frame get err info:%d discard:%d.",
                                mpp_frame_get_errinfo(mpp_frame), mpp_frame_get_discard(mpp_frame));
                        }
                        frame_count++;
                        // qDebug("decode_get_frame get frame %d", frame_count);

                        if (!err_info)
                        {
                            RK_U32 width = mpp_frame_get_width(mpp_frame);
                            RK_U32 height = mpp_frame_get_height(mpp_frame);

                            MppBuffer mpp_buffer = mpp_frame_get_buffer(mpp_frame);

                            convert_to_mat(mpp_buffer, width, height, mat);

                            // RK_U32 h_stride = mpp_frame_get_hor_stride(mpp_frame);
                            // RK_U32 v_stride = mpp_frame_get_ver_stride(mpp_frame);

                            // cv::Mat yuv_img(height * 3 / 2, width, CV_8UC1);
                            // RK_U8 *base = (RK_U8 *)mpp_buffer_get_ptr(mpp_buffer);
                            // RK_U8 *base_c = base + h_stride * v_stride;
                            // int idx = 0;
                            // for (int i = 0; i < height; i++, base += h_stride, idx += width)
                            // {
                            //     memcpy(yuv_img.data + idx, base, width);
                            // }
                            // for (int i = 0; i < height / 2; i++, base_c += h_stride, idx += width)
                            // {
                            //     memcpy(yuv_img.data + idx, base_c, width);
                            // }

                            // (*mat) = cv::Mat(cv::Size(width, height), CV_8UC3);
                            // cv::cvtColor(yuv_img, (*mat), CV_YUV420sp2RGB);
                        }
                    }

                    frame_eos = mpp_frame_get_eos(mpp_frame);
                    mpp_frame_deinit(&mpp_frame);

                    mpp_frame = nullptr;
                    get_frm = 1;
                }

                /* 尝试获取运行时帧内存使用情况 */
                if (mpp_frame_group)
                {
                    size_t usage = mpp_buffer_group_usage(mpp_frame_group);
                    if (usage > max_usage)
                        max_usage = usage;
                }

                /* 如果发送了最后一个数据包，但没有找到最后一帧，则继续 */
                if (pkt_eos && pkt_done && !frame_eos)
                {
                    msleep(10);
                    continue;
                }

                if (frame_eos)
                {
                    qDebug("found last frame");
                    break;
                }

                if (frame_num > 0 && frame_count >= frame_num)
                {
                    eos = 1;
                    break;
                }

                if (get_frm)
                    continue;

                break;
            } while (1);

            if (frame_num > 0 && frame_count >= frame_num)
            {
                eos = 1;
                qDebug("reach max frame number %d", frame_count);
                break;
            }

            if (pkt_done)
                break;

            /*
             * why sleep here:
             * mpi->decode_put_packet will failed when packet in internal queue is
             * full,waiting the package is consumed .Usually hardware decode one
             * frame which resolution is 1080p needs 2 ms,so here we sleep 3ms
             * * is enough.
             */
            msleep(3);
        } while (1);

        mpp_packet_deinit(&mpp_packet);
#endif
    }

private:
#if USE_ALGORITHM
    size_t mpp_buffer_group_usage(MppBufferGroup group)
    {
        if (group == nullptr)
        {
            qDebug("input invalid group %p", group);
            return MPP_BUFFER_MODE_BUTT;
        }

        return ((MppBufferGroupImpl*)group)->usage;
    }

    int write_image_to_file(void* buf, const char* filename, int sw, int sh, int fmt, int index) {
        int size;
        // char filePath[100];
        // const char* outputFilePath = "%s/out%dw%d-h%d-%s.bin";

        // snprintf(filePath, 100, outputFilePath,
        //     path, index, sw, sh, translate_format_str(fmt));

        FILE* file = fopen(filename, "wb+");
        if (!file) {
            fprintf(stderr, "Could not open %s\n", filename);
            return false;
        }
        else {
            fprintf(stderr, "open %s and write ok\n", filename);
        }

        size = sw * sh * get_bpp_from_format(fmt);

        fwrite(buf, size, 1, file);

        fclose(file);

        return 0;
    }

    bool convert_to_mat(MppBuffer mpp_buffer, RK_U32 width, RK_U32 height, cv::Mat* mat)
    {
        int ret = 0;
        im_rect src_rect, dst_rect;
        rga_buffer_t src_img, dst_img;

        mat->create(cv::Size(width, height), CV_8UC3);

        memset(&src_rect, 0, sizeof(src_rect));
        memset(&dst_rect, 0, sizeof(dst_rect));
        memset(&src_img, 0, sizeof(src_img));
        memset(&dst_img, 0, sizeof(dst_img));

        src_img = wrapbuffer_virtualaddr(mpp_buffer_get_ptr(mpp_buffer), width, height, RK_FORMAT_YCbCr_420_SP);
        dst_img = wrapbuffer_virtualaddr(mat->data, width, height, RK_FORMAT_BGR_888);

        if (src_img.width == 0 || dst_img.width == 0) {
            printf("%s, %s\n", __FUNCTION__, imStrError());
            return -1;
        }
        src_img.format = RK_FORMAT_YCbCr_420_SP;
        dst_img.format = RK_FORMAT_BGR_888;
        ret = imcheck(src_img, dst_img, src_rect, dst_rect);
        if (IM_STATUS_NOERROR != ret) {
            printf("%d, check error! %s", __LINE__, imStrError((IM_STATUS)ret));
            return -1;
        }

        auto STATUS = imcvtcolor(src_img, dst_img, src_img.format, dst_img.format);

        return STATUS != IM_STATUS_SUCCESS;
    }

#endif
private:
#if USE_ALGORITHM
    MppCtx mpp_ctx;
    MppApi* mpp_mpi;
    size_t max_usage;
    RK_U32 frame_count = 0, frame_num, eos;

    /* 缓冲区管理器 */
    MppBufferGroup mpp_frame_group;
#else
    uint8_t* video_out_buffer = nullptr;
    struct SwsContext* video_sws_context = nullptr;

    AVCodecContext* video_dec_ctx = nullptr;
    AVFrame* video_dec_frame = nullptr, * video_picture_frame = nullptr;
#endif
};

#endif // HXVIDEODECODER_H