// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include <qffmpegclock_p.h>
#include <qloggingcategory.h>

static Q_LOGGING_CATEGORY(qLcClock, "qt.multimedia.ffmpeg.clock")

QT_BEGIN_NAMESPACE

static bool compareClocks(const QFFmpeg::Clock *a, const QFFmpeg::Clock *b)
{
    if (!b)
        return false;

    if (!a)
        return true;

    return a->type() < b->type();
}

QFFmpeg::Clock::Clock(ClockController *controller)
    : controller(controller)
{
    Q_ASSERT(controller);
    controller->addClock(this);
}

QFFmpeg::Clock::~Clock()
{
    if (controller)
        controller->removeClock(this);
}

qint64 QFFmpeg::Clock::currentTime() const
{
    return controller ? controller->currentTime() : 0;
}

void QFFmpeg::Clock::syncTo(qint64 time)
{
    qCDebug(qLcClock) << "syncTo" << time << isMaster();
}

void QFFmpeg::Clock::setPlaybackRate(float rate, qint64 currentTime)
{
    qCDebug(qLcClock) << "Clock::setPlaybackRate" << rate;
    Q_UNUSED(rate)
    Q_UNUSED(currentTime)
}

void QFFmpeg::Clock::setPaused(bool paused)
{
    qCDebug(qLcClock) << "Clock::setPaused" << paused;
    Q_UNUSED(paused)
}

qint64 QFFmpeg::Clock::timeUpdated(qint64 currentTime)
{
    if (controller)
        return controller->timeUpdated(this, currentTime);
    return currentTime;
}

qint64 QFFmpeg::Clock::usecsTo(qint64 currentTime, qint64 displayTime)
{
    if (!controller || controller->m_isPaused)
        return -1;
    const qint64 t = qRound64((displayTime - currentTime) / playbackRate());
    return t < 0 ? 0 : t;
}

QFFmpeg::Clock::Type QFFmpeg::Clock::type() const
{
    return SystemClock;
}

QFFmpeg::ClockController::~ClockController()
{
    for (auto *p : std::as_const(m_clocks))
        p->setController(nullptr);
}

qint64 QFFmpeg::ClockController::timeUpdated(Clock *clock, qint64 time)
{
    QMutexLocker l(&m_mutex);
    if (!isMaster(clock)) {
        // If the clock isn't the master clock, simply return the current time
        // so we can make adjustments as needed
        return currentTimeNoLock();
    }

    // if the clock is the master, adjust our base timing
    m_baseTime = time;
    m_elapsedTimer.restart();

    return time;
}

void QFFmpeg::ClockController::addClock(Clock *clock)
{
    qCDebug(qLcClock) << "addClock" << clock;
    Q_ASSERT(clock != nullptr);

    if (m_clocks.contains(clock))
        return;

    m_clocks.append(clock);
    m_master = std::max(m_master.loadAcquire(), clock, compareClocks);

    clock->syncTo(currentTime());
    clock->setPaused(m_isPaused);
}

void QFFmpeg::ClockController::removeClock(Clock *clock)
{
    qCDebug(qLcClock) << "removeClock" << clock;
    m_clocks.removeAll(clock);
    if (m_master == clock) {
        // find a new master clock
        m_master = m_clocks.empty()
                ? nullptr
                : *std::max_element(m_clocks.begin(), m_clocks.end(), compareClocks);
    }
}

bool QFFmpeg::ClockController::isMaster(const Clock *clock) const
{
    return m_master.loadAcquire() == clock;
}

qint64 QFFmpeg::ClockController::currentTimeNoLock() const
{
    return m_isPaused ? m_baseTime : m_baseTime + m_elapsedTimer.elapsed() / m_playbackRate;
}

qint64 QFFmpeg::ClockController::currentTime() const
{
    QMutexLocker l(&m_mutex);
    return currentTimeNoLock();
}

void QFFmpeg::ClockController::syncTo(qint64 usecs)
{
    {
        QMutexLocker l(&m_mutex);
        qCDebug(qLcClock) << "syncTo" << usecs;
        m_baseTime = usecs;
        m_seekTime = usecs;
        m_elapsedTimer.restart();
    }

    for (auto *p : std::as_const(m_clocks))
        p->syncTo(usecs);
}

void QFFmpeg::ClockController::setPlaybackRate(float rate)
{
    qint64 baseTime = 0;
    {
        qCDebug(qLcClock) << "setPlaybackRate" << rate;

        QMutexLocker l(&m_mutex);

        m_baseTime = baseTime = currentTimeNoLock();
        m_elapsedTimer.restart();
        m_playbackRate = rate;
    }

    for (auto *p : std::as_const(m_clocks))
        p->setPlaybackRate(rate, baseTime);
}

void QFFmpeg::ClockController::setPaused(bool paused)
{
    {
        QMutexLocker l(&m_mutex);
        if (m_isPaused == paused)
            return;
        qCDebug(qLcClock) << "setPaused" << paused;
        m_isPaused = paused;
        if (m_isPaused) {
            m_baseTime = currentTimeNoLock();
            m_seekTime = m_baseTime;
        } else {
            m_elapsedTimer.restart();
        }
    }

    for (auto *p : std::as_const(m_clocks))
        p->setPaused(paused);
}

QT_END_NAMESPACE
