// THIS FILE IS AUTOGENERATED.

// Any changes to this file will be overwritten.

// For more information about how codegen works, see font-codegen/README.md

#[allow(unused_imports)]

use crate::codegen_prelude::*;

impl<'a> MinByteRange<'a> for Kerx<'a> {

    fn min_byte_range(&self) -> Range<usize> {

        0..self.subtables_byte_range().end

    }

    fn min_table_bytes(&self) -> &'a [u8] {

        let range = self.min_byte_range();

        self.offset_data().as_bytes().get(range).unwrap_or_default()

    }

}

impl TopLevelTable for Kerx<'_> {

    /// `kerx`

    const TAG: Tag = Tag::new(b"kerx");

}

impl ReadArgs for Kerx<'_> {

    type Args = ();

}

impl<'a> FontRead<'a> for Kerx<'a> {

    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {

        #[allow(clippy::absurd_extreme_comparisons)]

        if data.len() < Self::MIN_SIZE {

            return Err(ReadError::OutOfBounds);

        }

        let Some(data) = TableDataRef::new(data.as_bytes()) else {

            return Err(ReadError::OutOfBounds);

        };

        Ok(Self { data })

    }

}

/// The fields at the start of the table, which are read directly.

#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]

#[repr(C, packed)]

#[doc(hidden)]

pub struct KerxFixedHeader {

    pub version: BigEndian<u16>,

    pub padding: BigEndian<u16>,

    pub n_tables: BigEndian<u32>,

}

#[allow(clippy::absurd_extreme_comparisons)]

const _: () = assert!(std::mem::size_of::<KerxFixedHeader>() <= Kerx::MIN_SIZE);

/// The [kerx (Extended Kerning)](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html) table.

#[derive(Clone)]

pub struct Kerx<'a> {

    data: TableDataRef<'a, KerxFixedHeader>,

}

#[allow(clippy::needless_lifetimes)]

impl<'a> Kerx<'a> {

    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + u32::RAW_BYTE_LEN);

    basic_table_impls!(impl_the_methods);

    /// The version number of the extended kerning table (currently 2, 3, or 4)

    pub fn version(&self) -> u16 {

        self.data.header().version.get()

    }

    /// The number of subtables included in the extended kerning table.

    pub fn n_tables(&self) -> u32 {

        self.data.header().n_tables.get()

    }

    pub fn subtables(&self) -> VarLenArray<'a, Subtable<'a>> {

        let range = self.subtables_byte_range();

        self.offset_data()

            .split_off(range.start)

            .and_then(|d| VarLenArray::read(d).ok())

            .unwrap_or_default()

    }

    pub fn version_byte_range(&self) -> Range<usize> {

        let start = 0;

        let end = start + u16::RAW_BYTE_LEN;

        start..end

    }

    pub fn padding_byte_range(&self) -> Range<usize> {

        let start = self.version_byte_range().end;

        let end = start + u16::RAW_BYTE_LEN;

        start..end

    }

    pub fn n_tables_byte_range(&self) -> Range<usize> {

        let start = self.padding_byte_range().end;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn subtables_byte_range(&self) -> Range<usize> {

        let n_tables = self.n_tables();

        let start = self.n_tables_byte_range().end;

        let end = start + {

            let data = self.offset_data().split_off(start).unwrap_or_default();

            <Subtable as VarSize>::total_len_for_count(data, transforms::to_usize(n_tables))

                .unwrap_or(0)

        };

        start..end

    }

}

const _: () = assert!(FontData::default_data_long_enough(Kerx::MIN_SIZE));

impl Default for Kerx<'_> {

    fn default() -> Self {

        Self {

            data: TableDataRef::new(FontData::default_table_data().as_bytes())

                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),

        }

    }

}

impl<'a> MinByteRange<'a> for Subtable<'a> {

    fn min_byte_range(&self) -> Range<usize> {

        0..self.data_byte_range().end

    }

    fn min_table_bytes(&self) -> &'a [u8] {

        let range = self.min_byte_range();

        self.offset_data().as_bytes().get(range).unwrap_or_default()

    }

}

impl ReadArgs for Subtable<'_> {

    type Args = ();

}

impl<'a> FontRead<'a> for Subtable<'a> {

    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {

        #[allow(clippy::absurd_extreme_comparisons)]

        if data.len() < Self::MIN_SIZE {

            return Err(ReadError::OutOfBounds);

        }

        let Some(data) = TableDataRef::new(data.as_bytes()) else {

            return Err(ReadError::OutOfBounds);

        };

        Ok(Self { data })

    }

}

/// The fields at the start of the table, which are read directly.

#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]

#[repr(C, packed)]

#[doc(hidden)]

pub struct SubtableFixedHeader {

    pub length: BigEndian<u32>,

    pub coverage: BigEndian<u32>,

    pub tuple_count: BigEndian<u32>,

}

#[allow(clippy::absurd_extreme_comparisons)]

const _: () = assert!(std::mem::size_of::<SubtableFixedHeader>() <= Subtable::MIN_SIZE);

/// A subtable in a `kerx` table.

#[derive(Clone)]

pub struct Subtable<'a> {

    data: TableDataRef<'a, SubtableFixedHeader>,

}

#[allow(clippy::needless_lifetimes)]

impl<'a> Subtable<'a> {

    pub const MIN_SIZE: usize = (u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN);

    basic_table_impls!(impl_the_methods);

    /// The length of this subtable in bytes, including this header.

    pub fn length(&self) -> u32 {

        self.data.header().length.get()

    }

    /// Circumstances under which this table is used.

    pub fn coverage(&self) -> u32 {

        self.data.header().coverage.get()

    }

    /// The tuple count. This value is only used with variation fonts and should be 0 for all other fonts. The subtable's tupleCount will be ignored if the 'kerx' table version is less than 4.

    pub fn tuple_count(&self) -> u32 {

        self.data.header().tuple_count.get()

    }

    /// Subtable specific data.

    pub fn data(&self) -> &'a [u8] {

        let range = self.data_byte_range();

        self.offset_data()

            .read_array(range)

            .ok()

            .unwrap_or_default()

    }

    pub fn length_byte_range(&self) -> Range<usize> {

        let start = 0;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn coverage_byte_range(&self) -> Range<usize> {

        let start = self.length_byte_range().end;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn tuple_count_byte_range(&self) -> Range<usize> {

        let start = self.coverage_byte_range().end;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn data_byte_range(&self) -> Range<usize> {

        let start = self.tuple_count_byte_range().end;

        let end = start

            + self.offset_data().len().saturating_sub(start) / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;

        start..end

    }

}

const _: () = assert!(FontData::default_data_long_enough(Subtable::MIN_SIZE));

impl Default for Subtable<'_> {

    fn default() -> Self {

        Self {

            data: TableDataRef::new(FontData::default_table_data().as_bytes())

                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),

        }

    }

}

impl<'a> MinByteRange<'a> for Subtable0<'a> {

    fn min_byte_range(&self) -> Range<usize> {

        0..self.pairs_byte_range().end

    }

    fn min_table_bytes(&self) -> &'a [u8] {

        let range = self.min_byte_range();

        self.offset_data().as_bytes().get(range).unwrap_or_default()

    }

}

impl ReadArgs for Subtable0<'_> {

    type Args = ();

}

impl<'a> FontRead<'a> for Subtable0<'a> {

    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {

        #[allow(clippy::absurd_extreme_comparisons)]

        if data.len() < Self::MIN_SIZE {

            return Err(ReadError::OutOfBounds);

        }

        let Some(data) = TableDataRef::new(data.as_bytes()) else {

            return Err(ReadError::OutOfBounds);

        };

        Ok(Self { data })

    }

}

/// The fields at the start of the table, which are read directly.

#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]

#[repr(C, packed)]

#[doc(hidden)]

pub struct Subtable0FixedHeader {

    pub n_pairs: BigEndian<u32>,

    pub search_range: BigEndian<u32>,

    pub entry_selector: BigEndian<u32>,

    pub range_shift: BigEndian<u32>,

}

#[allow(clippy::absurd_extreme_comparisons)]

const _: () = assert!(std::mem::size_of::<Subtable0FixedHeader>() <= Subtable0::MIN_SIZE);

/// The type 0 `kerx` subtable.

#[derive(Clone)]

pub struct Subtable0<'a> {

    data: TableDataRef<'a, Subtable0FixedHeader>,

}

#[allow(clippy::needless_lifetimes)]

impl<'a> Subtable0<'a> {

    pub const MIN_SIZE: usize =

        (u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN);

    basic_table_impls!(impl_the_methods);

    /// The number of kerning pairs in this subtable.

    pub fn n_pairs(&self) -> u32 {

        self.data.header().n_pairs.get()

    }

    /// The largest power of two less than or equal to the value of nPairs, multiplied by the size in bytes of an entry in the subtable.

    pub fn search_range(&self) -> u32 {

        self.data.header().search_range.get()

    }

    /// This is calculated as log2 of the largest power of two less than or equal to the value of nPairs. This value indicates how many iterations of the search loop have to be made. For example, in a list of eight items, there would be three iterations of the loop.

    pub fn entry_selector(&self) -> u32 {

        self.data.header().entry_selector.get()

    }

    /// The value of nPairs minus the largest power of two less than or equal to nPairs. This is multiplied by the size in bytes of an entry in the table.

    pub fn range_shift(&self) -> u32 {

        self.data.header().range_shift.get()

    }

    /// Kerning records.

    pub fn pairs(&self) -> &'a [Subtable0Pair] {

        let range = self.pairs_byte_range();

        self.offset_data()

            .read_array(range)

            .ok()

            .unwrap_or_default()

    }

    pub fn n_pairs_byte_range(&self) -> Range<usize> {

        let start = 0;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn search_range_byte_range(&self) -> Range<usize> {

        let start = self.n_pairs_byte_range().end;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn entry_selector_byte_range(&self) -> Range<usize> {

        let start = self.search_range_byte_range().end;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn range_shift_byte_range(&self) -> Range<usize> {

        let start = self.entry_selector_byte_range().end;

        let end = start + u32::RAW_BYTE_LEN;

        start..end

    }

    pub fn pairs_byte_range(&self) -> Range<usize> {

        let n_pairs = self.n_pairs();

        let start = self.range_shift_byte_range().end;

        let end =

            start + (transforms::to_usize(n_pairs)).saturating_mul(Subtable0Pair::RAW_BYTE_LEN);

        start..end

    }

}

const _: () = assert!(FontData::default_data_long_enough(Subtable0::MIN_SIZE));

impl Default for Subtable0<'_> {

    fn default() -> Self {

        Self {

            data: TableDataRef::new(FontData::default_table_data().as_bytes())

                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),

        }

    }

}

/// The type 0 `kerx` subtable kerning record.

#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]

#[repr(C)]

#[repr(packed)]

pub struct Subtable0Pair {

    /// The glyph index for the lefthand glyph in the kerning pair.

    pub left: BigEndian<GlyphId16>,

    /// The glyph index for the righthand glyph in the kerning pair.

    pub right: BigEndian<GlyphId16>,

    /// Kerning value.

    pub value: BigEndian<i16>,

}

impl Subtable0Pair {

    /// The glyph index for the lefthand glyph in the kerning pair.

    pub fn left(&self) -> GlyphId16 {

        self.left.get()

    }

    /// The glyph index for the righthand glyph in the kerning pair.

    pub fn right(&self) -> GlyphId16 {

        self.right.get()

    }

    /// Kerning value.

    pub fn value(&self) -> i16 {

        self.value.get()

    }

}

impl FixedSize for Subtable0Pair {

    const RAW_BYTE_LEN: usize =

        GlyphId16::RAW_BYTE_LEN + GlyphId16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN;

}