#include "fm_video_edit.h"
#if (FM_VIDEO_EDIT)

#if (USE_LIB_MP4V2)
#include "mp4v2.h"
#else
#ifdef __cplusplus
extern "C"
{
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
}
#endif // extern C
#endif //USE_LIB_MP4V2

#define MAX_VIDEO_STREAM_COUNT 10


FMVideoEdit::FMVideoEdit(QStringList files, QStringList dests, EditMode mode, bool deleteSrcDone)
{
    _files = files;
    _dests = dests;
    _mode = mode;
    _deleteSrcAfter = deleteSrcDone;
}

void FMVideoEdit::run()
{
    _splitMP4VideoTracks();
}

int _find_video_stream_index(int stream_id, int *streams) {
    for(int i=0;i<MAX_VIDEO_STREAM_COUNT;i++) {
        if(stream_id == streams[i]) {
            return i;
        }
    }
    return -1;
}
void _clean_output_contexts(AVFormatContext** ctxs) {
    for(int i=0;i<MAX_VIDEO_STREAM_COUNT;i++) {
        if (ctxs[i] != NULL) {
            avformat_free_context(ctxs[i]);
        }
    }
}

void FMVideoEdit::_splitMP4VideoTracks()
{
    QString src = _files.first();

    AVFormatContext *input_ctx = NULL;

    int video_stream_index[MAX_VIDEO_STREAM_COUNT]          = {-1,};
    bool video_stream_validation[MAX_VIDEO_STREAM_COUNT]    = {true,}; // 정상 Video Stream 확인

    int video_stream_count = 0;
    int real_video_stream_count = 0;    // 실제 비디오 스트림 개수
    int audio_stream_index = -1;        // Audio 가 존재하지 않을 경우 stream index 를 2가 아닌 1로 작성하기 위해 사용
    int video_frame_count = -1;         // Progress 처리하기 위해 사용

    // 입력 파일 열기
    if (avformat_open_input(&input_ctx, src.toUtf8().constData(), NULL, NULL) < 0) {
        emit done(ErrorFileOpen);
        return;
    }

    // 메타 정보 확인
    // major_brand : isom
    // minor_version : 512
    // compatible_brands : isomiso2avc1mp41
    /*
    AVDictionaryEntry *tag = NULL;
    while ((tag = av_dict_get(input_ctx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
        qInfo() << tag->key << ":" << tag->value << __FUNCTION__;
    }
    */

    // 스트림 정보 읽기
    if (avformat_find_stream_info(input_ctx, NULL) < 0) {
        emit done(ErrorOpenStream);
        avformat_close_input(&input_ctx);
        return;
    }
    // 각 비디오 스트림 + 오디오/자막 스트림 인덱스 확인
    for (unsigned int i = 0; i < input_ctx->nb_streams; i++) {
        AVMediaType type = input_ctx->streams[i]->codecpar->codec_type;
        if (type == AVMEDIA_TYPE_VIDEO) {

            // 프레임이 없는 N 번째 영상 스트림 제거
            video_stream_validation[i] = (input_ctx->streams[i]->nb_frames > 0);
            //            if(input_ctx->streams[i]->nb_frames == 0) {
            //                video_stream_validation[i] = false;
            //            }
            if(video_stream_validation[i])
            {
                real_video_stream_count += 1;
            }

            // Progress 처리하기 위해
            if(video_frame_count < 0) {
                video_frame_count = input_ctx->streams[i]->nb_frames;
            }
            //            AVStream* ps =  input_ctx->streams[i];
            //            qInfo() << "VSTREAM:" << i << ps->discard << __FUNCTION__;
            video_stream_index[video_stream_count] = i;
            video_stream_count++;
        } else if (type == AVMEDIA_TYPE_AUDIO) {
            audio_stream_index = i;
        } //else if (type == AVMEDIA_TYPE_SUBTITLE) {
        //    subtitle_stream_index = i;
        //}
    }


    // 실제 영상 스트림이 출력 개수보다 많을 경우에만 처리
    //video_stream_count = 2;
    if(real_video_stream_count > _dests.size()) {
        emit done(ErrorWrongTrackCount);
        avformat_close_input(&input_ctx);
        return;
    }

    // 한번에 모든 패킷을 여러 파일에 저장하기 위해 동시 생성
    AVFormatContext *output_ctx[MAX_VIDEO_STREAM_COUNT]     = {NULL,};
    AVStream *out_video_stream[MAX_VIDEO_STREAM_COUNT]      = {NULL,};
    AVStream *out_audio_stream[MAX_VIDEO_STREAM_COUNT]      = {NULL,};
    AVStream *out_subtitle_stream[MAX_VIDEO_STREAM_COUNT]   = {NULL,};

    for(int s=0;s<video_stream_count;s++) {

        // 프레임 없는 영상 스트림 SKIP
        if(!video_stream_validation[s]) {
            continue;
        }
        // 복사할 비디오 스트림 인덱스
        // int current_video_stream = video_stream_index[s];

        // 출력 파일 생성
        //AVFormatContext *output_ctx = NULL;
        QString destString = _dests.at(s);
        char dest[4096] = {0,};
        memcpy(dest,destString.toUtf8().constData(),destString.toUtf8().length());
        // MP4는 PCM 데이터를 저장하지 못하므로 확장자는 MP4 이나 강제로 MOV 포멧으로 지정
        avformat_alloc_output_context2(&output_ctx[s], NULL, "mov", dest);

        if (!output_ctx[s]) {
            emit done(ErrorFileCreate);
            avformat_close_input(&input_ctx);
            _clean_output_contexts(output_ctx);
            return;
        }

        // 비디오 스트림 생성
        out_video_stream[s] = avformat_new_stream(output_ctx[s], NULL);
        if (!out_video_stream[s]) {
            emit done(ErrorCreateStream);
            _clean_output_contexts(output_ctx);
            avformat_close_input(&input_ctx);
            return;
        }

        // 스트림 파라미터 복사
        int ret = avcodec_parameters_copy(out_video_stream[s]->codecpar, input_ctx->streams[video_stream_index[s]]->codecpar);
        if (ret < 0) {
            emit done(ErrorCopyStreamParameters);
            _clean_output_contexts(output_ctx);
            avformat_close_input(&input_ctx);
            return;
        }
        out_video_stream[s]->codecpar->codec_tag = 0;

        // 나머지 스트림들 복사
        for (unsigned int i = 0; i < input_ctx->nb_streams; i++) {
            AVMediaType type = input_ctx->streams[i]->codecpar->codec_type;
            if (type == AVMEDIA_TYPE_AUDIO) {
                out_audio_stream[s] = avformat_new_stream(output_ctx[s], NULL);
                if (!out_audio_stream[s]) {
                    emit done(ErrorCreateStream);
                    _clean_output_contexts(output_ctx);
                    avformat_close_input(&input_ctx);
                    return;
                }
                ret = avcodec_parameters_copy(out_audio_stream[s]->codecpar, input_ctx->streams[i]->codecpar);
                if (ret < 0) {
                    emit done(ErrorCopyStreamParameters);
                    _clean_output_contexts(output_ctx);
                    avformat_close_input(&input_ctx);
                    return;
                }
                out_audio_stream[s]->codecpar->codec_tag = 0;
            }
            // 자막 스트림 복사
            if (type == AVMEDIA_TYPE_SUBTITLE) {
                out_subtitle_stream[s] = avformat_new_stream(output_ctx[s], NULL);
                if (!out_subtitle_stream[s]) {
                    emit done(ErrorCreateStream);
                    _clean_output_contexts(output_ctx);
                    avformat_close_input(&input_ctx);
                    return;
                }
                ret = avcodec_parameters_copy(out_subtitle_stream[s]->codecpar, input_ctx->streams[i]->codecpar);
                if (ret < 0) {
                    emit done(ErrorCopyStreamParameters);
                    _clean_output_contexts(output_ctx);
                    avformat_close_input(&input_ctx);
                    return;
                }
                out_subtitle_stream[s]->codecpar->codec_tag = 0;
            }
        } // 나머지 스트림 복사

        // 출력 파일 헤더 쓰기
        av_dump_format(output_ctx[s], 0, dest, 1);



        if (!(output_ctx[s]->oformat->flags & AVFMT_NOFILE)) {
            if (avio_open(&output_ctx[s]->pb, dest, AVIO_FLAG_WRITE) < 0) {
                emit done(ErrorFileWrite);
                _clean_output_contexts(output_ctx);
                avformat_close_input(&input_ctx);
                return;
            }
        }

        // major_brand를 'isom'으로 설정
        // AVDictionary *options = NULL;
        // av_dict_set(&options, "major_brand", "isom", 0);
        // av_dict_set(&options, "compatible_brands", "isomiso2avc1mp41", 0);
        //&options
        int res = avformat_write_header(output_ctx[s], NULL); // &options
        if (res < 0)
        {
            //char ebuffer[1024] = {0,};
            //av_strerror(res,ebuffer,1024);
            qInfo() << "VIDEO STREAM:" << s  << " HEADER WRITE ERROR" << __FUNCTION__;
            emit done(ErrorFileWrite);
            _clean_output_contexts(output_ctx);
            avformat_close_input(&input_ctx);
            // av_dict_free(&options);
            return;
        }
    } // 파일 생성 및 스트림 정보 복사

    // 패킷 복사
    AVPacket packet;

    // for 문으로 처리시 처음으로 다시 돌아가는 기능 필요...
    // av_seek_frame(input_ctx, -1, 0, AVSEEK_FLAG_BACKWARD);

    int frame_processed = 0; // Progress 처리
    while (av_read_frame(input_ctx, &packet) >= 0) {
        AVMediaType type = input_ctx->streams[packet.stream_index]->codecpar->codec_type;

        // 입력 스트림과 출력 스트림의 타임베이스 정보를 가져옵니다.
        const AVRational& in_time_base = input_ctx->streams[packet.stream_index]->time_base;

        if(type == AVMEDIA_TYPE_VIDEO) {

            // video 순서 index 확인
            int vindex = _find_video_stream_index(packet.stream_index,video_stream_index);
            if(!video_stream_validation[vindex]) {
                continue;
            }

            // 시간계산 비디오 스트림 인덱스는 무조건 0
            const AVRational& out_time_base = output_ctx[vindex]->streams[0]->time_base;

            // 모든 패킷 RESCALE 하지 않으면 재생시간 짧아짐
            packet.pts = av_rescale_q(packet.pts, in_time_base, out_time_base);
            packet.dts = av_rescale_q(packet.dts, in_time_base, out_time_base);
            packet.duration = av_rescale_q(packet.duration, in_time_base, out_time_base);

            packet.stream_index = 0; // 출력 비디오 스트림 인덱스
            av_interleaved_write_frame(output_ctx[vindex], &packet);
            if(vindex == 0 && video_frame_count > 0) {
                frame_processed++;
                int percent = int (((double)frame_processed) /  ((double)video_frame_count) * 100.0);
                emit progress(percent);
                //qInfo() << progress << __FUNCTION__;
            }
        } else if (type == AVMEDIA_TYPE_AUDIO) {


            // 패킷을 여러번 쓰기 위해서는 av_packet_clone 해서 처리해야함..
            for(int s=0;s<video_stream_count;s++) { // 모든 파일에 오디오 패킷 쓰기
                if(!video_stream_validation[s]) { // invalid video 스트림 SKIP
                    continue;
                }

                // 패킷 시간 RESCALE 처리해아함 // AUDIO STREAM INDEX 는 무조건 1
                const AVRational& out_time_base = output_ctx[s]->streams[1]->time_base;

                AVPacket* cp = av_packet_clone(&packet);

                // 모든 패킷 RESCALE 하지 않으면 재생시간 짧아짐
                cp->pts = av_rescale_q(cp->pts, in_time_base, out_time_base);
                cp->dts = av_rescale_q(cp->dts, in_time_base, out_time_base);
                cp->duration = av_rescale_q(cp->duration, in_time_base, out_time_base);

                cp->stream_index = 1; //출력 오디오 스트림 인덱스
                av_interleaved_write_frame(output_ctx[s], cp);
                av_packet_free(&cp);
            }
        } else if (type == AVMEDIA_TYPE_SUBTITLE) {
            // AUDIO 가 존재하지 않을경우 1 존재할 경우 2
            const int subtitle_stream_index = audio_stream_index >= 0 ? 2 : 1;


            for(int s=0;s<video_stream_count;s++) { // 모든 파일에 자막 패킷 쓰기
                if(!video_stream_validation[s]) {   // invalid video 스트림 SKIP
                    continue;
                }

                // 패킷 시간 RESCALE 처리해아함
                const AVRational& out_time_base = output_ctx[s]->streams[subtitle_stream_index]->time_base;

                AVPacket* cp = av_packet_clone(&packet);
                // 모든 패킷 RESCALE 하지 않으면 재생시간 짧아짐 for 에서 누적되니 신규 packet 에만 처리
                cp->pts = av_rescale_q(cp->pts, in_time_base, out_time_base);
                cp->dts = av_rescale_q(cp->dts, in_time_base, out_time_base);
                cp->duration = av_rescale_q(cp->duration, in_time_base, out_time_base);


                cp->stream_index = subtitle_stream_index;
                av_interleaved_write_frame(output_ctx[s], cp);
                av_packet_free(&cp);
            }
        }
        av_packet_unref(&packet);
    }

    for(int s=0;s<video_stream_count;s++) {
        if(!video_stream_validation[s]) { // invalid video 스트림 파일 SKIP
            continue;
        }
        // 트레일러 쓰기 및 파일 닫기
        av_write_trailer(output_ctx[s]);

        if (!(output_ctx[s]->oformat->flags & AVFMT_NOFILE)) {
            avio_closep(&output_ctx[s]->pb);
        }
        //av_dict_free(&options);
        avformat_free_context(output_ctx[s]);
    }
    avformat_close_input(&input_ctx);

    _afterProcess();
    emit done(ErrorNone);
}
void FMVideoEdit::_afterProcess()
{
    if(_deleteSrcAfter) {
        for(int i=0;i<_files.size();i++) {
            QFile(_files.at(i)).remove();
            qInfo() << "DELETE:" << _files.at(i) << __FUNCTION__;
        }
    }
}
#if (USE_LIB_MP4V2)
void FMVideoEdit::_splitVideoTracks()
{
    QString src = _files.first();

    /* 최적화 하여 마지막 이상한 atom 제거해도 수정이 안됨
    QFileInfo fi = QFileInfo(src2);
    QString src = QDir::cleanPath(fi.dir().path() + QDir::separator() + fi.baseName() + "_2.mp4");
    if(!MP4Optimize(src2.toLocal8Bit().data(),src.toLocal8Bit().data())) {
        //qInfo() << "OPTIMIZE FAILED.." << __FUNCTION__;
        return;
    } */

    MP4FileHandle inputFile = MP4Read(src.toLocal8Bit().data());
    if(MP4_INVALID_FILE_HANDLE == inputFile) {
        emit done(ErrorFileOpen);
        return;
    }

    uint32_t numTrack = MP4GetNumberOfTracks(inputFile,NULL,0);
    //qInfo() << QString(MP4Info(mp4File)) << __FUNCTION__;
    qInfo() << "numTrack" << numTrack << __FUNCTION__;
    QList<MP4TrackId> videoTracks = QList<MP4TrackId>();
    QList<MP4TrackId> otherTracks = QList<MP4TrackId>(); // 영상을 제외한 트랙들
    for(uint32_t i=0;i<numTrack;i++) {
        MP4TrackId tid = MP4FindTrackId (inputFile, i, NULL,0);
        const char* type = MP4GetTrackType(inputFile,tid);
        if(strcmp(type,MP4_VIDEO_TRACK_TYPE) == 0) {
            videoTracks.append(tid);
            qInfo() << "TRACK:" << i << " ID:" << tid << " TYPE:" << type << __FUNCTION__;
        } else if (strcmp(type,MP4_AUDIO_TRACK_TYPE) != 0) { // else { //
            // 오디오 트랙만 처리하면 atom size 에러가 발생함...
            otherTracks.append(tid);
            qInfo() << "OTHER TRACK:" << i << " ID:" << tid << " TYPE:" << type << __FUNCTION__;
        }
    }
    if(videoTracks.size() != _dests.size()) {
        emit done(ErrorWrongTrackCount);
        MP4Close(inputFile);
    }
    for(int i=0;i<_dests.size();i++) {
        QString dest = _dests.at(i);
        MP4FileHandle outputFile = MP4Create(dest.toLocal8Bit().data());
        if (outputFile == MP4_INVALID_FILE_HANDLE) {
            emit done(ErrorFileCreate);
            MP4Close(inputFile);
            return;
        }

        // 입력 파일의 일반적인 정보를 출력 파일에 복사
        MP4SetTimeScale(outputFile, MP4GetTimeScale(inputFile));

        QList<MP4TrackId> cloneTracks = QList<MP4TrackId>();
        cloneTracks.append(videoTracks.at(i));  // 영상 트랙
        cloneTracks.append(otherTracks);        // 나머지 트랙(자막,메타,음성)
        qInfo() << "cloneTracks:" << cloneTracks << __FUNCTION__;

        // 트랙 복제
        for (int j=0;j<cloneTracks.size();j++) {

            MP4TrackId srcID = cloneTracks.at(j);
            MP4TrackId outputVideoTrackId = MP4CloneTrack(inputFile, srcID, outputFile);
            qInfo() << "CLONE TRACK SRC:" << srcID << " OUT:" << outputVideoTrackId << __FUNCTION__;
            if (outputVideoTrackId == MP4_INVALID_TRACK_ID) {
                MP4Close(inputFile);
                MP4Close(outputFile);
                emit done(ErrorTrackClone);
                return;
            }

            // 샘플 복사
            uint32_t sampleId = 1;
            MP4SampleId sampleCount = MP4GetTrackNumberOfSamples(inputFile, srcID);
            while (sampleId <= sampleCount) {
                uint8_t* sampleData = nullptr;
                uint32_t sampleSize = 0;
                MP4Timestamp  startTime = 0;
                MP4Duration  sampleDuration = 0;
                if (MP4ReadSample(inputFile, srcID, sampleId, &sampleData, &sampleSize,&startTime, &sampleDuration)) {
                    if (!MP4WriteSample(outputFile, outputVideoTrackId, sampleData, sampleSize, sampleDuration)) {
                        emit done(ErrorWriteSample);
                        MP4Free(sampleData);
                        break;
                    }
                    MP4Free(sampleData);
                } else {
                    emit done(ErrorReadSample);
                    break;
                }
                sampleId++;
            }
        } // 각 트랙 복사
        MP4Close(outputFile);
    }
    MP4Close(inputFile);
}
#endif // #if (USE_LIB_MP4V2)

#endif // #if (FM_VIDEO_EDIT)