#ifndef AV_RECORDER_ABSTRACT_RECORDER_H
#define AV_RECORDER_ABSTRACT_RECORDER_H

#include "../base/types.h"
#include "../base/media_common.h"
#include "../capture/capture_abstract_capturer.h"
#include "../codec/codec_abstract_codec.h"
#include "../muxer/muxer_abstract_muxer.h"
#include <memory>
#include <functional>
#include <atomic>
#include <mutex>
#include <string>
#include <vector>

namespace av {
namespace recorder {

/**
 * 录制器状态
 */
enum class RecorderState {
    IDLE,           // 空闲
    INITIALIZED,    // 已初始化
    RECORDING,      // 录制中
    PAUSED,         // 暂停
    STOPPED,        // 已停止
    ERROR           // 错误状态
};

/**
 * 录制器参数
 */
struct RecorderParams {
    MediaType mediaType;
    std::string outputPath;         // 输出路径
    std::string format;             // 输出格式
    bool autoStart = false;         // 自动开始录制
    
    virtual ~RecorderParams() = default;
};

/**
 * 录制器统计信息
 */
struct RecorderStats {
    uint64_t recordedFrames = 0;    // 已录制帧数
    uint64_t droppedFrames = 0;     // 丢弃帧数
    uint64_t totalBytes = 0;        // 总字节数
    uint64_t errorCount = 0;        // 错误次数
    double recordingTime = 0.0;     // 录制时长(秒)
    double avgFrameRate = 0.0;      // 平均帧率
    std::chrono::steady_clock::time_point startTime; // 开始时间
};

/**
 * 抽象录制器基类
 * 整合采集器、编码器和复用器，提供完整的录制功能
 */
class AbstractRecorder {
public:
    AbstractRecorder(MediaType mediaType);
    virtual ~AbstractRecorder();

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

    /**
     * 初始化录制器
     * @param params 录制参数
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode initialize(const RecorderParams& params) = 0;

    /**
     * 开始录制
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode startRecording() = 0;

    /**
     * 停止录制
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode stopRecording() = 0;

    /**
     * 暂停录制
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode pauseRecording() = 0;

    /**
     * 恢复录制
     * @return 成功返回ErrorCode::SUCCESS
     */
    virtual ErrorCode resumeRecording() = 0;

    /**
     * 关闭录制器，释放资源
     */
    virtual void close() {}

    // 状态查询
    RecorderState getState() const { return state_.load(); }
    bool isRecording() const { return state_.load() == RecorderState::RECORDING; }
    bool isPaused() const { return state_.load() == RecorderState::PAUSED; }

    // 统计信息
    virtual RecorderStats getStats() const;
    virtual void resetStats();

    // 回调设置
    using ErrorCallback = std::function<void(ErrorCode, const std::string&)>;
    using StateCallback = std::function<void(RecorderState)>;
    
    void setErrorCallback(const ErrorCallback& callback) { errorCallback_ = callback; }
    void setStateCallback(const StateCallback& callback) { stateCallback_ = callback; }

protected:
    /**
     * 设置录制器状态
     */
    void setState(RecorderState state);

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

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

    /**
     * 计算帧率
     */
    void calculateFrameRate();

    /**
     * 验证参数
     */
    virtual bool validateParams(const RecorderParams& params) = 0;

protected:
    MediaType mediaType_;                   // 媒体类型
    std::atomic<RecorderState> state_;      // 当前状态
    RecorderParams params_;                 // 录制参数
    
    // 统计信息
    mutable std::mutex statsMutex_;
    RecorderStats stats_;
    
    // 回调函数
    ErrorCallback errorCallback_;
    StateCallback stateCallback_;
    
    // 帧率计算
    std::chrono::steady_clock::time_point lastFrameTime_;
    std::chrono::steady_clock::time_point lastFpsCalcTime_;
    uint64_t frameCountForFps_ = 0;
    
    // 线程安全
    mutable std::mutex recorderMutex_;
};

/**
 * 录制器工厂类
 */
class RecorderFactory {
public:
    /**
     * 创建录制器
     */
    static std::unique_ptr<AbstractRecorder> createRecorder(MediaType mediaType);
    
    /**
     * 检查是否支持指定媒体类型的录制
     */
    static bool isRecorderSupported(MediaType mediaType);
    
    /**
     * 获取支持的媒体类型列表
     */
    static std::vector<MediaType> getSupportedMediaTypes();
};

} // namespace recorder
} // namespace av

#endif // AV_RECORDER_ABSTRACT_RECORDER_H