#pragma once

#include "../base/types.h"
#include <memory>
#include <functional>
#include <vector>
#include <string>

namespace av {
namespace codec {

/**
 * 编解码器状态
 */
enum class CodecState {
    IDLE,       // 空闲
    OPENED,     // 已打开
    RUNNING,    // 运行中
    FLUSHING,   // 刷新中
    CLOSED,     // 已关闭
    ERROR       // 错误
};

/**
 * 编解码器类型
 */
enum class CodecType {
    ENCODER,    // 编码器
    DECODER     // 解码器
};

/**
 * 抽象编解码器基类
 * 提供编解码器的通用接口和状态管理
 */
class AbstractCodec {
public:
    AbstractCodec(MediaType mediaType, CodecType codecType);
    virtual ~AbstractCodec();

    // 禁止拷贝
    AbstractCodec(const AbstractCodec&) = delete;
    AbstractCodec& operator=(const AbstractCodec&) = delete;

    /**
     * 打开编解码器
     * @param params 编解码参数
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode open(const CodecParams& params) = 0;

    /**
     * 关闭编解码器
     */
    virtual void close() = 0;

    /**
     * 刷新编解码器缓冲区
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode flush() = 0;

    /**
     * 重置编解码器
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode reset();

    // 状态查询
    CodecState getState() const { return state_; }
    MediaType getMediaType() const { return mediaType_; }
    CodecType getCodecType() const { return codecType_; }
    bool isOpened() const { return state_ == CodecState::OPENED || state_ == CodecState::RUNNING; }
    bool isRunning() const { return state_ == CodecState::RUNNING; }
    bool hasError() const { return state_ == CodecState::ERROR; }

    // 参数获取
    const CodecParams& getParams() const { return params_; }

    // 统计信息
    struct Statistics {
        uint64_t processedFrames = 0;   // 处理的帧数
        uint64_t droppedFrames = 0;     // 丢弃的帧数
        uint64_t errorCount = 0;        // 错误次数
        double avgProcessTime = 0.0;    // 平均处理时间(ms)
        uint64_t totalBytes = 0;        // 总字节数
    };
    
    const Statistics& getStatistics() const { return stats_; }
    void resetStatistics();

    // 回调函数设置
    using ErrorCallback = std::function<void(ErrorCode error, const std::string& message)>;
    void setErrorCallback(ErrorCallback callback) { errorCallback_ = std::move(callback); }

protected:
    /**
     * 设置编解码器状态
     */
    void setState(CodecState state);

    /**
     * 报告错误
     */
    void reportError(ErrorCode error, const std::string& message = "");

    /**
     * 更新统计信息
     */
    void updateStats(bool success, double processTime, uint64_t bytes = 0);

    /**
     * 验证参数有效性
     */
    virtual bool validateParams(const CodecParams& params) = 0;

protected:
    MediaType mediaType_;           // 媒体类型
    CodecType codecType_;           // 编解码器类型
    CodecState state_;              // 当前状态
    CodecParams params_;            // 编解码参数
    Statistics stats_;              // 统计信息
    ErrorCallback errorCallback_;   // 错误回调
    
    // FFmpeg相关
    AVCodecContextPtr codecCtx_;    // 编解码上下文
    const AVCodec* codec_;          // 编解码器
};

/**
 * 抽象编码器基类
 */
class AbstractEncoder : public AbstractCodec {
public:
    AbstractEncoder(MediaType mediaType) : AbstractCodec(mediaType, CodecType::ENCODER) {}
    virtual ~AbstractEncoder() = default;

    /**
     * 编码一帧数据
     * @param frame 输入帧
     * @param packets 输出包列表
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode encode(const AVFramePtr& frame, std::vector<AVPacketPtr>& packets) = 0;

    /**
     * 结束编码（刷新缓冲区）
     * @param packets 输出包列表
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode finishEncode(std::vector<AVPacketPtr>& packets) = 0;

    // 编码器特有的回调
    using FrameCallback = std::function<void(const AVFramePtr& frame)>;
    using PacketCallback = std::function<void(const AVPacketPtr& packet)>;
    
    void setFrameCallback(FrameCallback callback) { frameCallback_ = std::move(callback); }
    void setPacketCallback(PacketCallback callback) { packetCallback_ = std::move(callback); }

protected:
    FrameCallback frameCallback_;   // 帧回调
    PacketCallback packetCallback_; // 包回调
};

/**
 * 抽象解码器基类
 */
class AbstractDecoder : public AbstractCodec {
public:
    AbstractDecoder(MediaType mediaType) : AbstractCodec(mediaType, CodecType::DECODER) {}
    virtual ~AbstractDecoder() = default;

    /**
     * 解码一个包
     * @param packet 输入包
     * @param frames 输出帧列表
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode decode(const AVPacketPtr& packet, std::vector<AVFramePtr>& frames) = 0;

    /**
     * 结束解码（刷新缓冲区）
     * @param frames 输出帧列表
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode finishDecode(std::vector<AVFramePtr>& frames) = 0;

    // 解码器特有的回调
    using PacketCallback = std::function<void(const AVPacketPtr& packet)>;
    using FrameCallback = std::function<void(const AVFramePtr& frame)>;
    
    void setPacketCallback(PacketCallback callback) { packetCallback_ = std::move(callback); }
    void setFrameCallback(FrameCallback callback) { frameCallback_ = std::move(callback); }

protected:
    PacketCallback packetCallback_; // 包回调
    FrameCallback frameCallback_;   // 帧回调
};

/**
 * 编解码器工厂类
 */
class CodecFactory {
public:
    /**
     * 创建编码器
     */
    static std::unique_ptr<AbstractEncoder> createEncoder(MediaType mediaType, const std::string& codecName);

    /**
     * 创建解码器
     */
    static std::unique_ptr<AbstractDecoder> createDecoder(MediaType mediaType, const std::string& codecName);

    /**
     * 获取支持的编码器列表
     */
    static std::vector<std::string> getSupportedEncoders(MediaType mediaType);

    /**
     * 获取支持的解码器列表
     */
    static std::vector<std::string> getSupportedDecoders(MediaType mediaType);

    /**
     * 检查编解码器是否支持
     */
    static bool isCodecSupported(const std::string& codecName, CodecType type, MediaType mediaType);
};

} // namespace codec
} // namespace av