#include "FormatIn.hpp"

#include <stdexcept>
#include <unistd.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 "../data/CodedData.hpp"
#include "../data/FrameData.hpp"

#include "../../common/gpu/info.h"
#include "PsToEs.hpp"

using namespace logif;

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

	FormatIn::~FormatIn()
	{
		if(io_ctx_){
			if(read_io_buff_){
				// av_free(read_io_buff_);
				read_io_buff_ = NULL;
			}
			avio_context_free(&io_ctx_);
			io_ctx_ = NULL;
		}
		if(ctx_){
			avformat_close_input(&ctx_);
			avformat_free_context(ctx_);
			ctx_ = NULL;
			if(dec_ctx_){
				avcodec_close(dec_ctx_);
				dec_ctx_ = NULL;
			}
		}
	}

////////////////////////////////////////////////////////////////////////
	int FormatIn::openWithCustomIO(void *opaque, read_packet fn, AVDictionary **options/*=NULL*/){
		ctx_ = avformat_alloc_context();
		if(!ctx_){
			logIt("open with custom io create format error");
			return -1;
		}
		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");
			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");
			return -1;
		}
		ctx_->pb = io_ctx_;

		auto err = av_probe_input_buffer(ctx_->pb, &ctx_->iformat, NULL, NULL, 0, read_io_buff_size_);
		if(err != 0){
			logIt("open with custom io prob input buffer error:%d", err);
            logIt("failed:%s", getAVErrorDesc(err).c_str());
			return -1;
		}

		return 0;
	}

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

	    std::string fn = filename;
		addCamera(fn);

        int ret = openWithCustomIO(NULL, readData, options);
        if(ret < 0){
            logIt("do openWithCustomIO failed:%d",ret);
        }

        ret = avformat_open_input(&ctx_, "", NULL, options);
        if(ret < 0){
            logIt("open %s failed:%s",filename,
                  getAVErrorDesc(ret).c_str());

        }

		return ret;
	}

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

		const int ret = avformat_open_input(&ctx_, filename, NULL, options);
		if(ret < 0){
			logIt("open %s failed:%s",filename,
					getAVErrorDesc(ret).c_str()); 

		}

		return ret;
	}

	bool FormatIn::findStreamInfo(AVDictionary **options){

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

			return false;
		}

		for (int i = 0; i < ctx_->nb_streams; ++i)
		{
			switch(ctx_->streams[i]->codecpar->codec_type){
				case AVMEDIA_TYPE_VIDEO:
					vs_idx_ = i;
					break;

				default:
					break;
			}
		}
		return true;
	}

	bool FormatIn::openCodec(const int type, AVDictionary **options){
		int stream_index = -1;
		switch(type){
			case AVMEDIA_TYPE_VIDEO:
				stream_index = vs_idx_;
				break;
			default:
				break;
		}
		if(stream_index < 0){
			logIt("open input %s codec need correct stream",ctx_->filename); 

			return false;
		}

		AVStream *s = ctx_->streams[stream_index];

		AVCodecParameters *codecpar = s->codecpar;
		AVCodec *dec = NULL;

		bool flag = false;
		AVDictionary *avdic = NULL;

		int idle_gpu = -1;

		for (int i = 0; i < 2; ++i)
		{
			if(hw_accl_){
                idle_gpu = gpu::getGPU(100);
                if(idle_gpu < 0){
                    logIt("NO GPU RESOURCE TO DECODE");
                    hw_accl_ = false;
                    continue;
                }
				if(codecpar->codec_id == AV_CODEC_ID_H264){
            		dec = avcodec_find_decoder_by_name("h264_cuvid");
				}else if(codecpar->codec_id == AV_CODEC_ID_H265){
					dec = avcodec_find_decoder_by_name("hevc_cuvid");
				}
            	if(!dec){
            		hw_accl_ = false;
            		continue;
            	}else{
            		av_dict_set(&avdic, "gpu", std::to_string(idle_gpu).c_str(), 0);
            		// av_dict_set(&avdic, "gpu", std::to_string(2).c_str(), 0);
            	}
			}else{
            	dec = avcodec_find_decoder(codecpar->codec_id);
			}
			if(dec){
            	if(avdic){
            		options = &avdic;
					logIt("DECODE USE GPU %d", idle_gpu);
            	}
				flag = allocCodec(dec, s, options);
				if(avdic){
					av_dict_free(&avdic);
				}
				if(flag){
	            	logIt("use decoder %s\n", dec->name);
					break;
				}else{
					av_free(dec_ctx_);
					dec_ctx_ = NULL;
					hw_accl_ = false;
				}
			}
		}
        
        return flag;
	}

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

		AVCodecParameters *codecpar = s->codecpar;

		dec_ctx_ = avcodec_alloc_context3(dec);
        if (!dec_ctx_){
            logIt("avcodec_alloc_context3 error"); 
            return false;
        }
        int 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){
		return ctx_->streams[vs_idx_];
	}

	AVCodecContext *FormatIn::getCodecContext(int type){
		return dec_ctx_;
	}
	
	bool FormatIn::readPacket(AVPacket &pkt_out, int stream_index){

		bool founded = false;
		while (!founded){
			const int ret = av_read_frame(ctx_, &pkt_out);
			if(ret < 0){
				logIt("read frame from %s failed:%s",
						ctx_->filename,getAVErrorDesc(ret).c_str()); 
	
				return false;
			}
			if(pkt_out.stream_index == stream_index){
				founded = true;
			}else{
				av_free_packet(&pkt_out);
				av_init_packet(&pkt_out);
				pkt_out.data = NULL;
				pkt_out.size = 0;
			}
		}
		pkt_out.stream_index = 0;
		return true;

	}

	bool FormatIn::readPacket(std::shared_ptr<CodedData> &data, int stream_index){

		AVPacket &pkt(data->getAVPacket());
		return readPacket(pkt, getStream()->index);
	}

	int FormatIn::decode(AVFrame* &frame, AVPacket &pkt){
		
		AVStream *in = getStream();

		av_packet_rescale_ts(&pkt, in->time_base, in->codec->time_base);
        int ret = avcodec_send_packet(dec_ctx_, &pkt);
        if(ret < 0){
        	logIt("avcodec_send_packet error : %s", 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 1;
            }
        }
		return 0;
	}

	int FormatIn::decode(std::shared_ptr<FrameData> &frame_data,
					std::shared_ptr<CodedData> &data){

		AVFrame *frame = frame_data->getAVFrame();
		AVPacket &pkt(data->getAVPacket());

		return decode(frame, pkt);
	}

	int FormatIn::readFrame(AVFrame* &frame){

		auto data(std::make_shared<CodedData>());
		if(!readPacket(data)){
			return -1;
		}

		AVPacket &pkt(data->getAVPacket());

		return decode(frame, pkt);
	}

	int FormatIn::readFrame(std::shared_ptr<FrameData> &frame_data){

		AVFrame *frame(frame_data->getAVFrame());

		return readFrame(frame);
	}


}