#include "utils_synchronizer_v2.h"
#include "../base/logger.h"
#include <algorithm>
#include <cmath>
#include <sstream>
#include <iomanip>

namespace av {
namespace utils {
SynchronizerV2::SynchronizerV2(const SyncConfigV2& config)
    : config_(config)
    , state_(SyncState::IDLE)
    , masterClockType_(ClockType::AUDIO)
    , initialized_(false)
    , running_(false)
    , paused_(false)
    , recoveryAttempts_(0)
    , lastSyncError_(0.0)
{
    // 初始化时钟
    audioClock_ = ClockInfo();
    videoClock_ = ClockInfo();
    externalClock_ = ClockInfo();
    
    // 初始化历史记录
    audioClockHistory_.clear();
    videoClockHistory_.clear();
    syncErrorHistory_.clear();
    
    Logger::instance().info("SynchronizerV2 created with strategy: " + 
                           std::to_string(static_cast<int>(config_.strategy)));
}

SynchronizerV2::~SynchronizerV2() {
    close();
    Logger::instance().info("SynchronizerV2 destroyed");
}

ErrorCode SynchronizerV2::initialize() {
    if (initialized_) {
        return ErrorCode::ALREADY_INITIALIZED;
    }
    
    std::lock_guard<std::mutex> clockLock(clockMutex_);
    std::lock_guard<std::mutex> statsLock(statsMutex_);
    
    // 重置所有时钟
    resetClock(ClockType::AUDIO);
    resetClock(ClockType::VIDEO);
    resetClock(ClockType::EXTERNAL);
    
    // 选择主时钟
    selectMasterClock();
    
    // 重置统计信息
    stats_ = SyncStatsV2();
    stats_.lastUpdateTime = std::chrono::steady_clock::now();
    
    // 设置开始时间
    startTime_ = std::chrono::steady_clock::now();
    lastClockUpdate_ = startTime_;
    lastStatsUpdate_ = startTime_;
    
    state_ = SyncState::IDLE;
    initialized_ = true;
    recoveryAttempts_ = 0;
    
    Logger::instance().info("SynchronizerV2 initialized");
    return ErrorCode::SUCCESS;
}

ErrorCode SynchronizerV2::start() {
    if (!initialized_) {
        return ErrorCode::NOT_INITIALIZED;
    }
    
    if (running_) {
        return ErrorCode::ALREADY_STARTED;
    }
    
    running_ = true;
    paused_ = false;
    state_ = SyncState::INITIALIZING;
    
    startTime_ = std::chrono::steady_clock::now();
    lastClockUpdate_ = startTime_;
    
    // 按照packets_sync.cpp的init_clock逻辑初始化外部时钟
    // 外部时钟应该初始化为NAN，而不是系统时间
    {
        std::lock_guard<std::mutex> lock(clockMutex_);
        if (std::isnan(externalClock_.pts)) {
            // 严格按照packets_sync.cpp的init_clock实现
            // 外部时钟初始化为NAN，不使用系统时间
            double currentTime = av_gettime_relative() / 1000000.0;
            externalClock_.pts = std::numeric_limits<double>::quiet_NaN();  // 初始化为NAN
            externalClock_.pts_drift = 0.0;       // 初始化pts_drift
            externalClock_.lastUpdate = currentTime;
            externalClock_.speed = 1.0;
            externalClock_.serial = -1;
            externalClock_.paused = false;
            externalClock_.time = currentTime;
            externalClock_.drift = 0.0;
            externalClock_.smoothedPts = std::numeric_limits<double>::quiet_NaN();
        }
    }
    
    // 启动后立即进入同步状态
    state_ = SyncState::SYNCING;
    
    Logger::instance().info("SynchronizerV2 started");
    return ErrorCode::SUCCESS;
}

void SynchronizerV2::setStreamInfo(bool hasAudio, bool hasVideo) {
    std::lock_guard<std::mutex> lock(clockMutex_);
    hasAudioStream_ = hasAudio;
    hasVideoStream_ = hasVideo;
    
    Logger::instance().info("Stream info updated: hasAudio=" + std::to_string(hasAudio) + 
                           ", hasVideo=" + std::to_string(hasVideo));
    
    // 重新选择主时钟
    selectMasterClock();
}

ErrorCode SynchronizerV2::stop() {
    if (!running_) {
        return ErrorCode::NOT_STARTED;
    }
    
    running_ = false;
    paused_ = false;
    state_ = SyncState::IDLE;
    
    Logger::instance().info("SynchronizerV2 stopped");
    return ErrorCode::SUCCESS;
}

ErrorCode SynchronizerV2::pause() {
    if (!running_) {
        return ErrorCode::NOT_STARTED;
    }
    
    if (paused_) {
        return ErrorCode::ALREADY_PAUSED;
    }
    
    std::lock_guard<std::mutex> lock(clockMutex_);
    
    paused_ = true;
    
    // 暂停所有时钟
    pauseClock(ClockType::AUDIO, true);
    pauseClock(ClockType::VIDEO, true);
    pauseClock(ClockType::EXTERNAL, true);
    
    Logger::instance().info("SynchronizerV2 paused");
    return ErrorCode::SUCCESS;
}

ErrorCode SynchronizerV2::resume() {
    if (!running_) {
        return ErrorCode::NOT_STARTED;
    }
    
    if (!paused_) {
        return ErrorCode::NOT_PAUSED;
    }
    
    std::lock_guard<std::mutex> lock(clockMutex_);
    
    paused_ = false;
    
    // 恢复所有时钟
    pauseClock(ClockType::AUDIO, false);
    pauseClock(ClockType::VIDEO, false);
    pauseClock(ClockType::EXTERNAL, false);
    
    state_ = SyncState::SYNCING;
    
    Logger::instance().info("SynchronizerV2 resumed");
    return ErrorCode::SUCCESS;
}

ErrorCode SynchronizerV2::reset() {
    std::lock_guard<std::mutex> clockLock(clockMutex_);
    std::lock_guard<std::mutex> statsLock(statsMutex_);
    std::lock_guard<std::mutex> historyLock(historyMutex_);
    
    // 重置时钟
    resetClock(ClockType::AUDIO);
    resetClock(ClockType::VIDEO);
    resetClock(ClockType::EXTERNAL);
    
    // 重置统计信息
    stats_ = SyncStatsV2();
    stats_.lastUpdateTime = std::chrono::steady_clock::now();
    
    // 清空历史记录
    audioClockHistory_.clear();
    videoClockHistory_.clear();
    syncErrorHistory_.clear();
    
    // 重置状态
    state_ = running_ ? SyncState::SYNCING : SyncState::IDLE;
    recoveryAttempts_ = 0;
    lastSyncError_ = 0.0;
    
    // 重新选择主时钟
    selectMasterClock();
    
    Logger::instance().info("SynchronizerV2 reset");
    return ErrorCode::SUCCESS;
}

ErrorCode SynchronizerV2::close() {
    if (running_) {
        stop();
    }
    
    initialized_ = false;
    
    Logger::instance().info("SynchronizerV2 closed");
    return ErrorCode::SUCCESS;
}

ErrorCode SynchronizerV2::setAudioClock(int64_t pts, double timeBase, int serial) {
    return updateClock(ClockType::AUDIO, pts, timeBase, serial);
}

ErrorCode SynchronizerV2::setVideoClock(int64_t pts, double timeBase, int serial) {
    return updateClock(ClockType::VIDEO, pts, timeBase, serial);
}

ErrorCode SynchronizerV2::setExternalClock(int64_t pts, double timeBase, int serial) {
    return updateClock(ClockType::EXTERNAL, pts, timeBase, serial);
}

int64_t SynchronizerV2::getAudioClock(bool predict) const {
    return getClock(ClockType::AUDIO, predict);
}

int64_t SynchronizerV2::getVideoClock(bool predict) const {
    return getClock(ClockType::VIDEO, predict);
}

int64_t SynchronizerV2::getExternalClock(bool predict) const {
    return getClock(ClockType::EXTERNAL, predict);
}

int64_t SynchronizerV2::getMasterClock(bool predict) const {
    return getClock(masterClockType_, predict);
}

FrameDecision SynchronizerV2::shouldDisplayVideoFrame(int64_t pts, double timeBase, double duration) {
    FrameDecision decision;
    decision.actualPts = pts;
    
    if (!running_ || paused_) {
        decision.action = FrameAction::DELAY;
        decision.delay = 0.01; // 10ms
        decision.reason = paused_ ? "Paused" : "Not running";
        return decision;
    }
    
    // 参考AVPlayer2的视频帧显示决策算法
    double delay = duration > 0 ? duration : (1.0 / 25.0); // 默认25fps
    
    // 如果视频是主时钟，直接显示
    if (masterClockType_ == ClockType::VIDEO) {
        decision.action = FrameAction::DISPLAY;
        decision.delay = delay;
        decision.reason = "Video master";
        decision.targetPts = pts;
        return decision;
    }
    
    // 获取主时钟并计算同步误差
    int64_t masterClock = getMasterClock(false); // 不使用预测，获取当前值
    decision.targetPts = masterClock;
    
    double videoPts = ptsToSeconds(pts, timeBase);
    double masterPts = ptsToSeconds(masterClock, timeBase);
    double diff = videoPts - masterPts;
    decision.syncError = diff;
    
    // 添加调试日志（仅在同步误差较大时）
    if (std::abs(diff) > 1.0) { // 超过1秒时记录
        Logger::instance().warning("Large video sync error: videoPTS=" + 
                                  std::to_string(videoPts) + "s, masterPTS=" + 
                                  std::to_string(masterPts) + "s, diff=" + 
                                  std::to_string(diff) + "s, masterClock=" + 
                                  std::to_string(masterClock) + ", timeBase=" + 
                                  std::to_string(timeBase));
    }
    
    // 参考packets_sync.cpp的AV_NOSYNC_THRESHOLD检查
    if (std::isnan(diff) || std::isinf(diff) || std::abs(diff) >= config_.noSyncThreshold) {
        // 同步误差过大，强制显示帧，不进行同步校正
        decision.action = FrameAction::DISPLAY;
        decision.delay = delay;
        decision.reason = "Large sync error, force display (diff: " + std::to_string(diff * 1000) + "ms)";
        decision.targetPts = pts;

        Logger::instance().warningf(
            "Video sync error exceeds AV_NOSYNC_THRESHOLD: " + std::to_string(diff * 1000) + "ms");
        return decision;
    }
    
    // 参考AVPlayer2的compute_target_delay算法进行同步调整
    double sync_threshold = std::max(config_.syncThreshold, std::min(0.1, delay));
    
    // 检查差异是否在合理范围内（避免异常值）
    if (!std::isnan(diff) && std::abs(diff) < config_.maxSyncError) {
        if (diff <= -sync_threshold) {
            // 视频落后太多，丢帧追赶
            decision.action = FrameAction::DROP;
            decision.reason = "Video too slow, drop frame";
            
            // 通知丢帧
            if (frameDropCallback_) {
                frameDropCallback_(ClockType::VIDEO, pts);
            }
            
            // 更新统计
            std::lock_guard<std::mutex> lock(statsMutex_);
            stats_.droppedFrames++;
            
        } else if (diff >= sync_threshold && delay > config_.frameDupThreshold) {
            // 视频超前且延迟足够大，增加延迟
            decision.action = FrameAction::DELAY;
            decision.delay = delay + diff;
            decision.reason = "Video too fast, increase delay";
            
        } else if (diff >= sync_threshold) {
            // 视频超前但延迟较小，重复帧
            decision.action = FrameAction::Frame_DUPLICATE;
            decision.delay = 2 * delay;
            decision.reason = "Video too fast, duplicate frame";
            
            // 通知重复帧
            if (frameDuplicateCallback_) {
                frameDuplicateCallback_(ClockType::VIDEO, pts);
            }
            
            // 更新统计
            std::lock_guard<std::mutex> lock(statsMutex_);
            stats_.duplicatedFrames++;
            
        } else {
            // 正常显示
            decision.action = FrameAction::DISPLAY;
            decision.delay = delay;
            decision.reason = "Normal display";
        }
    } else {
        // 同步误差过大或异常，需要智能处理
        if (std::isnan(diff) || std::isinf(diff)) {
            // 异常值，强制显示
            decision.action = FrameAction::DISPLAY;
            decision.delay = delay;
            decision.reason = "Invalid sync value, force display";
        } else if (diff < -config_.maxSyncError) {
            // 视频严重落后，丢帧追赶
            decision.action = FrameAction::DROP;
            decision.reason = "Video severely behind, drop frame";
            
            // 通知丢帧
            if (frameDropCallback_) {
                frameDropCallback_(ClockType::VIDEO, pts);
            }
            
            // 更新统计
            std::lock_guard<std::mutex> lock(statsMutex_);
            stats_.droppedFrames++;
        } else if (diff > config_.maxSyncError) {
            // 视频严重超前，大幅延迟
            decision.action = FrameAction::DELAY;
            decision.delay = std::min(delay + diff, 0.5); // 最大延迟500ms
            decision.reason = "Video severely ahead, large delay";
        } else {
            // 其他情况，使用默认延迟
            decision.action = FrameAction::DISPLAY;
            decision.delay = delay;
            decision.reason = "Sync error large, default display";
        }
        
        // 触发恢复机制
        if (state_ != SyncState::RECOVERING && recoveryAttempts_ < config_.maxRecoveryAttempts) {
            state_ = SyncState::RECOVERING;
            recoveryAttempts_++;
        }
    }
    
    // 更新统计
    {
        std::lock_guard<std::mutex> lock(statsMutex_);
        stats_.totalFrames++;
        stats_.syncError = diff;
        
        // 更新平均同步误差
        if (stats_.totalFrames == 1) {
            stats_.avgSyncError = std::abs(diff);
        } else {
            stats_.avgSyncError = stats_.avgSyncError * 0.9 + std::abs(diff) * 0.1;
        }
        
        // 更新最大同步误差
        stats_.maxSyncError = std::max(stats_.maxSyncError, std::abs(diff));
    }
    
    return decision;
}

FrameDecision SynchronizerV2::shouldPlayAudioFrame(int64_t pts, double timeBase, double duration) {
    FrameDecision decision;
    decision.actualPts = pts;
    
    if (!running_ || paused_) {
        decision.action = FrameAction::DELAY;
        decision.delay = 0.01; // 10ms
        decision.reason = paused_ ? "Paused" : "Not running";
        return decision;
    }
    
    // 参考AVPlayer2的音频帧播放决策算法
    double delay = duration > 0 ? duration : 0.02; // 默认20ms
    
    // 如果音频是主时钟，直接播放
    if (masterClockType_ == ClockType::AUDIO) {
        decision.action = FrameAction::DISPLAY;
        decision.delay = delay;
        decision.reason = "Audio master";
        decision.targetPts = pts;
        return decision;
    }
    
    // 获取主时钟并计算同步误差
    int64_t masterClock = getMasterClock(false); // 不使用预测，获取当前值
    decision.targetPts = masterClock;
    
    // 检查主时钟是否有效
    if (masterClock == AV_NOPTS_VALUE) {
        decision.action = FrameAction::DISPLAY;
        decision.delay = delay;
        decision.reason = "Master clock invalid, force play";
        return decision;
    }
    
    double audioPts = ptsToSeconds(pts, timeBase);
    double masterPts = ptsToSeconds(masterClock, timeBase);
    double diff = audioPts - masterPts;
    decision.syncError = diff;
    
    // 参考packets_sync.cpp的AV_NOSYNC_THRESHOLD检查
    if (std::isnan(diff) || std::isinf(diff) || std::abs(diff) >= config_.noSyncThreshold) {
        // 同步误差过大，不进行同步修正，直接播放
        decision.action = FrameAction::DISPLAY;
        decision.delay = delay;
        decision.reason = "Sync error too large (>" + std::to_string(config_.noSyncThreshold) + "s), no sync";
        
        // 记录大误差日志
        if (std::abs(diff) > 1.0) {
            Logger::instance().warning("Large audio sync error: audioPTS=" + 
                                      std::to_string(audioPts) + "s, masterPTS=" + 
                                      std::to_string(masterPts) + "s, diff=" + 
                                      std::to_string(diff) + "s");
        }
        
        return decision;
    }
    
    // 参考packets_sync.cpp的音频同步算法
    double sync_threshold = config_.syncThreshold;
    
    // 正常同步处理
    if (diff <= -sync_threshold) {
        // 音频落后太多，丢帧追赶
        decision.action = FrameAction::DROP;
        decision.reason = "Audio too slow, drop frame (diff=" + std::to_string(diff * 1000) + "ms)";
        
        // 通知丢帧
        if (frameDropCallback_) {
            frameDropCallback_(ClockType::AUDIO, pts);
        }
        
        // 更新统计
        std::lock_guard<std::mutex> lock(statsMutex_);
        stats_.droppedFrames++;
        
    } else if (diff >= sync_threshold) {
        // 音频超前，延迟播放
        decision.action = FrameAction::DELAY;
        decision.delay = delay + diff;
        decision.reason = "Audio too fast, delay (diff=" + std::to_string(diff * 1000) + "ms)";
        
    } else {
        // 正常播放
        decision.action = FrameAction::DISPLAY;
        decision.delay = delay;
        decision.reason = "Normal play (diff=" + std::to_string(diff * 1000) + "ms)";
    }
    
    // 更新统计
    {
        std::lock_guard<std::mutex> lock(statsMutex_);
        stats_.totalFrames++;
        stats_.syncError = diff;
        
        // 更新平均同步误差
        if (stats_.totalFrames == 1) {
            stats_.avgSyncError = std::abs(diff);
        } else {
            stats_.avgSyncError = stats_.avgSyncError * 0.9 + std::abs(diff) * 0.1;
        }
        
        // 更新最大同步误差
        stats_.maxSyncError = std::max(stats_.maxSyncError, std::abs(diff));
    }
    
    return decision;
}

double SynchronizerV2::calculateTargetDelay(int64_t pts, double timeBase, ClockType clockType) {
    if (!running_) {
        return 0.0;
    }
    
    // 参考packets_sync.cpp的compute_target_delay算法
    double delay = 0.0;
    
    // 基础帧延迟
    if (clockType == ClockType::VIDEO) {
        delay = 1.0 / 25.0; // 默认25fps，40ms
    } else {
        delay = 0.0; // 音频不需要基础延迟
    }
    
    // 如果不是视频主时钟模式，需要进行同步调整
    if (masterClockType_ != ClockType::VIDEO && clockType == ClockType::VIDEO) {
        // 获取主时钟
        int64_t masterClock = getMasterClock(true);
        if (masterClock == AV_NOPTS_VALUE) {
            return delay; // 主时钟无效，返回基础延迟
        }
        
        // 计算视频时钟与主时钟的差异
        double videoPts = ptsToSeconds(pts, timeBase);
        double masterPts = ptsToSeconds(masterClock, timeBase);
        double diff = videoPts - masterPts;
        
        // 参考packets_sync.cpp的AV_NOSYNC_THRESHOLD检查
        if (std::isnan(diff) || std::isinf(diff) || std::abs(diff) >= config_.noSyncThreshold) {
            // 同步误差过大，不进行同步校正，返回基础延迟
            return delay;
        }
        
        // 计算同步阈值，参考packets_sync.cpp的动态阈值算法
        double sync_threshold = std::max(config_.syncThreshold, std::min(0.1, delay));
        
        // 检查差异是否在合理范围内（避免异常值）
        if (!std::isnan(diff) && std::abs(diff) < config_.maxSyncError) {
            if (diff <= -sync_threshold) {
                // 视频落后，减少延迟以追赶
                delay = std::max(0.0, delay + diff);
            } else if (diff >= sync_threshold && delay > config_.frameDupThreshold) {
                // 视频超前且延迟足够大，增加延迟
                delay = delay + diff;
            } else if (diff >= sync_threshold) {
                // 视频超前但延迟较小，加倍延迟
                delay = 2 * delay;
            }
        }
    }
    
    return delay;
}

bool SynchronizerV2::shouldDropFrame(int64_t pts, double timeBase, ClockType clockType) {
    if (!running_ || clockType == masterClockType_) {
        return false;
    }
    
    int64_t masterClock = getMasterClock();
    if (masterClock == AV_NOPTS_VALUE) {
        return false; // 主时钟无效，不丢帧
    }
    
    double ptsInSeconds = ptsToSeconds(pts, timeBase);
    double masterClockInSeconds = ptsToSeconds(masterClock, timeBase);
    double diff = ptsInSeconds - masterClockInSeconds;
    
    // 参考packets_sync.cpp的AV_NOSYNC_THRESHOLD检查
    if (std::isnan(diff) || std::isinf(diff) || std::abs(diff) >= config_.noSyncThreshold) {
        return false; // 同步误差过大，不丢帧
    }
    
    return diff < -config_.frameDropThreshold;
}

bool SynchronizerV2::shouldDuplicateFrame(int64_t pts, double timeBase, ClockType clockType) {
    if (!running_ || clockType == masterClockType_) {
        return false;
    }
    
    int64_t masterClock = getMasterClock();
    if (masterClock == AV_NOPTS_VALUE) {
        return false; // 主时钟无效，不复制帧
    }
    
    double ptsInSeconds = ptsToSeconds(pts, timeBase);
    double masterClockInSeconds = ptsToSeconds(masterClock, timeBase);
    double diff = ptsInSeconds - masterClockInSeconds;
    
    // 参考packets_sync.cpp的AV_NOSYNC_THRESHOLD检查
    if (std::isnan(diff) || std::isinf(diff) || std::abs(diff) >= config_.noSyncThreshold) {
        return false; // 同步误差过大，不复制帧
    }
    
    return diff > config_.frameDupThreshold;
}

double SynchronizerV2::calculateSyncError() const {
    if (!running_) {
        return 0.0;
    }
    
    double audioClock = getAudioClock();
    double videoClock = getVideoClock();
    
    if (audioClock <= 0 || videoClock <= 0) {
        return 0.0;
    }
    
    return std::abs(audioClock - videoClock);
}

// 内部版本，假设调用者已经持有clockMutex_锁
double SynchronizerV2::calculateSyncErrorInternal() const {
    if (!running_) {
        return 0.0;
    }
    
    // 直接计算时钟值，避免调用getClock导致死锁，使用packets_sync.cpp的算法
    double audioClock = 0.0;
    double videoClock = 0.0;
    double currentTime = getSystemTime();
    
    // 计算音频时钟，使用packets_sync.cpp的get_clock算法
    if (!std::isnan(audioClock_.pts)) {
        if (audioClock_.paused) {
            audioClock = audioClock_.pts;
        } else {
            // 使用packets_sync.cpp的算法：pts + pts_drift + (current_time - last_updated) * speed
            audioClock = audioClock_.pts + audioClock_.pts_drift + (currentTime - audioClock_.lastUpdate) * audioClock_.speed;
        }
    }
    
    // 计算视频时钟，使用packets_sync.cpp的get_clock算法
    if (!std::isnan(videoClock_.pts)) {
        if (videoClock_.paused) {
            videoClock = videoClock_.pts;
        } else {
            // 使用packets_sync.cpp的算法：pts + pts_drift + (current_time - last_updated) * speed
            videoClock = videoClock_.pts + videoClock_.pts_drift + (currentTime - videoClock_.lastUpdate) * videoClock_.speed;
        }
    }
    
    if (audioClock <= 0 || videoClock <= 0) {
        return 0.0;
    }
    
    return std::abs(audioClock - videoClock);
}

double SynchronizerV2::calculateAudioDelay(int64_t pts, double timeBase) const {
    if (masterClockType_ == ClockType::AUDIO) {
        return 0.0;
    }
    
    int64_t masterClock = getMasterClock();
    double ptsInSeconds = ptsToSeconds(pts, timeBase);
    double masterClockInSeconds = ptsToSeconds(masterClock, timeBase);
    return ptsInSeconds - masterClockInSeconds;
}

double SynchronizerV2::calculateVideoDelay(int64_t pts, double timeBase) const {
    if (masterClockType_ == ClockType::VIDEO) {
        return 0.0;
    }
    
    int64_t masterClock = getMasterClock();
    double ptsInSeconds = ptsToSeconds(pts, timeBase);
    double masterClockInSeconds = ptsToSeconds(masterClock, timeBase);
    return ptsInSeconds - masterClockInSeconds;
}

void SynchronizerV2::setConfig(const SyncConfigV2& config) {
    std::lock_guard<std::mutex> lock(configMutex_);
    config_ = config;
    
    // 重新选择主时钟
    selectMasterClock();
    
    Logger::instance().info("SynchronizerV2 config updated");
}

SyncConfigV2 SynchronizerV2::getConfig() const {
    std::lock_guard<std::mutex> lock(configMutex_);
    return config_;
}

void SynchronizerV2::setSyncStrategy(SyncStrategy strategy) {
    std::lock_guard<std::mutex> lock(configMutex_);
    config_.strategy = strategy;
    selectMasterClock();
    
    Logger::instance().info("Sync strategy set to: " + std::to_string(static_cast<int>(strategy)));
}

SyncStrategy SynchronizerV2::getSyncStrategy() const {
    std::lock_guard<std::mutex> lock(configMutex_);
    return config_.strategy;
}

void SynchronizerV2::setPlaybackSpeed(double speed) {
    std::lock_guard<std::mutex> lock(clockMutex_);
    
    audioClock_.speed = speed;
    videoClock_.speed = speed;
    externalClock_.speed = speed;
    
    Logger::instance().info("Playback speed set to: " + std::to_string(speed) + "x");
}

double SynchronizerV2::getPlaybackSpeed() const {
    std::lock_guard<std::mutex> lock(clockMutex_);
    return audioClock_.speed;
}

bool SynchronizerV2::isSynchronized() const {
    return state_ == SyncState::SYNCHRONIZED;
}

SyncStatsV2 SynchronizerV2::getStats() const {
    std::lock_guard<std::mutex> lock(statsMutex_);
    SyncStatsV2 stats = stats_;
    
    // 更新当前时钟值
    stats.audioClock = getAudioClock();
    stats.videoClock = getVideoClock();
    stats.externalClock = getExternalClock();
    stats.masterClock = getMasterClock();
    stats.state = state_;
    stats.masterClockType = masterClockType_;
    
    return stats;
}

void SynchronizerV2::resetStats() {
    std::lock_guard<std::mutex> lock(statsMutex_);
    stats_ = SyncStatsV2();
    stats_.lastUpdateTime = std::chrono::steady_clock::now();
    
    Logger::instance().info("SynchronizerV2 stats reset");
}

void SynchronizerV2::setSyncEventCallback(SyncEventCallback callback) {
    syncEventCallback_ = callback;
}

void SynchronizerV2::setFrameDropCallback(FrameDropCallback callback) {
    frameDropCallback_ = callback;
}

void SynchronizerV2::setFrameDuplicateCallback(FrameDuplicateCallback callback) {
    frameDuplicateCallback_ = callback;
}

void SynchronizerV2::setSyncErrorCallback(SyncErrorCallback callback) {
    syncErrorCallback_ = callback;
}

void SynchronizerV2::enableAdaptiveSync(bool enable) {
    std::lock_guard<std::mutex> lock(configMutex_);
    config_.enableAdaptiveSync = enable;
    
    Logger::instance().info("Adaptive sync " + std::string(enable ? "enabled" : "disabled"));
}

void SynchronizerV2::enablePrediction(bool enable) {
    std::lock_guard<std::mutex> lock(configMutex_);
    config_.enablePrediction = enable;
    
    Logger::instance().info("Prediction " + std::string(enable ? "enabled" : "disabled"));
}

void SynchronizerV2::setClockUpdateInterval(double interval) {
    std::lock_guard<std::mutex> lock(configMutex_);
    config_.clockUpdateInterval = interval;
    
    Logger::instance().info("Clock update interval set to: " + std::to_string(interval * 1000) + "ms");
}

void SynchronizerV2::setSmoothingWindow(int window) {
    std::lock_guard<std::mutex> lock(configMutex_);
    config_.smoothingWindow = window;
    
    // 调整历史记录大小
    std::lock_guard<std::mutex> historyLock(historyMutex_);
    while (audioClockHistory_.size() > static_cast<size_t>(window)) {
        audioClockHistory_.pop_front();
    }
    while (videoClockHistory_.size() > static_cast<size_t>(window)) {
        videoClockHistory_.pop_front();
    }
    while (syncErrorHistory_.size() > static_cast<size_t>(window)) {
        syncErrorHistory_.pop_front();
    }
    
    Logger::instance().info("Smoothing window set to: " + std::to_string(window));
}

std::string SynchronizerV2::getDebugInfo() const {
    std::ostringstream oss;
    
    SyncStatsV2 stats = getStats();
    
    oss << std::fixed << std::setprecision(3);
    oss << "SynchronizerV2 Debug Info:\n";
    oss << "  State: " << static_cast<int>(stats.state) << "\n";
    oss << "  Master Clock: " << static_cast<int>(stats.masterClockType) << "\n";
    oss << "  Audio Clock: " << stats.audioClock << "s\n";
    oss << "  Video Clock: " << stats.videoClock << "s\n";
    oss << "  External Clock: " << stats.externalClock << "s\n";
    oss << "  Master Clock: " << stats.masterClock << "s\n";
    oss << "  Sync Error: " << stats.syncError * 1000 << "ms\n";
    oss << "  Avg Sync Error: " << stats.avgSyncError * 1000 << "ms\n";
    oss << "  Max Sync Error: " << stats.maxSyncError * 1000 << "ms\n";
    oss << "  Total Frames: " << stats.totalFrames << "\n";
    oss << "  Dropped Frames: " << stats.droppedFrames << "\n";
    oss << "  Duplicated Frames: " << stats.duplicatedFrames << "\n";
    oss << "  Running: " << (running_ ? "Yes" : "No") << "\n";
    oss << "  Paused: " << (paused_ ? "Yes" : "No") << "\n";
    
    return oss.str();
}

void SynchronizerV2::dumpClockInfo() const {
    std::lock_guard<std::mutex> lock(clockMutex_);
    
    Logger::instance().info("Clock Info Dump:");
    Logger::instance().info("  Audio - PTS: " + std::to_string(audioClock_.pts) + 
                           ", Speed: " + std::to_string(audioClock_.speed) + 
                           ", Paused: " + (audioClock_.paused ? "Yes" : "No"));
    Logger::instance().info("  Video - PTS: " + std::to_string(videoClock_.pts) + 
                           ", Speed: " + std::to_string(videoClock_.speed) + 
                           ", Paused: " + (videoClock_.paused ? "Yes" : "No"));
    Logger::instance().info("  External - PTS: " + std::to_string(externalClock_.pts) + 
                           ", Speed: " + std::to_string(externalClock_.speed) + 
                           ", Paused: " + (externalClock_.paused ? "Yes" : "No"));
}

// 私有方法实现

ErrorCode SynchronizerV2::updateClock(ClockType type, int64_t pts, double timeBase, int serial) {
    if (!initialized_) {
        return ErrorCode::NOT_INITIALIZED;
    }
    
    // 参考packets_sync.cpp的set_clock_at实现，确保与AVPlayer2一致
    double currentTime = getSystemTime();
    double ptsInSeconds = ptsToSeconds(pts, timeBase);
    
    // 在锁内更新时钟数据
    {
        std::lock_guard<std::mutex> lock(clockMutex_);
        
        ClockInfo* clock = nullptr;
        switch (type) {
            case ClockType::AUDIO:
                clock = &audioClock_;
                break;
            case ClockType::VIDEO:
                clock = &videoClock_;
                break;
            case ClockType::EXTERNAL:
                clock = &externalClock_;
                break;
            default:
                return ErrorCode::INVALID_PARAMS;
        }
        
        // 检查序列号，参考packets_sync.cpp的序列号检查机制
        if (serial != 0 && clock->serial != serial) {
            // 序列号不匹配，可能是seek操作，重置时钟
            resetClock(type);
            clock->serial = serial;
        }
        
        // 严格按照packets_sync.cpp的set_clock_at算法更新时钟
        if (pts != AV_NOPTS_VALUE) {
            // 参考packets_sync.cpp: clock->pts_drift = pts - time
            clock->pts_drift = ptsInSeconds - currentTime;
            clock->pts = ptsInSeconds;  // 存储转换后的秒值，与packets_sync.cpp一致
            clock->lastUpdate = currentTime;
        } else {
            clock->pts = std::numeric_limits<double>::quiet_NaN();
            clock->pts_drift = 0.0;
            clock->lastUpdate = currentTime;
        }
        
        clock->time = currentTime;
        clock->serial = serial;
        
        // 添加调试日志
        static int logCounter = 0;
        if (++logCounter % 100 == 0) { // 每100次更新记录一次
            std::string clockName = (type == ClockType::AUDIO) ? "Audio" : 
                                   (type == ClockType::VIDEO) ? "Video" : "External";
            Logger::instance().info("Clock Update [" + clockName + "]: PTS=" + 
                                  std::to_string(pts) + ", PTSSeconds=" + 
                                  std::to_string(ptsInSeconds) + ", SystemTime=" + 
                                  std::to_string(currentTime) + ", Drift=" + 
                                  std::to_string(clock->drift));
        }
        
        // 平滑处理（保持原有逻辑，但确保使用正确的PTS值）
        if (config_.smoothingWindow > 1) {
            clock->smoothedPts = smoothClock(type, static_cast<int64_t>(ptsInSeconds * AV_TIME_BASE));
        } else {
            clock->smoothedPts = static_cast<int64_t>(ptsInSeconds * AV_TIME_BASE);
        }
        
        // 更新历史记录（转换为AV_TIME_BASE格式）
        updateClockHistory(type, static_cast<int64_t>(ptsInSeconds * AV_TIME_BASE));
        
        // 如果这是主时钟，同步外部时钟到主时钟
        if (type == masterClockType_ && type != ClockType::EXTERNAL) {
            syncClockToSlave(&externalClock_, clock);
        }
        
        // 定期更新统计信息
        auto now = std::chrono::steady_clock::now();
        if (std::chrono::duration_cast<std::chrono::milliseconds>(now - lastStatsUpdate_).count() > 100) {
            updateStats();
            lastStatsUpdate_ = now;
        }
    } // 释放clockMutex_锁
    
    // 在锁外更新同步状态，避免死锁
    updateSyncState();
    
    return ErrorCode::SUCCESS;
}

int64_t SynchronizerV2::getClock(ClockType type, bool predict) const {
    std::lock_guard<std::mutex> lock(clockMutex_);
    
    const ClockInfo* clock = nullptr;
    switch (type) {
        case ClockType::AUDIO:
            clock = &audioClock_;
            break;
        case ClockType::VIDEO:
            clock = &videoClock_;
            break;
        case ClockType::EXTERNAL:
            clock = &externalClock_;
            break;
        case ClockType::SYSTEM:
            return static_cast<int64_t>(getSystemTime() * AV_TIME_BASE);
        default:
            return AV_NOPTS_VALUE;
    }
    
    // 严格按照packets_sync.cpp的get_clock实现
    // 检查时钟是否有效（pts不为NAN，与packets_sync.cpp一致）
    if (std::isnan(clock->pts)) {
        return AV_NOPTS_VALUE;
    }
    
    double clockValue;
    if (clock->paused) {
        // 暂停状态下，直接返回暂停时的PTS值
        clockValue = clock->pts;
    } else {
        // 运行状态下，使用packets_sync.cpp的get_clock算法
        // get_clock算法：pts_drift + time - (time - last_updated) * (1.0 - speed)
        // 等价于：pts + pts_drift + (current_time - last_updated) * speed
        double currentTime = av_gettime_relative() / 1000000.0;
        clockValue = clock->pts_drift + currentTime - (currentTime - clock->lastUpdate) * (1.0 - clock->speed);
    }
    
    // 转换为AV_TIME_BASE时间基准
    int64_t currentPts = static_cast<int64_t>(clockValue * AV_TIME_BASE);
    
    // 如果启用预测
    if (predict && config_.enablePrediction) {
        return predictClock(type, config_.predictionWindow);
    }
    
    return currentPts;
}

void SynchronizerV2::resetClock(ClockType type) {
    ClockInfo* clock = nullptr;
    switch (type) {
        case ClockType::AUDIO:
            clock = &audioClock_;
            break;
        case ClockType::VIDEO:
            clock = &videoClock_;
            break;
        case ClockType::EXTERNAL:
            clock = &externalClock_;
            break;
        default:
            return;
    }
    
    // 严格按照packets_sync.cpp的init_clock实现
    // init_clock调用set_clock(c, NAN, -1)，而set_clock使用av_gettime_relative
    double currentTime = av_gettime_relative() / 1000000.0;

    // 统一初始化所有时钟，与packets_sync.cpp保持一致
    clock->speed = 1.0;
    clock->paused = false;
    
    // 调用set_clock(c, NAN, -1)的等价操作
    clock->pts = std::numeric_limits<double>::quiet_NaN();  // 使用NAN，与packets_sync.cpp一致
    clock->pts_drift = clock->pts - currentTime;  // set_clock_at的逻辑
    clock->lastUpdate = currentTime;
    clock->serial = -1;
    
    // 保留SynchronizerV2特有的字段
    clock->time = currentTime;
    clock->drift = 0.0;
    clock->smoothedPts = AV_NOPTS_VALUE;
}

// 严格按照packets_sync.cpp的sync_clock_to_slave实现
void SynchronizerV2::syncClockToSlave(ClockInfo* slave, const ClockInfo* master) {
    if (!slave || !master) {
        return;
    }
    
    double currentTime = getSystemTime();
    
    // 计算主时钟当前值，使用packets_sync.cpp的get_clock算法
    double masterClock = std::numeric_limits<double>::quiet_NaN();
    if (!std::isnan(master->pts)) {
        if (master->paused) {
            masterClock = master->pts;
        } else {
            // 使用packets_sync.cpp的get_clock算法：pts_drift + time - (time - last_updated) * (1.0 - speed)
            masterClock = master->pts_drift + currentTime - (currentTime - master->lastUpdate) * (1.0 - master->speed);
        }
    }
    
    // 计算从时钟当前值，使用packets_sync.cpp的get_clock算法
    double slaveClock = std::numeric_limits<double>::quiet_NaN();
    if (!std::isnan(slave->pts)) {
        if (slave->paused) {
            slaveClock = slave->pts;
        } else {
            // 使用packets_sync.cpp的get_clock算法：pts_drift + time - (time - last_updated) * (1.0 - speed)
            slaveClock = slave->pts_drift + currentTime - (currentTime - slave->lastUpdate) * (1.0 - slave->speed);
        }
    }
    
    // 参考packets_sync.cpp的sync_clock_to_slave逻辑
    if (!std::isnan(masterClock) && 
        (std::isnan(slaveClock) || std::abs(masterClock - slaveClock) > config_.noSyncThreshold)) {
        // 按照packets_sync.cpp的set_clock_at算法同步从时钟到主时钟
        slave->pts = masterClock;
        slave->pts_drift = masterClock - currentTime;
        slave->lastUpdate = currentTime;
        slave->serial = master->serial;
        
        // 保留SynchronizerV2特有的字段
        slave->time = currentTime;
        slave->drift = masterClock - currentTime;
    }
}

void SynchronizerV2::pauseClock(ClockType type, bool pause) {
    ClockInfo* clock = nullptr;
    switch (type) {
        case ClockType::AUDIO:
            clock = &audioClock_;
            break;
        case ClockType::VIDEO:
            clock = &videoClock_;
            break;
        case ClockType::EXTERNAL:
            clock = &externalClock_;
            break;
        default:
            return;
    }
    
    if (clock->paused != pause) {
        double currentTime = getSystemTime();
        
        if (pause) {
            // 暂停时保存当前PTS，使用packets_sync.cpp的get_clock算法计算当前值
            if (!clock->paused && !std::isnan(clock->pts)) {
                clock->pts = clock->pts_drift + currentTime - (currentTime - clock->lastUpdate) * (1.0 - clock->speed);
                clock->pts_drift = 0.0;  // 暂停后drift重置为0
            }
        } else {
            // 恢复时重新设置pts_drift，参考packets_sync.cpp的set_clock_at
            if (!std::isnan(clock->pts)) {
                clock->pts_drift = clock->pts - currentTime;
            }
        }
        
        clock->paused = pause;
        clock->lastUpdate = currentTime;
        clock->time = currentTime;  // 保留SynchronizerV2特有字段
    }
}

void SynchronizerV2::selectMasterClock() {
    ClockType newMasterClock = masterClockType_;
    
    switch (config_.strategy) {
        case SyncStrategy::AUDIO_MASTER:
            newMasterClock = ClockType::AUDIO;
            break;
            
        case SyncStrategy::VIDEO_MASTER:
            newMasterClock = ClockType::VIDEO;
            break;
            
        case SyncStrategy::EXTERNAL_MASTER:
            newMasterClock = ClockType::EXTERNAL;
            break;
            
        case SyncStrategy::ADAPTIVE: {
            // 参考AVPlayer2的自适应主时钟选择算法
            if (config_.enableAdaptiveSync) {
                bool hasAudio = (hasAudioStream_ && !std::isnan(audioClock_.pts) && !audioClock_.paused);
                 bool hasVideo = (hasVideoStream_ && !std::isnan(videoClock_.pts) && !videoClock_.paused);
                 
                 if (hasAudio && hasVideo) {
                     // 音视频都存在时，评估时钟质量
                     double currentTime = getSystemTime();
                     
                     // 计算音频时钟的稳定性
                     double audioStability = 1.0;
                     if (audioClock_.time > 0) {
                         double audioAge = currentTime - audioClock_.time;
                         audioStability = std::exp(-audioAge / 2.0); // 2秒衰减
                     }
                     
                     // 计算视频时钟的稳定性
                     double videoStability = 1.0;
                     if (videoClock_.time > 0) {
                         double videoAge = currentTime - videoClock_.time;
                         videoStability = std::exp(-videoAge / 2.0); // 2秒衰减
                     }
                     
                     // 考虑时钟漂移
                     double audioDrift = std::abs(audioClock_.drift);
                     double videoDrift = std::abs(videoClock_.drift);
                     
                     // 音频时钟通常更稳定，给予优先权
                     double audioScore = audioStability * 1.2 / (1.0 + audioDrift * 10.0);
                     double videoScore = videoStability / (1.0 + videoDrift * 10.0);
                     
                     if (audioScore > videoScore && audioScore > 0.3) {
                         newMasterClock = ClockType::AUDIO;
                     } else if (videoScore > 0.3) {
                         newMasterClock = ClockType::VIDEO;
                     } else {
                         newMasterClock = ClockType::EXTERNAL;
                     }
                 } else if (hasAudio) {
                     // 只有音频
                     newMasterClock = ClockType::AUDIO;
                 } else if (hasVideo) {
                     // 只有视频
                     newMasterClock = ClockType::VIDEO;
                 } else {
                     // 都没有，使用外部时钟
                     newMasterClock = ClockType::EXTERNAL;
                 }
            } else {
                // 简单逻辑：优先音频，但要检查时钟有效性
                bool hasValidAudio = (hasAudioStream_ && !std::isnan(audioClock_.pts));
                bool hasValidVideo = (hasVideoStream_ && !std::isnan(videoClock_.pts));
                
                if (hasValidAudio) {
                    newMasterClock = ClockType::AUDIO;
                } else if (hasValidVideo) {
                    newMasterClock = ClockType::VIDEO;
                } else {
                    // 音视频时钟都无效，使用外部时钟
                    newMasterClock = ClockType::EXTERNAL;
                }
            }
            break;
        }
    }
    
    // 如果选择外部时钟作为主时钟，但外部时钟无效，则初始化它
    if (newMasterClock == ClockType::EXTERNAL && std::isnan(externalClock_.pts)) {
        double currentTime = av_gettime_relative() / 1000000.0;
        externalClock_.pts = currentTime;
        externalClock_.pts_drift = 0.0;
        externalClock_.lastUpdate = currentTime;
        externalClock_.time = currentTime;
        externalClock_.serial = 0;
        externalClock_.paused = false;
        externalClock_.speed = 1.0;
        externalClock_.drift = 0.0;
        
        Logger::instance().info("External clock initialized as master with current time: " + std::to_string(currentTime));
    }
    
    // 只有当主时钟真正改变时才更新和记录日志
    if (newMasterClock != masterClockType_) {
        ClockType oldMasterClock = masterClockType_;
        masterClockType_ = newMasterClock;
        
        // 获取时钟状态信息用于调试
        std::string audioStatus = "invalid";
        std::string videoStatus = "invalid";
        std::string externalStatus = "invalid";
        
        if (!std::isnan(audioClock_.pts)) {
            audioStatus = "valid(pts=" + std::to_string(audioClock_.pts) + ")";
        }
        if (!std::isnan(videoClock_.pts)) {
            videoStatus = "valid(pts=" + std::to_string(videoClock_.pts) + ")";
        }
        if (!std::isnan(externalClock_.pts)) {
            externalStatus = "valid(pts=" + std::to_string(externalClock_.pts) + ")";
        }
        
        Logger::instance().info("Master clock changed from "
                                + std::to_string(static_cast<int>(oldMasterClock))
                                + " to " + std::to_string(static_cast<int>(masterClockType_.load()))
                                + " (hasAudio=" + std::to_string(hasAudioStream_.load())
                                + ", hasVideo=" + std::to_string(hasVideoStream_.load())
                                + ", audio=" + audioStatus
                                + ", video=" + videoStatus
                                + ", external=" + externalStatus + ")");
    }
}

void SynchronizerV2::updateSyncState() {
    if (!running_) {
        state_ = SyncState::IDLE;
        return;
    }
    
    if (paused_) {
        return;
    }
    
    double syncError = calculateSyncErrorInternal();
    
    SyncState newState = state_;
    bool needRecovery = false;
    
    // 参考AVPlayer2的同步状态管理算法
    if (syncError <= config_.syncThreshold) {
        // 同步误差在可接受范围内
        if (state_ == SyncState::RECOVERING || state_ == SyncState::INITIALIZING) {
            // 从恢复或初始化状态转为同步状态
            newState = SyncState::SYNCHRONIZED;
            recoveryAttempts_ = 0;
        } else if (state_ != SyncState::SYNCHRONIZED) {
            newState = SyncState::SYNCHRONIZED;
        }
    } else if (syncError <= config_.adaptiveThreshold) {
        // 轻微漂移状态
        if (state_ == SyncState::SYNCHRONIZED) {
            newState = SyncState::DRIFT;
        } else if (state_ == SyncState::RECOVERING) {
            // 恢复中但误差仍较大，继续恢复
            double recoveryDuration = getCurrentTime() - recoveryStartTime_;
            if (recoveryDuration > 3.0) { // 3秒恢复超时
                if (recoveryAttempts_ < config_.maxRecoveryAttempts) {
                    needRecovery = true;
                } else {
                    newState = SyncState::ERROR;
                }
            }
        }
    } else if (syncError <= config_.maxSyncError) {
        // 同步误差较大但仍在可恢复范围内
        if (state_ != SyncState::RECOVERING) {
            newState = SyncState::ERROR;
            if (recoveryAttempts_ < config_.maxRecoveryAttempts) {
                needRecovery = true;
                newState = SyncState::RECOVERING;
            }
        } else {
            // 已在恢复状态，检查恢复超时
            double recoveryDuration = getCurrentTime() - recoveryStartTime_;
            if (recoveryDuration > 5.0) { // 5秒恢复超时
                if (recoveryAttempts_ < config_.maxRecoveryAttempts) {
                    needRecovery = true;
                } else {
                    newState = SyncState::ERROR;
                }
            }
        }
    } else {
        // 同步误差过大
        newState = SyncState::ERROR;
        // 标记需要恢复，但不在这里直接调用attemptRecovery避免死锁
        if (recoveryAttempts_ < config_.maxRecoveryAttempts) {
            needRecovery = true;
            newState = SyncState::RECOVERING;
        }
    }
    
    // 检查长时间失同步的情况
    if (newState == SyncState::ERROR && recoveryAttempts_ >= config_.maxRecoveryAttempts) {
        static double lastResetTime = 0;
        double currentTime = getCurrentTime();
        if (currentTime - lastResetTime > 10.0) { // 10秒重置一次
            // 尝试重新初始化同步
            recoveryAttempts_ = 0;
            newState = SyncState::INITIALIZING;
            lastResetTime = currentTime;
            Logger::instance().warning("Sync error persists, attempting full reset");
        }
    }
    
    if (newState != state_) {
        SyncState oldState = state_;
        state_ = newState;
        notifyStateChange(newState);
        
        Logger::instance().info("Sync state changed from " + std::to_string(static_cast<int>(oldState)) + 
                               " to " + std::to_string(static_cast<int>(newState)));
    }
    
    // 如果需要恢复，现在可以安全地调用恢复操作（因为updateSyncState现在在锁外被调用）
    if (needRecovery) {
        performDelayedRecovery();
    }
}

void SynchronizerV2::updateStats() {
    // 统计信息在其他方法中已经更新
}

int64_t SynchronizerV2::smoothClock(ClockType type, int64_t newPts) {
    std::lock_guard<std::mutex> lock(historyMutex_);
    
    std::deque<int64_t>* history = nullptr;
    switch (type) {
        case ClockType::AUDIO:
            history = &audioClockHistory_;
            break;
        case ClockType::VIDEO:
            history = &videoClockHistory_;
            break;
        default:
            return newPts;
    }
    
    if (history->empty() || newPts == AV_NOPTS_VALUE) {
        return newPts;
    }
    
    // 简单的指数移动平均
    int64_t lastSmoothed = history->back();
    if (lastSmoothed == AV_NOPTS_VALUE) {
        return newPts;
    }
    
    double smoothed = static_cast<double>(lastSmoothed) * (1.0 - config_.smoothingFactor) + 
                     static_cast<double>(newPts) * config_.smoothingFactor;
    return static_cast<int64_t>(smoothed);
}

int64_t SynchronizerV2::predictClock(ClockType type, double futureTime) const {
    // 注意：此方法假设调用者已经持有clockMutex_锁
    // 不能再调用getClock，否则会导致死锁
    
    const ClockInfo* clock = nullptr;
    switch (type) {
        case ClockType::AUDIO:
            clock = &audioClock_;
            break;
        case ClockType::VIDEO:
            clock = &videoClock_;
            break;
        case ClockType::EXTERNAL:
            clock = &externalClock_;
            break;
        default:
            return AV_NOPTS_VALUE;
    }
    
    if (clock->paused || std::isnan(clock->pts)) {
        return static_cast<int64_t>(clock->pts * AV_TIME_BASE);
    }
    
    // 计算当前时间（不调用getClock避免死锁），使用packets_sync.cpp的get_clock算法
    double currentTime = getSystemTime();
    // 使用packets_sync.cpp的算法：pts + pts_drift + (current_time - last_updated) * speed
    double currentPtsSeconds = clock->pts + clock->pts_drift + (currentTime - clock->lastUpdate) * clock->speed;
    
    return static_cast<int64_t>((currentPtsSeconds + futureTime * clock->speed) * AV_TIME_BASE);
}

void SynchronizerV2::updateClockHistory(ClockType type, int64_t pts) {
    std::lock_guard<std::mutex> lock(historyMutex_);
    
    std::deque<int64_t>* history = nullptr;
    switch (type) {
        case ClockType::AUDIO:
            history = &audioClockHistory_;
            break;
        case ClockType::VIDEO:
            history = &videoClockHistory_;
            break;
        default:
            return;
    }
    
    history->push_back(pts);
    while (history->size() > static_cast<size_t>(config_.smoothingWindow)) {
        history->pop_front();
    }
}

void SynchronizerV2::attemptRecovery() {
    recoveryAttempts_++;
    lastRecoveryTime_ = std::chrono::steady_clock::now();
    
    Logger::instance().warning("Attempting sync recovery, attempt: " + std::to_string(recoveryAttempts_));
    
    // 重置时钟漂移
    {
        std::lock_guard<std::mutex> lock(clockMutex_);
        audioClock_.drift = 0.0;
        videoClock_.drift = 0.0;
        externalClock_.drift = 0.0;
    }
    
    // 可能需要重新选择主时钟（在锁外面调用避免死锁）
    if (config_.enableAdaptiveSync) {
        selectMasterClock();
    }
}

void SynchronizerV2::performDelayedRecovery() {
    // 这个方法在不持有clockMutex_的情况下被调用
    // 执行实际的恢复操作
    
    // 检查恢复间隔，避免过于频繁的恢复
    auto now = std::chrono::steady_clock::now();
    auto timeSinceLastRecovery = std::chrono::duration<double>(now - lastRecoveryTime_).count();
    if (timeSinceLastRecovery < 1.0) { // 至少间隔1秒
        return;
    }
    
    recoveryAttempts_++;
    lastRecoveryTime_ = now;
    
    Logger::instance().warning("Performing delayed sync recovery, attempt: " + std::to_string(recoveryAttempts_));
    
    // 重置时钟漂移
    {
        std::lock_guard<std::mutex> lock(clockMutex_);
        audioClock_.drift = 0.0;
        videoClock_.drift = 0.0;
        externalClock_.drift = 0.0;
    }
    
    // 只有在恢复次数较少时才重新选择主时钟，避免频繁切换
    if (config_.enableAdaptiveSync && recoveryAttempts_ <= 3) {
        selectMasterClock();
    }
}

double SynchronizerV2::getCurrentTime() const {
    auto now = std::chrono::steady_clock::now();
    return std::chrono::duration<double>(now - startTime_).count();
}

double SynchronizerV2::getSystemTime() const {
    return av_gettime_relative() / 1000000.0;
}

void SynchronizerV2::notifyStateChange(SyncState newState) {
    if (syncEventCallback_) {
        syncEventCallback_(state_, newState);
    }
}

void SynchronizerV2::notifyFrameDrop(ClockType type, int64_t pts) {
    if (frameDropCallback_) {
        frameDropCallback_(type, pts);
    }
}

void SynchronizerV2::notifyFrameDuplicate(ClockType type, int64_t pts) {
    if (frameDuplicateCallback_) {
        frameDuplicateCallback_(type, pts);
    }
}

void SynchronizerV2::notifySyncError(double error, const std::string& reason) {
    if (syncErrorCallback_) {
        syncErrorCallback_(error, reason);
    }
}

// PTS转换辅助方法实现
double SynchronizerV2::ptsToSeconds(int64_t pts, double timeBase) const {
    if (pts == AV_NOPTS_VALUE) {
        return 0.0;
    }
    return pts * timeBase;
}

int64_t SynchronizerV2::secondsToPts(double seconds, double timeBase) const {
    if (timeBase <= 0.0) {
        return AV_NOPTS_VALUE;
    }
    return static_cast<int64_t>(seconds / timeBase);
}

} // namespace utils
} // namespace av