#ifndef AV_BASE_TYPES_H
#define AV_BASE_TYPES_H

#include <memory>
#include <string>
#include <functional>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <chrono>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
}

namespace av {

// 媒体类型枚举
enum class MediaType {
    UNKNOWN,
    AUDIO,
    VIDEO
};

// 编解码参数结构
struct CodecParams {
    // 通用参数
    MediaType type;
    std::string codecName;
    int bitRate = 0;
    
    // 视频参数
    int width = 0;
    int height = 0;
    int fps = 0;
    AVPixelFormat pixelFormat = AV_PIX_FMT_NONE;
    
    // 音频参数
    int sampleRate = 0;
    int channels = 0;
    AVSampleFormat sampleFormat = AV_SAMPLE_FMT_NONE;
};

// 音频数据结构
struct AudioData {
    uint8_t* data = nullptr;
    int size = 0;
    int sampleRate = 0;
    int channels = 0;
    AVSampleFormat format = AV_SAMPLE_FMT_NONE;
    int64_t pts = 0;
};

// 视频帧数据结构
struct VideoFrame {
    uint8_t* data[4] = {nullptr};
    int linesize[4] = {0};
    int width = 0;
    int height = 0;
    AVPixelFormat format = AV_PIX_FMT_NONE;
    int64_t pts = 0;
};

// 错误码定义
enum class ErrorCode {
    // 成功状态
    SUCCESS = 0,
    
    // 参数错误
    INVALID_PARAMS,
    INVALID_PATH,
    
    // 编解码错误
    CODEC_NOT_FOUND,
    CODEC_OPEN_FAILED,
    ENCODE_FAILED,
    DECODE_FAILED,
    
    // 内存错误
    MEMORY_ALLOC_FAILED,
    
    // 文件操作错误
    FILE_OPEN_FAILED,
    FILE_EXISTS,
    FILE_OPERATION_FAILED,
    
    // 状态错误
    INVALID_STATE,
    NOT_STARTED,
    NOT_PAUSED,
    ALREADY_INITIALIZED,
    NOT_INITIALIZED,
    ALREADY_STARTED,
    ALREADY_PAUSED,
    
    // 格式和转换错误
    CONVERSION_FAILED,
    FORMAT_NOT_SUPPORTED,
    NOT_SUPPORTED,
    
    // 硬件和设备错误
    HARDWARE_ERROR,
    DEVICE_NOT_FOUND,
    
    // 流操作错误
    STREAM_NOT_FOUND,
    STREAM_EXISTS,
    STREAM_CREATE_FAILED,
    END_OF_STREAM,
    
    // 线程和队列错误
    THREAD_ERROR,
    QUEUE_FULL,
    
    // 同步错误
    SYNC_ERROR,
    
    // 通用错误
    ALREADY_EXISTS,
    NOT_FOUND,
    TIMEOUT,
    COPY_FAILED,
    PROCESSING_ERROR,
    INITIALIZATION_FAILED,
    OPERATION_FAILED,
    UNKNOWN_ERROR
};

// AVResult 类型别名（用于兼容）
using AVResult = ErrorCode;

// 常用结果常量
const AVResult AV_OK = AVResult::SUCCESS;

// 智能指针类型定义
// 自定义删除器用于AVFrame
struct AVFrameDeleter
{
    void operator()(AVFrame* frame)
    {
        if (frame) {
            // 添加调试信息，帮助追踪重复释放问题
#ifdef DEBUG
            // 检查帧指针的有效性
            if (frame->data && frame->data[0]) {
                // 帧看起来正常
            } else {
                // 帧可能已经被释放或损坏
                fprintf(stderr, "Warning: AVFrameDeleter called on potentially corrupted frame\n");
            }
#endif
            av_frame_free(&frame);
        }
    }
};

using AVFramePtr = std::unique_ptr<AVFrame, AVFrameDeleter>;

// 自定义删除器用于AVPacket
struct AVPacketDeleter
{
    void operator()(AVPacket* pkt) { av_packet_free(&pkt); }
};
using AVPacketPtr = std::unique_ptr<AVPacket, AVPacketDeleter>;

// 回调函数类型定义 - 统一使用智能指针
using FrameCallback = std::function<void(const AVFramePtr&)>;
using PacketCallback = std::function<void(const AVPacketPtr&)>;
using ErrorCallback = std::function<void(ErrorCode, const std::string&)>;


// 自定义删除器用于AVCodecContext
struct AVCodecContextDeleter {
    void operator()(AVCodecContext* ctx) {
        avcodec_free_context(&ctx);
    }
};
using AVCodecContextPtr = std::unique_ptr<AVCodecContext, AVCodecContextDeleter>;

// 自定义删除器用于AVFormatContext
struct AVFormatContextDeleter {
    void operator()(AVFormatContext* ctx) {
        avformat_free_context(ctx);
    }
};
using AVFormatContextPtr = std::unique_ptr<AVFormatContext, AVFormatContextDeleter>;

// 智能指针创建函数
inline AVFramePtr makeAVFrame() {
    return AVFramePtr(av_frame_alloc());
}

inline AVPacketPtr makeAVPacket() {
    return AVPacketPtr(av_packet_alloc());
}

inline AVCodecContextPtr makeAVCodecContext(const AVCodec* codec) {
    return AVCodecContextPtr(avcodec_alloc_context3(codec));
}

// 内存管理辅助函数
template<typename T, typename Func>
void safeFree(T*& ptr, Func&& func) {
    if (ptr != nullptr) {
        func();
        ptr = nullptr;
    }
}

// 时间工具函数
inline void sleepMs(int timeMs) {
    std::this_thread::sleep_for(std::chrono::milliseconds(timeMs));
}

inline int64_t getCurrentTimeMs() {
    return std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::steady_clock::now().time_since_epoch()).count();
}

// 音频全局配置常量
namespace audio {
    constexpr int SAMPLE_RATE = 48000;
    constexpr int CHANNELS = 1;
    constexpr AVSampleFormat SAMPLE_FORMAT = AV_SAMPLE_FMT_FLTP;
    constexpr int CAPTURE_BITS_PER_SAMPLE = 16;
    constexpr int MICROPHONE_INDEX = 0;
    constexpr int SPEAKER_INDEX = 1;
}

// 视频全局配置常量
namespace video {
    constexpr AVPixelFormat DEFAULT_PIXEL_FORMAT = AV_PIX_FMT_NV12;
    constexpr int DEFAULT_FPS = 30;
}

} // namespace av

#endif // AV_BASE_TYPES_H
