/*

 * Copyright (c) 2023, kleines Filmröllchen <filmroellchen@serenityos.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#pragma once

#include <AK/Error.h>

#include <AK/NonnullOwnPtr.h>

#include <AK/Span.h>

#include <AK/Types.h>

#include <LibAudio/Loader.h>

#include <LibAudio/QOATypes.h>

#include <LibAudio/SampleFormats.h>

namespace Audio {

// Decoder for the Quite Okay Audio (QOA) format.

// NOTE: The QOA format is not finalized yet and this decoder might not be fully spec-compliant as of 2023-02-02.

//

// https://github.com/phoboslab/qoa/blob/master/qoa.h

class QOALoaderPlugin : public LoaderPlugin {

public:

    explicit QOALoaderPlugin(NonnullOwnPtr<AK::SeekableStream> stream);

    virtual ~QOALoaderPlugin() override = default;

    static bool sniff(SeekableStream& stream);

    static ErrorOr<NonnullOwnPtr<LoaderPlugin>, LoaderError> create(NonnullOwnPtr<SeekableStream>);

    virtual ErrorOr<Vector<FixedArray<Sample>>, LoaderError> load_chunks(size_t samples_to_read_from_input) override;

    virtual MaybeLoaderError reset() override;

    virtual MaybeLoaderError seek(int sample_index) override;

    virtual int loaded_samples() override { return static_cast<int>(m_loaded_samples); }

    virtual int total_samples() override { return static_cast<int>(m_total_samples); }

    virtual u32 sample_rate() override { return m_sample_rate; }

    virtual u16 num_channels() override { return m_num_channels; }

    virtual ByteString format_name() override { return "Quite Okay Audio (.qoa)"; }

    virtual PcmSampleFormat pcm_format() override { return PcmSampleFormat::Int16; }

private:

    enum class IsFirstFrame : bool {

        Yes = true,

        No = false,

    };

    MaybeLoaderError initialize();

    MaybeLoaderError parse_header();

    MaybeLoaderError load_one_frame(Span<Sample>& target, IsFirstFrame is_first_frame = IsFirstFrame::No);

    // Updates predictor values in lms_state so the next slice can reuse the same state.

    MaybeLoaderError read_one_slice(QOA::LMSState& lms_state, Span<i16>& samples);

    static ALWAYS_INLINE QOA::UnpackedSlice unpack_slice(QOA::PackedSlice packed_slice);

    // QOA's division routine for scaling residuals before final quantization.

    static ALWAYS_INLINE i16 qoa_divide(i16 value, i16 scale_factor);

    // Because QOA has dynamic sample rate and channel count, we only use the sample rate and channel count from the first frame.

    u32 m_sample_rate { 0 };

    u8 m_num_channels { 0 };

    // If this is the case (the reference encoder even enforces it at the moment)

    bool m_has_uniform_channel_count { true };

    size_t m_loaded_samples { 0 };

    size_t m_total_samples { 0 };

};

}