#include "FormatIn.hpp"

#include <stdexcept>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

extern "C"{
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/pixdesc.h>
#include <libavutil/opt.h>
#include <libavutil/avassert.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}

#include "../log/log.hpp"
#include "../configure/conf.hpp"

#include "../property/VideoProp.hpp"

#include "../../common/gpu/info.h"
using namespace logif;

namespace ffwrapper{
	FormatIn::FormatIn(bool hw)
	:ctx_(NULL)
	,dec_ctx_(NULL)
	,vs_idx_(-1)
	,as_idx_(-1)
	,prop_(NULL)
	,io_ctx_(NULL)
	,read_io_buff_(NULL)
	,read_io_buff_size_(32768)
	,fps_(25.0)
	{}

	FormatIn::FormatIn(const VideoProp &prop, bool hw/*=true*/)
	:FormatIn(hw)
	{
		prop_ = new VideoProp;
		*prop_ = prop;
	}

	FormatIn::~FormatIn()
	{
		logIt("free format in");
		if (prop_) delete prop_;

		if(dec_ctx_){
			avcodec_close(dec_ctx_);
			avcodec_free_context(&dec_ctx_);
			dec_ctx_ = NULL;
		}

		if(ctx_){
			avformat_close_input(&ctx_);
			ctx_ = NULL;
		}

		if(io_ctx_){
			av_freep(&io_ctx_->buffer);
			av_freep(&io_ctx_);
			io_ctx_ = NULL;
		}
	}

	int FormatIn::openWithCustomIO(void *opaque, read_packet fn, AVDictionary **options/*=NULL*/){
		read_io_buff_ = (uint8_t*)av_malloc(read_io_buff_size_);
		if(!read_io_buff_){
			logIt("open with custom io alloc read io buff error\n");
			return -1;
		}

		io_ctx_ = avio_alloc_context(read_io_buff_, read_io_buff_size_, 0, opaque, fn, NULL, NULL);//opaque
		if(!io_ctx_){
			logIt("open with custom io create custom avio error\n");
			return -1;
		}

		ctx_ = avformat_alloc_context();
		if(!ctx_){
			logIt("open with custom io create format error\n");
			return -1;
		}

		ctx_->pb = io_ctx_;

		return 0;
	}

	int FormatIn::open(const char *filename, AVDictionary **options){

		int ret = avformat_open_input(&ctx_, filename, NULL, options);

		ret = avformat_find_stream_info(ctx_, options);
		if(ret < 0){
			logIt("find %s stream info failed:%s",
					ctx_->filename,getAVErrorDesc(ret).c_str());
			return ret;
		}

		for (int i = 0; i < ctx_->nb_streams; ++i)
		{
			auto type = ctx_->streams[i]->codecpar->codec_type;
			logIt("there are %d stream, stream %d, type %d", ctx_->nb_streams, i, type);

			if (type == AVMEDIA_TYPE_VIDEO){
				vs_idx_ = i;

				auto in = ctx_->streams[i];
				if(in->r_frame_rate.num >=1 && in->r_frame_rate.den >= 1){
            	    fps_ = av_q2d(in->r_frame_rate);
            	}else if(in->avg_frame_rate.num >=1 && in->avg_frame_rate.den >= 1){
            	    fps_ = av_q2d(in->avg_frame_rate);
            	}
				logIt("in stream video fps %f, time_base: %d:%d, size: %dx%d", fps_, in->time_base.num, in->time_base.den, in->codecpar->width, in->codecpar->height);
			}
			if (type == AVMEDIA_TYPE_AUDIO){
				auto in = ctx_->streams[i];
				logIt("in stream audio %d time_base: %d:%d", in->codecpar->codec_id, in->time_base.num, in->time_base.den);
				if (in->codecpar->codec_id == AV_CODEC_ID_AAC)
					as_idx_ = i;
				else
					logIt("record not support audio codec: %d", in->codecpar->codec_id);
			}
		}

		return 0;
	}

	const bool FormatIn::IsHEVC()const{
		return ctx_->streams[vs_idx_]->codecpar->codec_id == AV_CODEC_ID_HEVC;
	}

	const bool FormatIn::IsAVC1()const{
		if (IsHEVC()) return false;

		char p[100] = {0};
		char *sub = av_fourcc_make_string(p, ctx_->streams[vs_idx_]->codecpar->codec_tag);
		const int ret = strcmp(sub, "avc1");
		if (ret == 0) return true;
		return false;
	}

	bool FormatIn::openCodec(AVDictionary **options){
		if (dec_ctx_) return true;
		if (vs_idx_ == -1) return false;

		AVStream *s = ctx_->streams[vs_idx_];
		AVCodecParameters *codecpar = s->codecpar;

		bool flag = false;

        AVCodecID codec_id = codecpar->codec_id;

        AVCodec *dec = avcodec_find_decoder(codec_id);

		if(dec){
			flag = allocCodec(dec, s, options);
			if(*options){
				av_dict_free(options);
			}
			if(!flag){
				av_free(dec_ctx_);
				dec_ctx_ = NULL;
			}

	        logIt("use decoder %s\n", dec->name);
		}

        return flag;
	}

	bool FormatIn::allocCodec(AVCodec *dec, AVStream *s, AVDictionary **options){

		AVCodecParameters *codecpar = NULL;
		if(s) codecpar = s->codecpar;

		dec_ctx_ = avcodec_alloc_context3(dec);
        if (!dec_ctx_){
            logIt("avcodec_alloc_context3 error"); 
            return false;
        }
        int ret = 0;
        if(s && codecpar) {
        	ret = avcodec_parameters_to_context(dec_ctx_, codecpar);
        	if(ret < 0) {
        	    logIt("avcodec_parameters_to_context error : %s", getAVErrorDesc(ret).c_str());
        	    return false;
        	}
        	av_codec_set_pkt_timebase(dec_ctx_, s->time_base);
        	dec_ctx_->framerate = av_guess_frame_rate(ctx_, s, NULL);
        }

        dec_ctx_->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
		ret = avcodec_open2(dec_ctx_,dec, options);
		if(ret < 0){
			logIt("open input %s codec failed:%s",
					ctx_->filename,getAVErrorDesc(ret).c_str()); 
			return false;
		}
		return true;
	}

	AVStream *FormatIn::getStream(int type/*=-1*/){
		if (vs_idx_ < 0 || !ctx_ || ctx_->nb_streams == 0 || !ctx_->streams) return NULL;

		if (type == -1){
			return ctx_->streams[vs_idx_];
		}

		if (vs_idx_ > -1 && type == ctx_->streams[vs_idx_]->codecpar->codec_type)
			return ctx_->streams[vs_idx_];
		if (as_idx_ > -1 && type == ctx_->streams[as_idx_]->codecpar->codec_type)
			return ctx_->streams[as_idx_];

		return NULL;
	}

	AVCodecContext *FormatIn::getCodecContext(int type){
		return dec_ctx_;
	}
	
	bool FormatIn::isVideoPkt(AVPacket *pkt){
		if (pkt->stream_index == vs_idx_){
			return true;
		}
		return false;
	}

	bool FormatIn::isAudioPkt(AVPacket *pkt){
		if (pkt->stream_index == as_idx_){
			return true;
		}
		return false;
	}

	bool FormatIn::notVideoAudio(AVPacket *pkt){
		return !isVideoPkt(pkt) && !isAudioPkt(pkt);
	}
	
	int FormatIn::readPacket(AVPacket *pkt_out){
		auto flag = av_read_frame(ctx_, pkt_out);
		if (flag < 0)
			logIt("======>> av_read_frame error %s", getAVErrorDesc(flag).c_str());
		return flag;
	}

	int FormatIn::decode(AVFrame* frame, AVPacket *pkt){
		
		AVStream *in = getStream();
		if (in){
			av_packet_rescale_ts(pkt, in->time_base, in->codec->time_base);
		}
        int ret = avcodec_send_packet(dec_ctx_, pkt);
        if(ret < 0){
        	logIt("pkt size %d avcodec_send_packet error : %s", pkt->size, getAVErrorDesc(ret).c_str());
        	return -1;
        }
        while (ret >= 0) {
            ret = avcodec_receive_frame(dec_ctx_, frame);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            	break;
            } else if (ret < 0) {
				logIt("decode frame failed : %s", getAVErrorDesc(ret).c_str()); 
                return -1;
            }else{
            	return 0;
            }
        }
		return -2;
	}

//////////////////////////////////////////////////////////////////////
	constexpr int bs = 8192;
	FormatInGB::FormatInGB()
	:FormatIn()
	,gb28181_(NULL)
	,parser_ctx_(NULL)
	,buffer_(NULL)
	,buffer_size_(bs)
	{
		buffer_ = (unsigned char*)malloc(buffer_size_);
	}

	FormatInGB::FormatInGB(const VideoProp &prop)
	:FormatInGB()
	{
		prop_ = new VideoProp;
		*prop_ = prop;
	}

	FormatInGB::~FormatInGB(){
		if (parser_ctx_){
			av_parser_close(parser_ctx_);
		}
		if (gb28181_)delete gb28181_;
		if (buffer_) free(buffer_);

		for(auto &pkt : q_pkt_){
			av_packet_free(&pkt);
		}
		q_pkt_.clear();
	}

	static enum AVCodecID codecMap(const int c){
		switch (c) {
		case E_VIDEO_STREAM_H264://     = 0,
			return AV_CODEC_ID_H264;
    	case E_VIDEO_STREAM_MPEG2://    = 1,    // MPEG4
    		// return AV_CODEC_ID_MPEG2VIDEO;
    	case E_VIDEO_STREAM_MPEG4://    = 2,    // MPEG4
    		return AV_CODEC_ID_MPEG4;
    	case E_VIDEO_STREAM_SVAC://     = 3,    // SVAC
    		return AV_CODEC_ID_NONE;
    	case E_VIDEO_STREAM_3GP://      = 4,    // 3GP
    		return AV_CODEC_ID_NONE;			// audio
    	case E_VIDEO_STREAM_H265://     = 5,    //H265
    		return AV_CODEC_ID_HEVC;
		default:
			break;
		}
		return AV_CODEC_ID_NONE;
	}

	int FormatInGB::open(const char *filename, AVDictionary **options){
		if (gb28181_){
			delete gb28181_;
		}

		gb28181_ = new GB28181API;
		std::string fn = filename;

		if(gb28181_->addCamera(fn) < 0){
			delete gb28181_;
			gb28181_ = NULL;
			logIt("do addCamera Error\n");
			return -1;
		}
		for(int i = 0; i < 6; i++){
			if (gb28181_->getDataType() >= 0){
				AVCodecID id = codecMap(gb28181_->getDataType());
				logIt("======>>codec name %s\n", avcodec_get_name(id));
				parser_ctx_ = av_parser_init(id);
				if (parser_ctx_) parser_ctx_->flags |= PARSER_FLAG_USE_CODEC_TS;
				AVCodec* dec = avcodec_find_decoder(id);
				allocCodec(dec, NULL, NULL);
				break;
			}
			usleep(1000000);
		}
		return 0;
	}

	int FormatInGB::readPacket(AVPacket *pkt_out){
		if (!q_pkt_.empty()){
			auto pkt = q_pkt_.front();
			q_pkt_.pop_front();
			av_packet_ref(pkt_out, pkt);
			av_packet_free(&pkt);
			return 0;
		}

		if (gb28181_->getDataType() < 0){
			logIt("======>> readPacket can't recv gb28181 stream");
			return 1;
		}
		if (!parser_ctx_){
			AVCodecID id = codecMap(gb28181_->getDataType());
			parser_ctx_ = av_parser_init(id);
			AVCodec* dec = avcodec_find_decoder(id);
			allocCodec(dec, NULL, NULL);
		}
		if (parser_ctx_ && dec_ctx_){

			int try_run = 0;
			AVPacket* pkt = av_packet_alloc();
			bool got_pkt = false;

			while (true) {
				int data_size = gb28181_->readData(gb28181_, buffer_, buffer_size_);
				// printf("======>> data_size %d pos %d\n", data_size, buffer_pos_);
				if (data_size == 0){
					try_run ++;
					if (try_run > 12){
						av_packet_free(&pkt);
						logIt("gb28181_ readData %d failed, return -1", try_run);
						return -1;
					}
					continue;
				}
				try_run = 0;
				unsigned char* data = buffer_;
				while (data_size > 0) {
					int ret = av_parser_parse2(parser_ctx_, dec_ctx_,
						&pkt->data, &pkt->size, data, data_size,
						AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);

					// logIt("======>> av_parser_parse2 ret %d pkt size %d", ret, pkt->size);
					if (ret < 0) {
						av_packet_free(&pkt);
						logIt("======>> av_parser_parse2 error %d %s", ret, getAVErrorDesc(ret).c_str());
						return ret;
					}

					data += ret;
					data_size -= ret;

					if (pkt->size){
						if(fps_ == 0 && dec_ctx_->framerate.den > 0 && dec_ctx_->framerate.num > 0){
							fps_ = dec_ctx_->framerate.num/dec_ctx_->framerate.den;
							if (fps_ == 0) fps_ = 24;
						}
						if (parser_ctx_->key_frame == 1){
							pkt->flags |= AV_PKT_FLAG_KEY;
						}
						got_pkt = true;
						AVPacket* tmpkt = av_packet_alloc();
						av_packet_ref(tmpkt, pkt);
						q_pkt_.push_back(tmpkt);
					}
				}
				if (got_pkt) {
					av_packet_free(&pkt);
					auto tmpkt = q_pkt_.front();
					q_pkt_.pop_front();
					av_packet_ref(pkt_out, tmpkt);
					av_packet_free(&tmpkt);
					return 0;
				}
			}
		}
		return -1;
	}

	const bool FormatInGB::IsHEVC()const{
		if (!gb28181_) return false;
		return codecMap(gb28181_->getDataType()) == AV_CODEC_ID_HEVC;
	}

	const bool FormatInGB::IsAVC1()const{
		return false;
	}

	bool FormatInGB::isVideoPkt(AVPacket *pkt) {
		return true;
	}
	bool FormatInGB::isAudioPkt(AVPacket *pkt) {
		return false;
	}

}