#include "SimplePlayerWindow.h"
#include <QFileDialog>
#include <QMessageBox>
#include <QDebug>
#include <QFileInfo>

SimplePlayerWindow::SimplePlayerWindow(QWidget *parent)
    : QMainWindow(parent)
    , m_playerAdapter(PlayerAdapterFactory::create(this))
    , m_videoRenderer(nullptr)
{
    setupUI();
    connectSignals();
    updateUI();
    
    // 设置视频渲染器
    if (m_videoRenderer && m_playerAdapter) {
        m_playerAdapter->setVideoRenderer(m_videoRenderer);
    }
    
    setWindowTitle("Simple Media Player");
    resize(800, 600);
}

SimplePlayerWindow::~SimplePlayerWindow()
{
    if (m_playerAdapter) {
        m_playerAdapter->stop();
    }
}

void SimplePlayerWindow::openFile()
{
    QString filename = QFileDialog::getOpenFileName(
        this,
        "Open Media File",
        "",
        "Media Files (*.mp4 *.avi *.mkv *.mov *.wmv *.flv *.webm *.mp3 *.wav *.aac *.flac *.ogg);;All Files (*.*)"
    );
    
    if (!filename.isEmpty()) {
        av::ErrorCode result = m_playerAdapter->openFile(filename);
        if (result != av::ErrorCode::OK) {
            QMessageBox::critical(this, "Error", "Failed to open file: " + filename);
        } else {
            m_fileLabel->setText("File: " + QFileInfo(filename).fileName());
        }
    }
}

void SimplePlayerWindow::playPause()
{
    PlayerState state = m_playerAdapter->getState();
    
    if (state == PlayerState::Playing) {
        m_playerAdapter->pause();
    } else if (state == PlayerState::Paused || state == PlayerState::Stopped) {
        m_playerAdapter->play();
    }
}

void SimplePlayerWindow::stop()
{
    m_playerAdapter->stop();
}

void SimplePlayerWindow::seek()
{
    if (m_seeking) {
        qint64 duration = m_playerAdapter->getDuration();
        qint64 position = (duration * m_positionSlider->value()) / 1000;
        m_playerAdapter->seek(position);
    }
}

void SimplePlayerWindow::setVolume()
{
    double volume = m_volumeSlider->value() / 100.0;
    m_playerAdapter->setVolume(volume);
    m_volumeLabel->setText(QString("Volume: %1%").arg(m_volumeSlider->value()));
}

void SimplePlayerWindow::toggleMute()
{
    bool muted = m_playerAdapter->isMuted();
    m_playerAdapter->setMuted(!muted);
}

void SimplePlayerWindow::setPlaybackSpeed()
{
    double speed = m_speedSlider->value() / 100.0;
    m_playerAdapter->setPlaybackSpeed(speed);
    m_speedLabel->setText(QString("Speed: %1x").arg(speed, 0, 'f', 2));
}

void SimplePlayerWindow::onStateChanged(PlayerState state)
{
    QString stateText;
    switch (state) {
        case PlayerState::Idle:
            stateText = "Idle";
            break;
        // case PlayerState::Loading:
        //     stateText = "Loading";
        //     break;
        case PlayerState::Playing:
            stateText = "Playing";
            break;
        case PlayerState::Paused:
            stateText = "Paused";
            break;
        case PlayerState::Stopped:
            stateText = "Stopped";
            break;
        case PlayerState::Error:
            stateText = "Error";
            break;
    }
    
    m_stateLabel->setText("State: " + stateText);
    updateUI();
}

void SimplePlayerWindow::onMediaInfoChanged(const MediaInfo& info)
{
    QString infoText = QString("Duration: %1 | Video: %2x%3 | Audio: %4 Hz")
                           .arg(formatTime(info.duration))
                           .arg(info.width)
                           .arg(info.height)
                           .arg(info.audioSampleRate);

    m_infoLabel->setText(infoText);
}

void SimplePlayerWindow::onPositionChanged(qint64 position)
{
    if (!m_seeking) {
        qint64 duration = m_playerAdapter->getDuration();
        if (duration > 0) {
            int sliderValue = (position * 1000) / duration;
            m_positionSlider->setValue(sliderValue);
        }
        
        QString timeText = QString("%1 / %2")
                               .arg(formatTime(position))
                               .arg(formatTime(duration));
        m_timeLabel->setText(timeText);
    }
}

void SimplePlayerWindow::onVolumeChanged(double volume)
{
    int volumePercent = static_cast<int>(volume * 100);
    m_volumeSlider->setValue(volumePercent);
    m_volumeLabel->setText(QString("Volume: %1%").arg(volumePercent));
}

void SimplePlayerWindow::onMutedChanged(bool muted)
{
    m_muteButton->setText(muted ? "Unmute" : "Mute");
}

void SimplePlayerWindow::onPlaybackSpeedChanged(double speed)
{
    int speedPercent = static_cast<int>(speed * 100);
    m_speedSlider->setValue(speedPercent);
    m_speedLabel->setText(QString("Speed: %1x").arg(speed, 0, 'f', 2));
}

void SimplePlayerWindow::onErrorOccurred(const QString& error)
{
    QMessageBox::critical(this, "Player Error", error);
    qDebug() << "Player error:" << error;
}

void SimplePlayerWindow::onStatsUpdated(const PlaybackStats& stats)
{
    QString statsText = QString("Packets: %1 | Video Frames: %2 | Audio Frames: %3")
                            .arg(stats.queuedPackets)
                            .arg(stats.queuedVideoFrames)
                            .arg(stats.queuedAudioFrames);
    
    m_statsLabel->setText(statsText);
}

void SimplePlayerWindow::setupUI()
{
    auto* centralWidget = new QWidget(this);
    setCentralWidget(centralWidget);

    auto* mainLayout = new QVBoxLayout(centralWidget);

    // 文件信息
    m_fileLabel = new QLabel("No file loaded");
    m_stateLabel = new QLabel("State: Idle");
    m_infoLabel = new QLabel("Media info will appear here");

    mainLayout->addWidget(m_fileLabel);
    mainLayout->addWidget(m_stateLabel);
    mainLayout->addWidget(m_infoLabel);
    
    // 视频渲染器
    m_videoRenderer = new VideoRenderer(this);
    m_videoRenderer->setMinimumSize(640, 480);
    m_videoRenderer->setStyleSheet("border: 1px solid gray;");
    mainLayout->addWidget(m_videoRenderer);

    // 控制按钮
    auto* buttonLayout = new QHBoxLayout();

    m_openButton = new QPushButton("Open File");
    m_playPauseButton = new QPushButton("Play");
    m_stopButton = new QPushButton("Stop");

    buttonLayout->addWidget(m_openButton);
    buttonLayout->addWidget(m_playPauseButton);
    buttonLayout->addWidget(m_stopButton);
    buttonLayout->addStretch();

    mainLayout->addLayout(buttonLayout);

    // 进度控制
    auto* progressLayout = new QHBoxLayout();

    m_timeLabel = new QLabel("00:00 / 00:00");
    m_positionSlider = new QSlider(Qt::Horizontal);
    m_positionSlider->setRange(0, 1000);

    progressLayout->addWidget(m_timeLabel);
    progressLayout->addWidget(m_positionSlider);

    mainLayout->addLayout(progressLayout);

    // 音量控制
    auto* volumeLayout = new QHBoxLayout();

    m_volumeLabel = new QLabel("Volume: 100%");
    m_volumeSlider = new QSlider(Qt::Horizontal);
    m_volumeSlider->setRange(0, 100);
    m_volumeSlider->setValue(100);
    m_muteButton = new QPushButton("Mute");

    volumeLayout->addWidget(m_volumeLabel);
    volumeLayout->addWidget(m_volumeSlider);
    volumeLayout->addWidget(m_muteButton);

    mainLayout->addLayout(volumeLayout);

    // 播放速度控制
    auto* speedLayout = new QHBoxLayout();

    m_speedLabel = new QLabel("Speed: 1.00x");
    m_speedSlider = new QSlider(Qt::Horizontal);
    m_speedSlider->setRange(25, 400); // 0.25x to 4.0x
    m_speedSlider->setValue(100);

    speedLayout->addWidget(m_speedLabel);
    speedLayout->addWidget(m_speedSlider);

    mainLayout->addLayout(speedLayout);

    // 统计信息
    m_statsLabel = new QLabel("Statistics will appear here");
    mainLayout->addWidget(m_statsLabel);

    mainLayout->addStretch();
}

void SimplePlayerWindow::connectSignals()
{
    // UI信号
    connect(m_openButton, &QPushButton::clicked, this, &SimplePlayerWindow::openFile);
    connect(m_playPauseButton, &QPushButton::clicked, this, &SimplePlayerWindow::playPause);
    connect(m_stopButton, &QPushButton::clicked, this, &SimplePlayerWindow::stop);

    connect(m_positionSlider, &QSlider::sliderPressed, [this]() { m_seeking = true; });
    connect(m_positionSlider, &QSlider::sliderReleased, [this]() {
        seek();
        m_seeking = false;
    });

    connect(m_volumeSlider, &QSlider::valueChanged, this, &SimplePlayerWindow::setVolume);
    connect(m_muteButton, &QPushButton::clicked, this, &SimplePlayerWindow::toggleMute);
    connect(m_speedSlider, &QSlider::valueChanged, this, &SimplePlayerWindow::setPlaybackSpeed);

    // 播放器信号
    connect(m_playerAdapter.get(),
            &PlayerAdapter::stateChanged,
            this,
            &SimplePlayerWindow::onStateChanged);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::mediaInfoChanged,
            this,
            &SimplePlayerWindow::onMediaInfoChanged);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::positionChanged,
            this,
            &SimplePlayerWindow::onPositionChanged);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::volumeChanged,
            this,
            &SimplePlayerWindow::onVolumeChanged);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::mutedChanged,
            this,
            &SimplePlayerWindow::onMutedChanged);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::playbackSpeedChanged,
            this,
            &SimplePlayerWindow::onPlaybackSpeedChanged);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::errorOccurred,
            this,
            &SimplePlayerWindow::onErrorOccurred);
    connect(m_playerAdapter.get(),
            &PlayerAdapter::statsUpdated,
            this,
            &SimplePlayerWindow::onStatsUpdated);
}

void SimplePlayerWindow::updateUI()
{
    PlayerState state = m_playerAdapter->getState();

    // 更新播放/暂停按钮
    if (state == PlayerState::Playing) {
        m_playPauseButton->setText("Pause");
    } else {
        m_playPauseButton->setText("Play");
    }

    // 更新按钮可用状态
    bool hasMedia = (state != PlayerState::Idle);
    m_playPauseButton->setEnabled(hasMedia);
    m_stopButton->setEnabled(hasMedia);
    m_positionSlider->setEnabled(hasMedia);
}

QString SimplePlayerWindow::formatTime(qint64 microseconds)
{
    qint64 seconds = microseconds / 1000000;
    qint64 minutes = seconds / 60;
    seconds %= 60;

    return QString("%1:%2").arg(minutes, 2, 10, QChar('0')).arg(seconds, 2, 10, QChar('0'));
}