/*
 * Copyright (c) 2023, Jelle Raaijmakers <jelle@gmta.nl>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include "Codec.h"
#include <AK/Array.h>
#include <Kernel/Devices/Audio/IntelHDA/Controller.h>

namespace Kernel::Audio::IntelHDA {

// 7.3.4.7: Supported PCM Size, Rates
struct BitRateEncoding {
    u8 flag;
    u8 bit_rate;
};
static constexpr Array<BitRateEncoding, 5> bit_rate_encodings { {
    // clang-format off
    { 0x1,  8 },
    { 0x2,  16 },
    { 0x4,  20 },
    { 0x8,  24 },
    { 0x10, 32 },
    // clang-format on
} };

struct SampleRateEncoding {
    u16 flag;
    u32 sample_rate;
};
static constexpr Array<SampleRateEncoding, 12> sample_rate_encodings { {
    // clang-format off
    { 0x1,     8'000 },
    { 0x2,    11'025 },
    { 0x4,    16'000 },
    { 0x8,    22'050 },
    { 0x10,   32'000 },
    { 0x20,   44'100 },
    { 0x40,   48'000 },
    { 0x80,   88'200 },
    { 0x100,  96'000 },
    { 0x200, 176'400 },
    { 0x400, 192'000 },
    { 0x800, 384'000 },
    // clang-format on
} };

ErrorOr<void> Codec::register_node(NonnullRefPtr<Node> node)
{
    auto set_result = TRY(m_nodes_by_node_id.try_set(node->node_id(), node));
    VERIFY(set_result == HashSetResult::InsertedNewEntry);
    return {};
}

ErrorOr<void> Node::initialize()
{
    return codec().register_node(*this);
}

ErrorOr<u32> Node::command(CodecControlVerb verb, u16 payload)
{
    auto& node_codec = codec();
    return node_codec.controller().send_command(node_codec.codec_address(), m_node_id, verb, payload);
}

ErrorOr<u32> Node::parameter(GetParameterId get_parameter_id)
{
    return command(CodecControlVerb::GetParameter, to_underlying(get_parameter_id));
}

ErrorOr<void> Node::set_power_state(PowerState power_state)
{
    // 7.3.3.10: Power State
    TRY(command(CodecControlVerb::SetPowerState, to_underlying(power_state)));
    return {};
}

template<typename T>
void NodeWithChildren<T>::for_each_child_node(Function<void(T const&, bool)> callback) const
{
    auto number_of_child_nodes = m_child_nodes.size();
    for (size_t child_index = 0; child_index < number_of_child_nodes; ++child_index)
        callback(m_child_nodes[child_index], child_index == number_of_child_nodes - 1);
}

template<typename T>
ErrorOr<void> NodeWithChildren<T>::initialize()
{
    TRY(Node::initialize());
    return populate_child_nodes();
}

template<typename T>
ErrorOr<void> NodeWithChildren<T>::populate_child_nodes()
{
    VERIFY(m_child_nodes.is_empty());

    // 7.3.4.3: Subordinate Node Count
    auto subordinate_node_count = TRY(parameter(GetParameterId::SubordinateNodeCount));
    u8 starting_node_number = (subordinate_node_count >> 16) & 0xff;
    u8 total_number_of_nodes = subordinate_node_count & 0xff;
    TRY(m_child_nodes.try_ensure_capacity(total_number_of_nodes));
    for (int subnode_index = 0; subnode_index < total_number_of_nodes; ++subnode_index)
        m_child_nodes.unchecked_append(TRY(Node::create<T>(*this, starting_node_number + subnode_index)));
    return {};
}

StringView WidgetNode::widget_type_name() const
{
    switch (m_widget_type) {
    case WidgetType::AudioInput:
        return "Audio Input"sv;
    case WidgetType::AudioMixer:
        return "Audio Mixer"sv;
    case WidgetType::AudioOutput:
        return "Audio Output"sv;
    case WidgetType::AudioSelector:
        return "Audio Selector"sv;
    case WidgetType::BeepGenerator:
        return "Beep Generator"sv;
    case WidgetType::PinComplex:
        return "Pin Complex"sv;
    case WidgetType::Power:
        return "Power"sv;
    case WidgetType::VendorDefined:
        return "Vendor Defined"sv;
    case WidgetType::VolumeKnob:
        return "Volume Knob"sv;
    }
    return "Reserved"sv;
}

ErrorOr<void> WidgetNode::initialize()
{
    TRY(Node::initialize());

    // 7.3.4.6: Audio Widget Capabilities
    auto widget_capabilities = TRY(parameter(GetParameterId::AudioWidgetCapabilities));
    m_widget_type = static_cast<WidgetType>((widget_capabilities >> 20) & 0xf);
    m_channel_count = (((widget_capabilities >> 15) & 0xe) | (widget_capabilities & 0x1)) + 1;
    m_power_control_supported = (widget_capabilities & WidgetCapabilityFlag::PowerControlSupported) > 0;
    m_connection_list_present = (widget_capabilities & WidgetCapabilityFlag::ConnectionListPresent) > 0;
    m_format_override = (widget_capabilities & WidgetCapabilityFlag::FormatOverride) > 0;
    m_amp_param_override = (widget_capabilities & WidgetCapabilityFlag::AmpParamOverride) > 0;
    m_output_amp_present = (widget_capabilities & WidgetCapabilityFlag::OutputAmpPresent) > 0;
    m_input_amp_present = (widget_capabilities & WidgetCapabilityFlag::InputAmpPresent) > 0;

    if (supports_stream()) {
        // 7.3.3.11: Converter Stream, Channel
        auto stream_channel = TRY(command(CodecControlVerb::GetConverterStreamChannel, 0));
        m_selected_stream = (stream_channel >> 4) & 0xf;
        m_selected_channel = stream_channel & 0xf;

        TRY(populate_supported_pcm_size_rates());
        TRY(populate_supported_stream_formats());
    }

    // 7.3.4.10: Amplifier Capabilities
    auto read_amp_capabilities = [](Node& node, GetParameterId type) -> ErrorOr<AmplifierCapabilities> {
        auto capabilities = TRY(node.parameter(type));
        return AmplifierCapabilities {
            .muting_supported = ((capabilities >> 31) & 0x1) > 0,
            .step_size = static_cast<u8>((capabilities >> 16) & 0x7f),
            .number_of_steps = static_cast<u8>(((capabilities >> 8) & 0x7f) + 1),
            .offset = static_cast<u8>(capabilities & 0x7f),
        };
    };
    Node& amp_params_node = amp_param_override() ? *this : *parent_node();
    if (output_amp_present())
        m_output_amp_capabilities = TRY(read_amp_capabilities(amp_params_node, GetParameterId::OutputAmplifierCapabilities));
    if (input_amp_present())
        m_input_amp_capabilities = TRY(read_amp_capabilities(amp_params_node, GetParameterId::InputAmplifierCapabilities));

    if (widget_type() == WidgetType::PinComplex) {
        // 7.3.4.9: Pin Capabilities
        auto pin_capabilities = TRY(parameter(GetParameterId::PinCapabilities));
        m_pin_complex_input_supported = (pin_capabilities & PinCapabilityFlag::InputCapable) > 0;
        m_pin_complex_output_supported = (pin_capabilities & PinCapabilityFlag::OutputCapable) > 0;

        TRY(populate_pin_configuration_default());
    }

    // Connection list
    if (connection_list_present())
        TRY(populate_connection_list());

    return {};
}

ErrorOr<NonnullOwnPtr<KString>> WidgetNode::to_string()
{
    StringBuilder builder;
    TRY(builder.try_appendff("WidgetNode(node_id={}, type={})", node_id(), widget_type_name()));
    return KString::try_create(builder.string_view());
}

void WidgetNode::debug_dump(StringView group_spine, bool is_last) const
{
    dbgln("{} {} Widget (node #{}):", group_spine, is_last ? "└"sv : "├"sv, node_id());
    auto spine = is_last ? " "sv : "│"sv;
    dbgln("{} {} ├ Type: {} ({:#x})", group_spine, spine, widget_type_name(), to_underlying(widget_type()));
    dbgln("{} {} ├ Channel count: {}", group_spine, spine, channel_count());
    dbgln("{} {} ├ Power control supported: {}", group_spine, spine, m_power_control_supported ? "yes"sv : "no"sv);

    if (supports_stream()) {
        dbgln("{} {} ├ Selected stream: {}", group_spine, spine, selected_stream());
        if (channel_count() == 1)
            dbgln("{} {} ├ Selected channel: {}", group_spine, spine, selected_channel());
        else
            dbgln("{} {} ├ Selected channels: {}-{}", group_spine, spine, selected_channel(), selected_channel() + channel_count() - 1);

        dbgln("{} {} ├ Format override: {}", group_spine, spine, format_override() ? "yes"sv : "no"sv);
        dbgln("{} {} ├ Supported PCM bit sizes:", group_spine, spine);
        for (auto supported_size : supported_pcm_sizes())
            dbgln("{} {} │ • {}", group_spine, spine, supported_size);

        dbgln("{} {} ├ Supported PCM rates:", group_spine, spine);
        for (auto supported_rate : supported_pcm_rates())
            dbgln("{} {} │ • {}Hz", group_spine, spine, supported_rate);

        dbgln("{} {} ├ Supported stream formats:", group_spine, spine);
        if (has_flag(supported_stream_formats(), StreamFormatFlag::PCM))
            dbgln("{} {} │ • PCM", group_spine, spine);
        if (has_flag(supported_stream_formats(), StreamFormatFlag::Float32))
            dbgln("{} {} │ • Float32", group_spine, spine);
        if (has_flag(supported_stream_formats(), StreamFormatFlag::AC3))
            dbgln("{} {} │ • AC3", group_spine, spine);
    }

    dbgln("{} {} ├ Amplifier parameters override: {}", group_spine, spine, amp_param_override() ? "yes"sv : "no"sv);
    dbgln("{} {} ├ Output amplifier present: {}", group_spine, spine, output_amp_present() ? "yes"sv : "no"sv);
    if (output_amp_present()) {
        auto amp_capabilities = output_amp_capabilities();
        dbgln("{} {} │ ├ Muting supported: {}", group_spine, spine, amp_capabilities.muting_supported ? "yes"sv : "no"sv);
        dbgln("{} {} │ ├ Step size: {}", group_spine, spine, amp_capabilities.step_size);
        dbgln("{} {} │ ├ Number of steps: {}", group_spine, spine, amp_capabilities.number_of_steps);
        dbgln("{} {} │ └ Offset: {}", group_spine, spine, amp_capabilities.offset);
    }

    dbgln("{} {} ├ Input amplifier present: {}", group_spine, spine, input_amp_present() ? "yes"sv : "no"sv);
    if (input_amp_present()) {
        auto amp_capabilities = input_amp_capabilities();
        dbgln("{} {} │ ├ Muting supported: {}", group_spine, spine, amp_capabilities.muting_supported ? "yes"sv : "no"sv);
        dbgln("{} {} │ ├ Step size: {}", group_spine, spine, amp_capabilities.step_size);
        dbgln("{} {} │ ├ Number of steps: {}", group_spine, spine, amp_capabilities.number_of_steps);
        dbgln("{} {} │ └ Offset: {}", group_spine, spine, amp_capabilities.offset);
    }

    if (widget_type() == WidgetType::PinComplex) {
        dbgln("{} {} ├ Pin complex input supported: {}", group_spine, spine, pin_complex_input_supported());
        dbgln("{} {} ├ Pin complex output supported: {}", group_spine, spine, pin_complex_output_supported());
        dbgln("{} {} ├ Pin configuration default:", group_spine, spine);
        dbgln("{} {} │ ├ Sequence: {}", group_spine, spine, m_pin_configuration_default.sequence);
        dbgln("{} {} │ ├ Default association: {}", group_spine, spine, m_pin_configuration_default.default_association);
        dbgln("{} {} │ ├ Jack detect override: {}", group_spine, spine,
            ((static_cast<u8>(m_pin_configuration_default.misc) & to_underlying(PinMiscFlag::JackDetectOverride)) > 0) ? "yes"sv : "no"sv);
        dbgln("{} {} │ ├ Color: {}", group_spine, spine, pin_color_name());
        dbgln("{} {} │ ├ Connection type: {}", group_spine, spine, pin_connection_type_name());
        dbgln("{} {} │ ├ Default device: {}", group_spine, spine, pin_default_device_name());
        dbgln("{} {} │ ├ Location: {}, {}", group_spine, spine, pin_gross_location_name(), pin_geometric_location_name());
        dbgln("{} {} │ └ Port connectivity: {}", group_spine, spine, pin_port_connectivity_name());
    }

    dbgln("{} {} └ Connection list:{}", group_spine, spine, connection_list_present() ? ""sv : " absent"sv);
    if (connection_list_present()) {
        auto selected_node_id = connection_selected_node_id();
        auto all_active = !supports_connection_select_control();
        for (auto connection_entry : connection_list()) {
            dbgln("{} {}   • Node #{}{}", group_spine, spine, connection_entry,
                all_active || connection_entry == selected_node_id ? " (active)"sv : ""sv);
        }
    }
}

ErrorOr<void> WidgetNode::set_amplifier_gain_mute(SetAmplifierGainMute settings)
{
    // 7.3.3.7: Amplifier Gain/Mute
    VERIFY(input_amp_present() || output_amp_present());
    u16 set_amp_gain_payload = ((output_amp_present() ? 1 : 0) << 15)
        | ((input_amp_present() ? 1 : 0) << 15)
        | ((settings.set_left ? 1 : 0) << 13)
        | ((settings.set_right ? 1 : 0) << 12)
        | ((settings.connection_index & 0xf) << 8)
        | ((settings.mute ? 1 : 0) << 7)
        | (settings.gain & 0x7f);
    TRY(command(CodecControlVerb::SetAmplifierGainMute, set_amp_gain_payload));
    return {};
}

ErrorOr<void> WidgetNode::set_connection_select(u8 connection_index)
{
    // 7.3.3.2: Connection Select Control
    VERIFY(connection_list_present());
    VERIFY(connection_index < connection_list().size());
    TRY(command(CodecControlVerb::SetConnectionSelectControl, connection_index));
    return {};
}

ErrorOr<void> WidgetNode::set_converter_stream_and_channel(u8 stream_index, u8 channel_index)
{
    // 7.3.3.11: Converter Stream, Channel
    VERIFY(widget_type() == WidgetType::AudioInput || widget_type() == WidgetType::AudioOutput);
    u16 stream_channel_payload = ((stream_index & 0xf) << 4) | (channel_index & 0xf);
    TRY(command(CodecControlVerb::SetConverterStreamChannel, stream_channel_payload));
    return {};
}

ErrorOr<void> WidgetNode::set_pin_control(PinControl pin_control)
{
    // 7.3.3.13: Pin Widget Control
    VERIFY(widget_type() == WidgetType::PinComplex);
    VERIFY(!pin_control.output_enabled || pin_complex_output_supported());
    VERIFY(!pin_control.input_enabled || pin_complex_input_supported());

    u8 payload = ((pin_control.low_impedance_amplifier_enabled ? 1 : 0) << 7)
        | ((pin_control.output_enabled ? 1 : 0) << 6)
        | ((pin_control.input_enabled ? 1 : 0) << 5)
        | (pin_control.voltage_reference_enable & 0x7);
    TRY(command(CodecControlVerb::SetPinWidgetControl, payload));
    return {};
}

bool WidgetNode::supports_stream() const
{
    return widget_type() == WidgetType::AudioInput
        || widget_type() == WidgetType::AudioOutput;
}

bool WidgetNode::supports_connection_select_control() const
{
    return widget_type() == WidgetType::AudioInput
        || widget_type() == WidgetType::AudioSelector
        || widget_type() == WidgetType::PinComplex;
}

ErrorOr<FormatParameters> WidgetNode::get_converter_format()
{
    // 7.3.3.8: Converter Format
    VERIFY(widget_type() == WidgetType::AudioInput || widget_type() == WidgetType::AudioOutput);
    u16 format = TRY(command(CodecControlVerb::GetConverterFormat, 0)) & 0xffffu;
    return decode_format(format);
}

ErrorOr<void> WidgetNode::set_converter_format(FormatParameters format)
{
    // 7.3.3.8: Converter Format
    VERIFY(widget_type() == WidgetType::AudioInput || widget_type() == WidgetType::AudioOutput);
    u16 format_payload = TRY(encode_format(format));
    TRY(command(CodecControlVerb::SetConverterFormat, format_payload));
    return {};
}

ErrorOr<void> WidgetNode::populate_supported_pcm_size_rates()
{
    VERIFY(m_supported_pcm_sizes.is_empty() && m_supported_pcm_rates.is_empty());

    // 7.3.4.7: Supported PCM Size, Rates
    Node& stream_support_node = format_override() ? *this : *parent_node();
    auto supported_pcm_size_and_rates = TRY(stream_support_node.parameter(GetParameterId::SupportedPCMSizeRates));

    auto pcm_sizes = (supported_pcm_size_and_rates >> 16) & 0x1f;
    TRY(m_supported_pcm_sizes.try_ensure_capacity(popcount(pcm_sizes)));
    for (auto bit_rate_encoding : bit_rate_encodings) {
        if ((pcm_sizes & bit_rate_encoding.flag) > 0)
            m_supported_pcm_sizes.unchecked_append(bit_rate_encoding.bit_rate);
    }

    auto pcm_rates = supported_pcm_size_and_rates & 0x7ff;
    TRY(m_supported_pcm_rates.try_ensure_capacity(popcount(pcm_rates)));
    for (auto sample_rate_encoding : sample_rate_encodings) {
        if ((pcm_rates & sample_rate_encoding.flag) > 0)
            m_supported_pcm_rates.unchecked_append(sample_rate_encoding.sample_rate);
    }

    return {};
}

ErrorOr<void> WidgetNode::populate_supported_stream_formats()
{
    VERIFY(m_supported_stream_formats == 0);

    // 7.3.4.8: Supported Stream Formats
    Node& stream_support_node = format_override() ? *this : *parent_node();
    auto supported_stream_formats = TRY(stream_support_node.parameter(GetParameterId::SupportedStreamFormats));

    if ((supported_stream_formats & 0x1) > 0)
        m_supported_stream_formats |= StreamFormatFlag::PCM;
    if ((supported_stream_formats & 0x2) > 0)
        m_supported_stream_formats |= StreamFormatFlag::Float32;
    if ((supported_stream_formats & 0x4) > 0)
        m_supported_stream_formats |= StreamFormatFlag::AC3;

    return {};
}

ErrorOr<void> WidgetNode::populate_connection_list()
{
    VERIFY(connection_list_present());
    VERIFY(m_connection_list.is_empty());

    // 7.3.4.11: Connection List Length
    auto connection_list_length_info = TRY(parameter(GetParameterId::ConnectionListLength));
    bool long_form = (connection_list_length_info >> 7) & 0x1;
    u8 connection_list_length = connection_list_length_info & 0x7f;
    u8 entries_per_request = long_form ? 2 : 4;

    // 7.3.3.3: Get Connection List Entry
    for (u8 entry_offset = 0; entry_offset < connection_list_length; entry_offset += entries_per_request) {
        auto entries = TRY(command(CodecControlVerb::GetConnectionListEntry, entry_offset));
        for (u8 entry_index = 0; entry_index < min(entries_per_request, static_cast<int>(connection_list_length) - entry_offset); ++entry_index) {
            u16 entry = entries & (long_form ? 0xffff : 0xff);
            TRY(m_connection_list.try_append(entry));
            entries >>= (32 / entries_per_request);
        }
    }

    // 7.1.3: Widget Interconnection Rules
    //         "Connection_List_Length = 1 means there is only one (hard-wired) input possible and,
    //          therefore, there is no Connection_Selector field. The actual connection is read
    //          from the Connection List as usual."
    if (connection_list_length == 1) {
        m_connection_index = 0;
    } else {
        // 7.3.3.2: Connection Select Control
        auto connection_selection_control = TRY(command(CodecControlVerb::GetConnectionSelectControl, 0));
        m_connection_index = connection_selection_control & 0xff;
    }

    return {};
}

ErrorOr<void> WidgetNode::populate_pin_configuration_default()
{
    VERIFY(widget_type() == WidgetType::PinComplex);

    u32 configuration_default = TRY(command(CodecControlVerb::GetConfigurationDefault, 0));
    m_pin_configuration_default.sequence = configuration_default & 0xf;
    m_pin_configuration_default.default_association = (configuration_default >> 4) & 0xf;
    m_pin_configuration_default.misc = static_cast<PinMiscFlag>((configuration_default >> 8) & 0xf);
    m_pin_configuration_default.color = static_cast<PinColor>((configuration_default >> 12) & 0xf);
    m_pin_configuration_default.connection_type = static_cast<PinConnectionType>((configuration_default >> 16) & 0xf);
    m_pin_configuration_default.default_device = static_cast<PinDefaultDevice>((configuration_default >> 20) & 0xf);
    m_pin_configuration_default.geometric_location = static_cast<PinGeometricLocation>((configuration_default >> 24) & 0xf);
    m_pin_configuration_default.gross_location = static_cast<PinGrossLocation>((configuration_default >> 28) & 0x3);
    m_pin_configuration_default.port_connectivity = static_cast<PinPortConnectivity>(configuration_default >> 30);

    return {};
}

StringView WidgetNode::pin_color_name() const
{
    auto underlying_color = to_underlying(m_pin_configuration_default.color);
    if (underlying_color >= 0xa && underlying_color <= 0xd)
        return "Reserved"sv;

    switch (m_pin_configuration_default.color) {
    case PinColor::Unknown:
        return "Unknown"sv;
    case PinColor::Black:
        return "Black"sv;
    case PinColor::Grey:
        return "Grey"sv;
    case PinColor::Blue:
        return "Blue"sv;
    case PinColor::Green:
        return "Green"sv;
    case PinColor::Red:
        return "Red"sv;
    case PinColor::Orange:
        return "Orange"sv;
    case PinColor::Yellow:
        return "Yellow"sv;
    case PinColor::Purple:
        return "Purple"sv;
    case PinColor::Pink:
        return "Pink"sv;
    case PinColor::White:
        return "White"sv;
    case PinColor::Other:
        return "Other"sv;
    }
    VERIFY_NOT_REACHED();
}

StringView WidgetNode::pin_connection_type_name() const
{
    switch (m_pin_configuration_default.connection_type) {
    case PinConnectionType::Unknown:
        return "Unknown"sv;
    case PinConnectionType::EighthStereoMono:
        return "1/8\" Stereo/Mono"sv;
    case PinConnectionType::FourthStereoMono:
        return "1/4\" Stereo/Mono"sv;
    case PinConnectionType::ATAPIInternal:
        return "ATAPI Internal"sv;
    case PinConnectionType::RCA:
        return "RCA"sv;
    case PinConnectionType::Optical:
        return "Optical"sv;
    case PinConnectionType::OtherDigital:
        return "Other Digital"sv;
    case PinConnectionType::OtherAnalog:
        return "Other Analog"sv;
    case PinConnectionType::MultichannelAnalog:
        return "Multichannel Analog"sv;
    case PinConnectionType::XLRProfessional:
        return "XLR / Professional"sv;
    case PinConnectionType::RJ11:
        return "RJ-11 (Modem)"sv;
    case PinConnectionType::Combination:
        return "Combination"sv;
    case PinConnectionType::Other:
        return "Other"sv;
    }
    VERIFY_NOT_REACHED();
}

StringView WidgetNode::pin_default_device_name() const
{
    switch (m_pin_configuration_default.default_device) {
    case PinDefaultDevice::LineOut:
        return "Line Out"sv;
    case PinDefaultDevice::Speaker:
        return "Speaker"sv;
    case PinDefaultDevice::HPOut:
        return "Headphones"sv;
    case PinDefaultDevice::CD:
        return "CD"sv;
    case PinDefaultDevice::SPDIFOut:
        return "S/PDIF Out"sv;
    case PinDefaultDevice::DigitalOtherOut:
        return "Digital Other Out"sv;
    case PinDefaultDevice::ModemLineSide:
        return "Modem Line Side"sv;
    case PinDefaultDevice::ModemHandsetSide:
        return "Modem Handset Side"sv;
    case PinDefaultDevice::LineIn:
        return "Line In"sv;
    case PinDefaultDevice::AUX:
        return "AUX"sv;
    case PinDefaultDevice::MicIn:
        return "Mic In"sv;
    case PinDefaultDevice::Telephony:
        return "Telephony"sv;
    case PinDefaultDevice::SPDIFIn:
        return "S/PDIF In"sv;
    case PinDefaultDevice::DigitalOtherIn:
        return "Digital Other In"sv;
    case PinDefaultDevice::Reserved:
        return "Reserved"sv;
    case PinDefaultDevice::Other:
        return "Other"sv;
    }
    VERIFY_NOT_REACHED();
}

StringView WidgetNode::pin_gross_location_name() const
{
    switch (m_pin_configuration_default.gross_location) {
    case PinGrossLocation::ExternalOnPrimaryChassis:
        return "External on Primary Chassis"sv;
    case PinGrossLocation::Internal:
        return "Internal"sv;
    case PinGrossLocation::SeparateChassis:
        return "Separate Chassis"sv;
    case PinGrossLocation::Other:
        return "Other"sv;
    }
    VERIFY_NOT_REACHED();
}

StringView WidgetNode::pin_geometric_location_name() const
{
    // 7.3.3.31: Configuration Default - special cases
    if (m_pin_configuration_default.geometric_location == PinGeometricLocation::Special1) {
        if (m_pin_configuration_default.gross_location == PinGrossLocation::ExternalOnPrimaryChassis)
            return "Rear Panel"sv;
        if (m_pin_configuration_default.gross_location == PinGrossLocation::Internal)
            return "Riser"sv;
        if (m_pin_configuration_default.gross_location == PinGrossLocation::Other)
            return "Mobile Lid (Inside)"sv;
    } else if (m_pin_configuration_default.geometric_location == PinGeometricLocation::Special2) {
        if (m_pin_configuration_default.gross_location == PinGrossLocation::ExternalOnPrimaryChassis)
            return "Drive Bay"sv;
        if (m_pin_configuration_default.gross_location == PinGrossLocation::Internal)
            return "Digital Display"sv;
        if (m_pin_configuration_default.gross_location == PinGrossLocation::Other)
            return "Mobile Lid (Outside)"sv;
    } else if (m_pin_configuration_default.geometric_location == PinGeometricLocation::Special3) {
        if (m_pin_configuration_default.gross_location == PinGrossLocation::Internal)
            return "ATAPI"sv;
    }

    switch (m_pin_configuration_default.geometric_location) {
    case PinGeometricLocation::NotApplicable:
        return "N/A"sv;
    case PinGeometricLocation::Rear:
        return "Rear"sv;
    case PinGeometricLocation::Front:
        return "Front"sv;
    case PinGeometricLocation::Left:
        return "Left"sv;
    case PinGeometricLocation::Right:
        return "Right"sv;
    case PinGeometricLocation::Top:
        return "Top"sv;
    case PinGeometricLocation::Bottom:
        return "Bottom"sv;
    case PinGeometricLocation::Special1:
    case PinGeometricLocation::Special2:
    case PinGeometricLocation::Special3:
        return "Special"sv;
    }
    VERIFY_NOT_REACHED();
}

StringView WidgetNode::pin_port_connectivity_name() const
{
    switch (m_pin_configuration_default.port_connectivity) {
    case PinPortConnectivity::Jack:
        return "Jack"sv;
    case PinPortConnectivity::NoConnection:
        return "No Physical Connection"sv;
    case PinPortConnectivity::FixedFunction:
        return "Fixed Function Device"sv;
    case PinPortConnectivity::JackAndFixedFunction:
        return "Jack and Fixed Function Device"sv;
    }
    VERIFY_NOT_REACHED();
}

StringView FunctionGroupNode::function_group_type_name() const
{
    switch (m_function_group_type) {
    case FunctionGroupType::AudioFunctionGroup:
        return "Audio Function Group"sv;
    case FunctionGroupType::ModemFunctionGroup:
        return "Modem Function Group"sv;
    case FunctionGroupType::VendorFunctionGroup:
        return "Vendor Function Group"sv;
    case FunctionGroupType::Reserved:
        return "Reserved"sv;
    }
    VERIFY_NOT_REACHED();
}

ErrorOr<void> FunctionGroupNode::initialize()
{
    TRY(NodeWithChildren<WidgetNode>::initialize());

    // 7.3.4.4: Function Group Type
    auto function_group_type = TRY(parameter(GetParameterId::FunctionGroupType));
    if (function_group_type == 0x1)
        m_function_group_type = FunctionGroupType::AudioFunctionGroup;
    else if (function_group_type == 0x2)
        m_function_group_type = FunctionGroupType::ModemFunctionGroup;
    else if (function_group_type >= 0x80)
        m_function_group_type = FunctionGroupType::VendorFunctionGroup;
    else
        m_function_group_type = FunctionGroupType::Reserved;

    return {};
}

ErrorOr<NonnullOwnPtr<KString>> FunctionGroupNode::to_string()
{
    StringBuilder builder;
    TRY(builder.try_appendff("FunctionGroupNode(node_id={})", node_id()));
    return KString::try_create(builder.string_view());
}

void FunctionGroupNode::debug_dump(bool is_last) const
{
    dbgln("{} Function group (node #{}):", is_last ? "└"sv : "├"sv, node_id());
    auto spine = is_last ? " "sv : "│"sv;
    dbgln("{} ├ Function group type: {} ({:#x})", spine, function_group_type_name(), to_underlying(function_group_type()));

    for_each_child_node([&spine](WidgetNode const& widget_node, bool is_last) -> void {
        widget_node.debug_dump(spine, is_last);
    });
}

ErrorOr<void> RootNode::initialize()
{
    TRY(NodeWithChildren<FunctionGroupNode>::initialize());

    // 7.3.4.1: Vendor ID
    auto vendor_id_response = TRY(parameter(GetParameterId::VendorID));
    m_vendor_id = (vendor_id_response >> 16) & 0xffff;
    m_device_id = vendor_id_response & 0xffff;

    // 7.3.4.2: Revision ID
    auto revision_id_response = TRY(parameter(GetParameterId::RevisionID));
    m_major_revision = (revision_id_response >> 20) & 0xf;
    m_minor_revision = (revision_id_response >> 16) & 0xf;
    if (m_major_revision != 1 || m_minor_revision != 0)
        return ENOTSUP;

    return {};
}

ErrorOr<NonnullOwnPtr<KString>> RootNode::to_string()
{
    StringBuilder builder;
    TRY(builder.try_appendff("RootNode(node_id={})", node_id()));
    return KString::try_create(builder.string_view());
}

void RootNode::debug_dump() const
{
    dbgln("Root (node #{}):", node_id());
    dbgln("├ Codec vendor: {:#04x}, device: {:#04x}", vendor_id(), device_id());
    dbgln("├ Codec HDA compatibility: {}.{}", major_revision(), minor_revision());

    for_each_child_node([](FunctionGroupNode const& fg_node, bool is_last) -> void {
        fg_node.debug_dump(is_last);
    });
}

}