use alloc::vec::Vec;

use indexmap::IndexSet;

use std::ops::{Deref, DerefMut};

use crate::common::{DebugAbbrevOffset, SectionId};

use crate::constants;

use crate::write::{Result, Section, Writer};

/// A table of abbreviations that will be stored in a `.debug_abbrev` section.

// Requirements:

// - values are `Abbreviation`

// - insertion returns an abbreviation code for use in writing a DIE

// - inserting a duplicate returns the code of the existing value

#[derive(Debug, Default)]

Unexecuted instantiation: <gimli::write::abbrev::AbbreviationTable as core::default::Default>::default

Unexecuted instantiation: <gimli::write::abbrev::AbbreviationTable as core::default::Default>::default

pub(crate) struct AbbreviationTable {

    abbrevs: IndexSet<Abbreviation>,

}

impl AbbreviationTable {

    /// Add an abbreviation to the table and return its code.

    pub fn add(&mut self, abbrev: Abbreviation) -> u64 {

        let (code, _) = self.abbrevs.insert_full(abbrev);

        // Code must be non-zero

        (code + 1) as u64

    }

    /// Write the abbreviation table to the `.debug_abbrev` section.

    pub fn write<W: Writer>(&self, w: &mut DebugAbbrev<W>) -> Result<()> {

        for (code, abbrev) in self.abbrevs.iter().enumerate() {

            w.write_uleb128((code + 1) as u64)?;

            abbrev.write(w)?;

        }

        // Null abbreviation code

        w.write_u8(0)

    }

Unexecuted instantiation: <gimli::write::abbrev::AbbreviationTable>::write::<wasmtime_cranelift::debug::write_debuginfo::WriterRelocate>

Unexecuted instantiation: <gimli::write::abbrev::AbbreviationTable>::write::<_>

}

/// An abbreviation describes the shape of a `DebuggingInformationEntry`'s type:

/// its tag type, whether it has children, and its set of attributes.

#[derive(Debug, Clone, PartialEq, Eq, Hash)]

pub(crate) struct Abbreviation {

    tag: constants::DwTag,

    has_children: bool,

    attributes: Vec<AttributeSpecification>,

}

impl Abbreviation {

    /// Construct a new `Abbreviation`.

    #[inline]

    pub fn new(

        tag: constants::DwTag,

        has_children: bool,

        attributes: Vec<AttributeSpecification>,

    ) -> Abbreviation {

        Abbreviation {

            tag,

            has_children,

            attributes,

        }

    }

    /// Write the abbreviation to the `.debug_abbrev` section.

    pub fn write<W: Writer>(&self, w: &mut DebugAbbrev<W>) -> Result<()> {

        w.write_uleb128(self.tag.0.into())?;

        w.write_u8(if self.has_children {

            constants::DW_CHILDREN_yes.0

        } else {

            constants::DW_CHILDREN_no.0

        })?;

        for attr in &self.attributes {

            attr.write(w)?;

        }

        // Null name and form

        w.write_u8(0)?;

        w.write_u8(0)

    }

Unexecuted instantiation: <gimli::write::abbrev::Abbreviation>::write::<wasmtime_cranelift::debug::write_debuginfo::WriterRelocate>

Unexecuted instantiation: <gimli::write::abbrev::Abbreviation>::write::<_>

}

/// The description of an attribute in an abbreviated type.

// TODO: support implicit const

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

pub(crate) struct AttributeSpecification {

    name: constants::DwAt,

    form: constants::DwForm,

}

impl AttributeSpecification {

    /// Construct a new `AttributeSpecification`.

    #[inline]

    pub fn new(name: constants::DwAt, form: constants::DwForm) -> AttributeSpecification {

        AttributeSpecification { name, form }

    }

    /// Write the attribute specification to the `.debug_abbrev` section.

    #[inline]

    pub fn write<W: Writer>(&self, w: &mut DebugAbbrev<W>) -> Result<()> {

        w.write_uleb128(self.name.0.into())?;

        w.write_uleb128(self.form.0.into())

    }

Unexecuted instantiation: <gimli::write::abbrev::AttributeSpecification>::write::<wasmtime_cranelift::debug::write_debuginfo::WriterRelocate>

Unexecuted instantiation: <gimli::write::abbrev::AttributeSpecification>::write::<_>

}

define_section!(

    DebugAbbrev,

    DebugAbbrevOffset,

    "A writable `.debug_abbrev` section."

);

#[cfg(test)]

#[cfg(feature = "read")]

mod tests {

    use super::*;

    use crate::constants;

    use crate::read;

    use crate::write::EndianVec;

    use crate::LittleEndian;

    #[test]

    fn test_abbreviation_table() {

        let mut abbrevs = AbbreviationTable::default();

        let abbrev1 = Abbreviation::new(

            constants::DW_TAG_subprogram,

            false,

            vec![AttributeSpecification::new(

                constants::DW_AT_name,

                constants::DW_FORM_string,

            )],

        );

        let abbrev2 = Abbreviation::new(

            constants::DW_TAG_compile_unit,

            true,

            vec![

                AttributeSpecification::new(constants::DW_AT_producer, constants::DW_FORM_strp),

                AttributeSpecification::new(constants::DW_AT_language, constants::DW_FORM_data2),

            ],

        );

        let code1 = abbrevs.add(abbrev1.clone());

        assert_eq!(code1, 1);

        let code2 = abbrevs.add(abbrev2.clone());

        assert_eq!(code2, 2);

        assert_eq!(abbrevs.add(abbrev1.clone()), code1);

        assert_eq!(abbrevs.add(abbrev2.clone()), code2);

        let mut debug_abbrev = DebugAbbrev::from(EndianVec::new(LittleEndian));

        let debug_abbrev_offset = debug_abbrev.offset();

        assert_eq!(debug_abbrev_offset, DebugAbbrevOffset(0));

        abbrevs.write(&mut debug_abbrev).unwrap();

        assert_eq!(debug_abbrev.offset(), DebugAbbrevOffset(17));

        let read_debug_abbrev = read::DebugAbbrev::new(debug_abbrev.slice(), LittleEndian);

        let read_abbrevs = read_debug_abbrev

            .abbreviations(debug_abbrev_offset)

            .unwrap();

        let read_abbrev1 = read_abbrevs.get(code1).unwrap();

        assert_eq!(abbrev1.tag, read_abbrev1.tag());

        assert_eq!(abbrev1.has_children, read_abbrev1.has_children());

        assert_eq!(abbrev1.attributes.len(), read_abbrev1.attributes().len());

        assert_eq!(

            abbrev1.attributes[0].name,

            read_abbrev1.attributes()[0].name()

        );

        assert_eq!(

            abbrev1.attributes[0].form,

            read_abbrev1.attributes()[0].form()

        );

        let read_abbrev2 = read_abbrevs.get(code2).unwrap();

        assert_eq!(abbrev2.tag, read_abbrev2.tag());

        assert_eq!(abbrev2.has_children, read_abbrev2.has_children());

        assert_eq!(abbrev2.attributes.len(), read_abbrev2.attributes().len());

        assert_eq!(

            abbrev2.attributes[0].name,

            read_abbrev2.attributes()[0].name()

        );

        assert_eq!(

            abbrev2.attributes[0].form,

            read_abbrev2.attributes()[0].form()

        );

        assert_eq!(

            abbrev2.attributes[1].name,

            read_abbrev2.attributes()[1].name()

        );

        assert_eq!(

            abbrev2.attributes[1].form,

            read_abbrev2.attributes()[1].form()

        );

    }

}