#include "audio_recorder.h"

#include "capturer/audio/audio_qt_capturer.h"

AudioRecorder::AudioRecorder() {}

AudioRecorder::~AudioRecorder()
{
    Close();
}

bool AudioRecorder::Open(const std::vector<AudioCapturer::Type>& deviceTypes,
                         Encoder<MediaType::AUDIO>::Param& param,
                         const uint32_t sampleRate,
                         const uint32_t channels,
                         const uint32_t bitsPerSample,
                         const AVSampleFormat format)
{
    Close();
    Info mixInfo;
    mixInfo.mixer = &_mixer;
    mixInfo.isRecord = &_isRecord;
    mixInfo.streamIndex = &_streamIndex;

    // 清空并重新创建音频捕获器
    m_audioCapturers.clear();
    for (int index = 0; index < deviceTypes.size(); ++index) {
        mixInfo.mixIndex = index;
        _infos.push_back(mixInfo);
        m_audioCapturers.push_back(new QtAudioCapturer());
    }

    // 初始化每个音频捕获器
    for (int index = 0; index < deviceTypes.size(); ++index) {
        auto capturer = m_audioCapturers[index];
        if (!capturer->Init(deviceTypes[index], _Callback, &(_infos[index]))) {
            continue;
        }
        auto&& format = capturer->GetFormat();
        __CheckBool(_mixer.AddAudioInput(index,
                                         format.sampleRate,
                                         format.channels,
                                         format.bitsPerSample,
                                         _GetAVSampleFormat(format.bitsPerSample)));
    }

    __CheckBool(_mixer.AddAudioOutput(sampleRate, channels, bitsPerSample, format));
    _param = param;
    __CheckBool(_mixer.SetOutFrameSize(1024));

    // 启动所有成功初始化的音频捕获器
    for (int index = 0; index < deviceTypes.size(); ++index) {
        if (_mixer.GetInputInfo(index) != nullptr) {
            __CheckBool(m_audioCapturers[index]->Start());
        }
    }

    return true;
}

void AudioRecorder::Close()
{
    StopRecord();

    // 停止并释放所有音频捕获器
    for (auto capturer : m_audioCapturers) {
        if (capturer) {
            capturer->Stop();
            delete capturer;
        }
    }
    m_audioCapturers.clear();

    _mixer.Close();
    _infos.clear();
}

void AudioRecorder::SetVolumeScale(float scale, int mixIndex)
{
    auto info = _mixer.GetInputInfo(mixIndex);
    if (info != nullptr) {
        info->scale = scale;
    }
}

bool AudioRecorder::LoadMuxer(AvMuxer& muxer)
{
    for (auto&& info : _infos) {
        info.muxer = &muxer;
    }
    __CheckBool((_streamIndex = muxer.AddAudioStream(_param)) != -1);
    return true;
}

bool AudioRecorder::StartRecord()
{
    _isRecord = true;
    return true;
}

void AudioRecorder::StopRecord()
{
    _isRecord = false;
}

void AudioRecorder::_Callback(void* data, size_t size, void* userInfo)
{
    if (!data || size == 0 || !userInfo) {
        return;
    }

    Info* info = static_cast<Info*>(userInfo);
    if (!info->mixer || !info->isRecord) {
        return;
    }

    // 添加调试输出
    // qDebug() << "AudioRecorder: 收到音频数据，大小:" << size << "字节，混音索引:" << info->mixIndex;

    /* auto inputInfo =*/info->mixer->GetInputInfo(info->mixIndex);
    auto frame = info->mixer->Convert(info->mixIndex, (uint8_t*) data, size);
    if (frame == nullptr) {
        return;
    }
    if (*(info->isRecord)) {
        __CheckNo(info->streamIndex && *(info->streamIndex) != -1);
        int frameSize = info->muxer->GetCodecCtx(*info->streamIndex)->frame_size;
        if (info->mixer->GetOutFrameSize() != frameSize) {
            __DebugPrint("Change frame size from %d to %d",
                         info->mixer->GetOutFrameSize(),
                         frameSize);
            info->mixer->SetOutFrameSize(frameSize);
            return;
        }
        __CheckNo(info->muxer->Write(frame, *(info->streamIndex)));
    }
}