#ifndef AV_UTILS_SYNCHRONIZER_V2_H
#define AV_UTILS_SYNCHRONIZER_V2_H

#pragma once

#include "../base/types.h"
#include "../base/logger.h"
#include <memory>
#include <atomic>
#include <mutex>
#include <chrono>
#include <deque>
#include <functional>

extern "C" {
#include <libavutil/avutil.h>
#include <libavutil/time.h>
}

namespace av {
namespace utils {

// 同步错误常量
const ErrorCode SYNC_ERROR = ErrorCode::PROCESSING_ERROR;

/**
 * 改进的时钟类型
 */
enum class ClockType {
    AUDIO,
    VIDEO,
    EXTERNAL,
    SYSTEM
};

/**
 * 同步策略
 */
enum class SyncStrategy {
    AUDIO_MASTER,       // 音频为主时钟
    VIDEO_MASTER,       // 视频为主时钟
    EXTERNAL_MASTER,    // 外部时钟为主
    ADAPTIVE            // 自适应选择
};

/**
 * 同步状态
 */
enum class SyncState {
    IDLE,               // 空闲
    INITIALIZING,       // 初始化中
    SYNCING,           // 同步中
    SYNCHRONIZED,      // 已同步
    DRIFT,             // 轻微漂移
    ERROR,             // 同步错误
    RECOVERING         // 恢复中
};

/**
 * 时钟信息结构
 */
struct ClockInfo {
    double pts = 0.0;                                           // 当前PTS
    double time = 0.0;                                          // 系统时间
    double speed = 1.0;                                         // 播放速度
    int serial = 0;                                             // 序列号
    bool paused = false;                                        // 是否暂停
    std::chrono::steady_clock::time_point lastUpdate;          // 最后更新时间
    double drift = 0.0;                                         // 时钟漂移
    double smoothedPts = 0.0;                                   // 平滑后的PTS
    
    ClockInfo() {
        lastUpdate = std::chrono::steady_clock::now();
    }
};

/**
 * 同步配置
 */
struct SyncConfigV2 {
    SyncStrategy syncStrategy = SyncStrategy::ADAPTIVE;  // 同步策略
    
    // 同步阈值
    double syncThreshold = 0.04;           // 40ms - 基本同步阈值
    double audioSyncThreshold = 0.04;      // 40ms - 音频同步阈值
    double videoSyncThreshold = 0.04;      // 40ms - 视频同步阈值
    double maxSyncError = 0.1;             // 100ms - 最大允许误差
    double frameDropThreshold = 0.05;      // 50ms - 丢帧阈值
    double frameDupThreshold = 0.1;        // 100ms - 重复帧阈值
    
    // 帧控制
    bool enableFrameDrop = true;           // 启用丢帧
    bool enableFrameDuplicate = true;      // 启用重复帧
    
    // 时钟更新参数
    double clockUpdateInterval = 0.01;     // 10ms - 时钟更新间隔
    int smoothingWindow = 10;              // 平滑窗口大小
    double smoothingFactor = 0.1;          // 平滑因子
    
    // 自适应参数
    bool enableAdaptiveSync = true;
    double adaptiveThreshold = 0.02;       // 20ms - 自适应阈值
    int adaptiveWindow = 30;               // 自适应窗口
    
    // 恢复参数
    double recoveryThreshold = 0.2;        // 200ms - 恢复阈值
    int maxRecoveryAttempts = 5;           // 最大恢复尝试次数
    bool enableErrorRecovery = true;       // 启用错误恢复
    
    // 性能参数
    bool enablePrediction = true;          // 启用预测
    double predictionWindow = 0.1;         // 100ms - 预测窗口
    
    // 兼容性字段 (保持向后兼容)
    SyncStrategy strategy = SyncStrategy::ADAPTIVE;  // 与syncStrategy相同
};

/**
 * 同步统计信息
 */
struct SyncStatsV2 {
    // 时钟值
    double audioClock = 0.0;
    double videoClock = 0.0;
    double externalClock = 0.0;
    double masterClock = 0.0;
    
    // 延迟信息
    double audioDelay = 0.0;
    double videoDelay = 0.0;
    double syncError = 0.0;
    double avgSyncError = 0.0;
    double maxSyncError = 0.0;
    
    // 帧处理统计
    uint64_t totalFrames = 0;
    uint64_t droppedFrames = 0;
    uint64_t duplicatedFrames = 0;
    uint64_t syncAdjustments = 0;
    
    // 状态信息
    SyncState state = SyncState::IDLE;
    ClockType masterClockType = ClockType::AUDIO;
    std::chrono::steady_clock::time_point lastUpdateTime;
    
    // 性能指标
    double cpuUsage = 0.0;
    double memoryUsage = 0.0;
};

/**
 * 帧决策结果
 */
enum class FrameAction {
    DISPLAY,         // 正常显示
    DROP,            // 丢弃帧
    Frame_DUPLICATE, // 重复帧
    DELAY            // 延迟显示
};

/**
 * 帧决策信息
 */
struct FrameDecision {
    FrameAction action = FrameAction::DISPLAY;
    double delay = 0.0;                     // 延迟时间
    double targetPts = 0.0;                 // 目标PTS
    double actualPts = 0.0;                 // 实际PTS
    double syncError = 0.0;                 // 同步误差
    std::string reason;                     // 决策原因
};

/**
 * 回调函数类型
 */
using SyncEventCallback = std::function<void(SyncState oldState, SyncState newState)>;
using FrameDropCallback = std::function<void(ClockType clockType, double pts)>;
using FrameDuplicateCallback = std::function<void(ClockType clockType, double pts)>;
using SyncErrorCallback = std::function<void(double error, const std::string& reason)>;

/**
 * 改进的同步器类 - 基于AVPlayer2的经验重新设计
 * 
 * 主要改进:
 * 1. 更精确的时钟管理和同步算法
 * 2. 自适应同步策略
 * 3. 更好的错误恢复机制
 * 4. 性能优化和预测算法
 * 5. 详细的统计和监控
 */
class SynchronizerV2 {
public:
    explicit SynchronizerV2(const SyncConfigV2& config = SyncConfigV2());
    ~SynchronizerV2();
    
    // 生命周期管理
    ErrorCode initialize();
    ErrorCode start();
    ErrorCode stop();
    ErrorCode pause();
    ErrorCode resume();
    ErrorCode reset();
    
    // 设置流信息
    void setStreamInfo(bool hasAudio, bool hasVideo);
    ErrorCode close();
    
    // 时钟设置 - 改进的接口
    ErrorCode setAudioClock(double pts, double time = -1, int serial = 0);
    ErrorCode setVideoClock(double pts, double time = -1, int serial = 0);
    ErrorCode setExternalClock(double time = -1, int serial = 0);
    
    // 时钟获取 - 支持预测
    double getAudioClock(bool predict = false) const;
    double getVideoClock(bool predict = false) const;
    double getExternalClock(bool predict = false) const;
    double getMasterClock(bool predict = false) const;
    ClockType getMasterClockType() const { return masterClockType_; }
    
    // 同步决策 - 核心功能
    FrameDecision shouldDisplayVideoFrame(double pts, double duration = 0.0);
    FrameDecision shouldPlayAudioFrame(double pts, double duration = 0.0);
    double calculateTargetDelay(double pts, ClockType clockType);
    
    // 同步控制
    bool shouldDropFrame(double pts, ClockType clockType);
    bool shouldDuplicateFrame(double pts, ClockType clockType);
    double calculateSyncError() const;
    double calculateAudioDelay(double pts) const;
    double calculateVideoDelay(double pts) const;
    
    // 配置管理
    void setConfig(const SyncConfigV2& config);
    SyncConfigV2 getConfig() const;
    void setSyncStrategy(SyncStrategy strategy);
    SyncStrategy getSyncStrategy() const;
    void setPlaybackSpeed(double speed);
    double getPlaybackSpeed() const;
    
    // 状态查询
    SyncState getState() const { return state_; }
    bool isSynchronized() const;
    bool isRunning() const { return running_; }
    bool isPaused() const { return paused_; }
    
    // 统计信息
    SyncStatsV2 getStats() const;
    void resetStats();
    
    // 回调设置
    void setSyncEventCallback(SyncEventCallback callback);
    void setFrameDropCallback(FrameDropCallback callback);
    void setFrameDuplicateCallback(FrameDuplicateCallback callback);
    void setSyncErrorCallback(SyncErrorCallback callback);
    
    // 高级功能
    void enableAdaptiveSync(bool enable);
    void enablePrediction(bool enable);
    void setClockUpdateInterval(double interval);
    void setSmoothingWindow(int window);
    
    // 调试和监控
    std::string getDebugInfo() const;
    void dumpClockInfo() const;

private:
    // 内部时钟管理
    ErrorCode updateClock(ClockType type, double pts, double time, int serial);
    double getClock(ClockType type, bool predict = false) const;
    void resetClock(ClockType type);
    void pauseClock(ClockType type, bool pause);
    
    // 同步算法
    void updateMasterClock();
    void selectMasterClock();
    void updateSyncState();
    void updateStats();
    
    // 平滑和预测
    double smoothClock(ClockType type, double newPts);
    double predictClock(ClockType type, double futureTime) const;
    void updateClockHistory(ClockType type, double pts);
    
    // 自适应算法
    void adaptiveSyncUpdate();
    bool shouldSwitchMasterClock();
    void handleSyncError(double error);
    
    // 错误恢复
    void attemptRecovery();
    void performDelayedRecovery();
    void resetSyncState();
    
    // 工具函数
    double getCurrentTime() const;
    double getSystemTime() const;
    void notifyStateChange(SyncState newState);
    void notifyFrameDrop(ClockType type, double pts);
    void notifyFrameDuplicate(ClockType type, double pts);
    void notifySyncError(double error, const std::string& reason);
    
    // 内部版本，假设调用者已经持有clockMutex_锁
    double calculateSyncErrorInternal() const;
    
private:
    // 配置
    SyncConfigV2 config_;
    mutable std::mutex configMutex_;
    
    // 状态
    std::atomic<SyncState> state_{SyncState::IDLE};
    std::atomic<ClockType> masterClockType_{ClockType::AUDIO};
    std::atomic<bool> initialized_{false};
    std::atomic<bool> running_{false};
    std::atomic<bool> paused_{false};
    
    // 时钟
    ClockInfo audioClock_;
    ClockInfo videoClock_;
    ClockInfo externalClock_;
    mutable std::mutex clockMutex_;
    
    // 历史记录
    std::deque<double> audioClockHistory_;
    std::deque<double> videoClockHistory_;
    std::deque<double> syncErrorHistory_;
    mutable std::mutex historyMutex_;
    
    // 统计信息
    SyncStatsV2 stats_;
    mutable std::mutex statsMutex_;
    
    // 时间记录
    std::chrono::steady_clock::time_point startTime_;
    std::chrono::steady_clock::time_point lastClockUpdate_;
    std::chrono::steady_clock::time_point lastStatsUpdate_;

    // 自适应参数
    int recoveryAttempts_ = 0;
    double lastSyncError_ = 0.0;
    std::chrono::steady_clock::time_point lastRecoveryTime_;
    
    // 回调函数
    SyncEventCallback syncEventCallback_;
    FrameDropCallback frameDropCallback_;
    FrameDuplicateCallback frameDuplicateCallback_;
    SyncErrorCallback syncErrorCallback_;
    
    // 流信息
    std::atomic<bool> hasAudioStream_{false};
    std::atomic<bool> hasVideoStream_{false};
};

} // namespace utils
} // namespace av

#endif // AV_UTILS_SYNCHRONIZER_V2_H