// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "recordingrunner.h"

/// Base

RecordingRunner::RecordingRunner(const RecorderSettings &recorderSettings)
{
    if (recorderSettings.frameRate)
        m_recorder.setVideoFrameRate(recorderSettings.frameRate);
    if (recorderSettings.resolution.isValid())
        m_recorder.setVideoResolution(recorderSettings.resolution);
    if (recorderSettings.quality)
        m_recorder.setQuality(*recorderSettings.quality);
    if (!recorderSettings.outputLocation.isEmpty())
        m_recorder.setOutputLocation(recorderSettings.outputLocation);
    if (recorderSettings.fileFormat || recorderSettings.audioCodec || recorderSettings.videoCodec) {
        QMediaFormat format;
        if (recorderSettings.fileFormat)
            format.setFileFormat(*recorderSettings.fileFormat);
        if (recorderSettings.videoCodec)
            format.setVideoCodec(*recorderSettings.videoCodec);
        if (recorderSettings.audioCodec)
            format.setAudioCodec(*recorderSettings.audioCodec);
        m_recorder.setMediaFormat(format);
    }

    m_recorder.setAutoStop(true);

    connect(&m_recorder, &QMediaRecorder::recorderStateChanged, this,
            &RecordingRunner::handleRecorderStateChanged);
    connect(&m_recorder, &QMediaRecorder::errorOccurred, this, &RecordingRunner::handleError);

    m_session.setRecorder(&m_recorder);
}

RecordingRunner::~RecordingRunner() = default;

void RecordingRunner::run()
{
    m_recorder.record();
}

void RecordingRunner::handleRecorderStateChanged(QMediaRecorder::RecorderState state)
{
    if (state == QMediaRecorder::RecordingState) {
        qInfo() << "Starting recording to" << m_recorder.actualLocation();
    } else if (state == QMediaRecorder::StoppedState) {
        const bool noError = m_recorder.error() == QMediaRecorder::NoError;
        qInfo() << "The recording to" << m_recorder.actualLocation() << "has been finished"
                << (noError ? "" : "with an error");

        emit finished();
    }
}

void RecordingRunner::handleError(QMediaRecorder::Error error, QString description)
{
    qWarning() << "Recoding error occurred:" << error << description;

    if (m_recorder.recorderState() == QMediaRecorder::StoppedState)
        emit finished();
}

/// Pull mode

PullModeRecordingRunner::PullModeRecordingRunner(
        const RecorderSettings &recorderSettings,
        const AudioGeneratorSettingsOpt &audioGeneratorSettings,
        const VideoGeneratorSettingsOpt &videoGeneratorSettings)
    : RecordingRunner(recorderSettings)
{
    Q_ASSERT(audioGeneratorSettings || videoGeneratorSettings);

    if (audioGeneratorSettings) {
        m_audioGenerator = std::make_unique<AudioGenerator>(*audioGeneratorSettings);
        m_audioInput = std::make_unique<QAudioBufferInput>();
        connect(m_audioInput.get(), &QAudioBufferInput::readyToSendAudioBuffer, this,
                &PullModeRecordingRunner::sendNextAudioBuffer);
        session().setAudioBufferInput(m_audioInput.get());
    }

    if (videoGeneratorSettings) {
        m_videoGenerator = std::make_unique<VideoGenerator>(*videoGeneratorSettings);
        m_videoInput = std::make_unique<QVideoFrameInput>();
        connect(m_videoInput.get(), &QVideoFrameInput::readyToSendVideoFrame, this,
                &PullModeRecordingRunner::sendNextVideoFrame);
        session().setVideoFrameInput(m_videoInput.get());
    }
}

void PullModeRecordingRunner::sendNextAudioBuffer()
{
    const bool result = m_audioInput->sendAudioBuffer(m_audioGenerator->generate());
    Q_ASSERT(result);
}

void PullModeRecordingRunner::sendNextVideoFrame()
{
    const bool result = m_videoInput->sendVideoFrame(m_videoGenerator->generate());
    Q_ASSERT(result);
}

/// Push mode

PushModeRecordingRunner::PushModeRecordingRunner(
        const RecorderSettings &recorderSettings,
        const AudioGeneratorSettingsOpt &audioGeneratorSettings,
        const VideoGeneratorSettingsOpt &videoGeneratorSettings,
        const PushModeSettings &pushModeSettings)
    : RecordingRunner(recorderSettings)
{
    if (audioGeneratorSettings) {
        m_audioBufferInputQueue =
                std::make_unique<AudioBufferInputQueue>(pushModeSettings.maxQueueSize);
        session().setAudioBufferInput(m_audioBufferInputQueue->mediaFrameInput());
        m_audioBufferSource = std::make_unique<AudioBufferSource>(*audioGeneratorSettings,
                                                                  pushModeSettings.producingRate);
        m_audioBufferSource->addFrameReceivedCallback(&AudioBufferInputQueue::pushMediaFrame,
                                                      m_audioBufferInputQueue.get());
    }

    if (videoGeneratorSettings) {
        m_videoFrameInputQueue =
                std::make_unique<VideoFrameInputQueue>(pushModeSettings.maxQueueSize);
        session().setVideoFrameInput(m_videoFrameInputQueue->mediaFrameInput());
        m_videoFrameSource = std::make_unique<VideoFrameSource>(*videoGeneratorSettings,
                                                                pushModeSettings.producingRate);
        m_videoFrameSource->addFrameReceivedCallback(&VideoFrameInputQueue::pushMediaFrame,
                                                     m_videoFrameInputQueue.get());
    }

    connect(this, &RecordingRunner::finished, this, &PushModeRecordingRunner::onFinished);
}

PushModeRecordingRunner::~PushModeRecordingRunner() = default;

void PushModeRecordingRunner::onFinished()
{
    m_audioBufferSource.reset();
    m_videoFrameSource.reset();
}

void PushModeRecordingRunner::run()
{
    if (m_audioBufferSource)
        m_audioBufferSource->run();
    if (m_videoFrameSource)
        m_videoFrameSource->run();
    RecordingRunner::run();
}

#include "moc_recordingrunner.cpp"