#ifndef _cffmpeg_buz_recorder_hpp_
#define _cffmpeg_buz_recorder_hpp_

#include <stdint.h>
#include <string>
#include <list>
#include <memory>

#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>

#include "../common/callback.hpp"

#include "../common.hpp"

struct AVPacket;

namespace ffwrapper{
    class FormatIn;
    class FormatOut;
}

namespace cffmpeg_wrap{
    namespace buz{

        class Recorder{
            public:
                Recorder(ffwrapper::FormatIn *in, const std::string &id);
                ~Recorder();

            public: 
                int Run(const char* output, const int mind, const int maxd, const bool audio);
                int PushPacket(std::list<CPacket> &lst);
                int StartWritePacket(std::list<CPacket> &lst, const int64_t &id, const int start, const int end);
                int FireRecorder(const int64_t &id);

                void SetCallback(FUNC_REC_INFO cb){
                    func_rec_info_ = cb;
                }

                const bool ErrorOcurred(){return error_occured_;}
                const std::string& RecID()const{return id_;}
            private:
                void run_thread();

                int init_writer(const bool audio);
                int write_correctly(const CPacket &pkt);
                void end_writer();

                void maybe_dump_gop();

                int init_write_h264(const bool audio);
                int write_h264(const CPacket &pkt);
                int end_write_h264();

                int init_write_hevc(const bool audio);
                int write_hevc(const CPacket &pkt);
                int end_write_hevc();
                int mux_hevc(FILE *fp, const char *outfile);
            private: 
                ffwrapper::FormatIn     *in_;
                ffwrapper::FormatOut    *out_;

                std::list<CPacket>      list_pkt_;
                std::atomic_bool        stop_recorder_;
                std::mutex              mutex_pkt_;
     		    std::condition_variable cv_;
                std::string             dir_;
                std::string             id_;
                int64_t                 id_frame_;
                int                     id_frame_in_file_;

                std::string             file_path_;
                FUNC_REC_INFO           func_rec_info_;
                FILE                    *fp_;
                bool                    audio_;

                std::unique_ptr<std::thread> thrd_;


                int     end_frame_;
                int     v_cur_frame_;
                int     a_cur_frame_;
                
                int64_t last_rec_id_;

                int     maxduration;
                int     minduration;

                bool                    error_occured_;
        };
    }
}

#endif