// 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::*;

pub use read_fonts::tables::gdef::GlyphClassDef;

/// [GDEF](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#gdef-header) 1.0
#[derive(Clone, Debug, Default)]
pub struct Gdef {
    /// Offset to class definition table for glyph type, from beginning
    /// of GDEF header (may be NULL)
    pub glyph_class_def: NullableOffsetMarker<ClassDef>,
    /// Offset to attachment point list table, from beginning of GDEF
    /// header (may be NULL)
    pub attach_list: NullableOffsetMarker<AttachList>,
    /// Offset to ligature caret list table, from beginning of GDEF
    /// header (may be NULL)
    pub lig_caret_list: NullableOffsetMarker<LigCaretList>,
    /// Offset to class definition table for mark attachment type, from
    /// beginning of GDEF header (may be NULL)
    pub mark_attach_class_def: NullableOffsetMarker<ClassDef>,
    /// Offset to the table of mark glyph set definitions, from
    /// beginning of GDEF header (may be NULL)
    pub mark_glyph_sets_def: NullableOffsetMarker<MarkGlyphSets>,
    /// Offset to the Item Variation Store table, from beginning of
    /// GDEF header (may be NULL)
    pub item_var_store: NullableOffsetMarker<ItemVariationStore, WIDTH_32>,
}

impl Gdef {
    /// Construct a new `Gdef`
    pub fn new(
        glyph_class_def: Option<ClassDef>,
        attach_list: Option<AttachList>,
        lig_caret_list: Option<LigCaretList>,
        mark_attach_class_def: Option<ClassDef>,
    ) -> Self {
        Self {
            glyph_class_def: glyph_class_def.into(),
            attach_list: attach_list.into(),
            lig_caret_list: lig_caret_list.into(),
            mark_attach_class_def: mark_attach_class_def.into(),
            ..Default::default()
        }
    }
}

impl FontWrite for Gdef {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        let version = self.compute_version() as MajorMinor;
        version.write_into(writer);
        self.glyph_class_def.write_into(writer);
        self.attach_list.write_into(writer);
        self.lig_caret_list.write_into(writer);
        self.mark_attach_class_def.write_into(writer);
        version
            .compatible((1, 2))
            .then(|| self.mark_glyph_sets_def.write_into(writer));
        version
            .compatible((1, 3))
            .then(|| self.item_var_store.write_into(writer));
    }
    fn name(&self) -> &'static str {
        "Gdef"
    }
}

impl Validate for Gdef {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("Gdef", |ctx| {
            ctx.in_field("glyph_class_def", |ctx| {
                self.glyph_class_def.validate_impl(ctx);
            });
            ctx.in_field("attach_list", |ctx| {
                self.attach_list.validate_impl(ctx);
            });
            ctx.in_field("lig_caret_list", |ctx| {
                self.lig_caret_list.validate_impl(ctx);
            });
            ctx.in_field("mark_attach_class_def", |ctx| {
                self.mark_attach_class_def.validate_impl(ctx);
            });
            ctx.in_field("mark_glyph_sets_def", |ctx| {
                self.mark_glyph_sets_def.validate_impl(ctx);
            });
            ctx.in_field("item_var_store", |ctx| {
                self.item_var_store.validate_impl(ctx);
            });
        })
    }
}

impl TopLevelTable for Gdef {
    const TAG: Tag = Tag::new(b"GDEF");
}

impl<'a> FromObjRef<read_fonts::tables::gdef::Gdef<'a>> for Gdef {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::Gdef<'a>, _: FontData) -> Self {
        Gdef {
            glyph_class_def: obj.glyph_class_def().to_owned_table(),
            attach_list: obj.attach_list().to_owned_table(),
            lig_caret_list: obj.lig_caret_list().to_owned_table(),
            mark_attach_class_def: obj.mark_attach_class_def().to_owned_table(),
            mark_glyph_sets_def: obj.mark_glyph_sets_def().to_owned_table(),
            item_var_store: obj.item_var_store().to_owned_table(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::Gdef<'a>> for Gdef {}

impl<'a> FontRead<'a> for Gdef {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::Gdef as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

impl FontWrite for GlyphClassDef {
    fn write_into(&self, writer: &mut TableWriter) {
        let val = *self as u16;
        writer.write_slice(&val.to_be_bytes())
    }
}

/// [Attachment Point List Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#attachment-point-list-table)
#[derive(Clone, Debug, Default)]
pub struct AttachList {
    /// Offset to Coverage table - from beginning of AttachList table
    pub coverage: OffsetMarker<CoverageTable>,
    /// Array of offsets to AttachPoint tables-from beginning of
    /// AttachList table-in Coverage Index order
    pub attach_points: Vec<OffsetMarker<AttachPoint>>,
}

impl AttachList {
    /// Construct a new `AttachList`
    pub fn new(coverage: CoverageTable, attach_points: Vec<AttachPoint>) -> Self {
        Self {
            coverage: coverage.into(),
            attach_points: attach_points.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for AttachList {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.coverage.write_into(writer);
        (array_len(&self.attach_points).unwrap() as u16).write_into(writer);
        self.attach_points.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "AttachList"
    }
}

impl Validate for AttachList {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("AttachList", |ctx| {
            ctx.in_field("coverage", |ctx| {
                self.coverage.validate_impl(ctx);
            });
            ctx.in_field("attach_points", |ctx| {
                if self.attach_points.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.attach_points.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::gdef::AttachList<'a>> for AttachList {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::AttachList<'a>, _: FontData) -> Self {
        AttachList {
            coverage: obj.coverage().to_owned_table(),
            attach_points: obj.attach_points().map(|x| x.to_owned_table()).collect(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::AttachList<'a>> for AttachList {}

impl<'a> FontRead<'a> for AttachList {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::AttachList as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

/// Part of [AttachList]
#[derive(Clone, Debug, Default)]
pub struct AttachPoint {
    /// Array of contour point indices -in increasing numerical order
    pub point_indices: Vec<u16>,
}

impl AttachPoint {
    /// Construct a new `AttachPoint`
    pub fn new(point_indices: Vec<u16>) -> Self {
        Self {
            point_indices: point_indices.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for AttachPoint {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (array_len(&self.point_indices).unwrap() as u16).write_into(writer);
        self.point_indices.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "AttachPoint"
    }
}

impl Validate for AttachPoint {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("AttachPoint", |ctx| {
            ctx.in_field("point_indices", |ctx| {
                if self.point_indices.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::gdef::AttachPoint<'a>> for AttachPoint {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::AttachPoint<'a>, _: FontData) -> Self {
        let offset_data = obj.offset_data();
        AttachPoint {
            point_indices: obj.point_indices().to_owned_obj(offset_data),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::AttachPoint<'a>> for AttachPoint {}

impl<'a> FontRead<'a> for AttachPoint {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::AttachPoint as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

/// [Ligature Caret List Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#ligature-caret-list-table)
#[derive(Clone, Debug, Default)]
pub struct LigCaretList {
    /// Offset to Coverage table - from beginning of LigCaretList table
    pub coverage: OffsetMarker<CoverageTable>,
    /// Array of offsets to LigGlyph tables, from beginning of
    /// LigCaretList table —in Coverage Index order
    pub lig_glyphs: Vec<OffsetMarker<LigGlyph>>,
}

impl LigCaretList {
    /// Construct a new `LigCaretList`
    pub fn new(coverage: CoverageTable, lig_glyphs: Vec<LigGlyph>) -> Self {
        Self {
            coverage: coverage.into(),
            lig_glyphs: lig_glyphs.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for LigCaretList {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        self.coverage.write_into(writer);
        (array_len(&self.lig_glyphs).unwrap() as u16).write_into(writer);
        self.lig_glyphs.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "LigCaretList"
    }
}

impl Validate for LigCaretList {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("LigCaretList", |ctx| {
            ctx.in_field("coverage", |ctx| {
                self.coverage.validate_impl(ctx);
            });
            ctx.in_field("lig_glyphs", |ctx| {
                if self.lig_glyphs.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.lig_glyphs.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::gdef::LigCaretList<'a>> for LigCaretList {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::LigCaretList<'a>, _: FontData) -> Self {
        LigCaretList {
            coverage: obj.coverage().to_owned_table(),
            lig_glyphs: obj.lig_glyphs().map(|x| x.to_owned_table()).collect(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::LigCaretList<'a>> for LigCaretList {}

impl<'a> FontRead<'a> for LigCaretList {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::LigCaretList as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

/// [Ligature Glyph Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#ligature-glyph-table)
#[derive(Clone, Debug, Default)]
pub struct LigGlyph {
    /// Array of offsets to CaretValue tables, from beginning of
    /// LigGlyph table — in increasing coordinate order
    pub caret_values: Vec<OffsetMarker<CaretValue>>,
}

impl LigGlyph {
    /// Construct a new `LigGlyph`
    pub fn new(caret_values: Vec<CaretValue>) -> Self {
        Self {
            caret_values: caret_values.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for LigGlyph {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (array_len(&self.caret_values).unwrap() as u16).write_into(writer);
        self.caret_values.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "LigGlyph"
    }
}

impl Validate for LigGlyph {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("LigGlyph", |ctx| {
            ctx.in_field("caret_values", |ctx| {
                if self.caret_values.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.caret_values.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::gdef::LigGlyph<'a>> for LigGlyph {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::LigGlyph<'a>, _: FontData) -> Self {
        LigGlyph {
            caret_values: obj.caret_values().map(|x| x.to_owned_table()).collect(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::LigGlyph<'a>> for LigGlyph {}

impl<'a> FontRead<'a> for LigGlyph {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::LigGlyph as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

/// [Caret Value Tables](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caret-value-tables)
#[derive(Clone, Debug)]
pub enum CaretValue {
    Format1(CaretValueFormat1),
    Format2(CaretValueFormat2),
    Format3(CaretValueFormat3),
}

impl CaretValue {
    /// Construct a new `CaretValueFormat1` subtable
    pub fn format_1(coordinate: i16) -> Self {
        Self::Format1(CaretValueFormat1::new(coordinate))
    }

    /// Construct a new `CaretValueFormat2` subtable
    pub fn format_2(caret_value_point_index: u16) -> Self {
        Self::Format2(CaretValueFormat2::new(caret_value_point_index))
    }

    /// Construct a new `CaretValueFormat3` subtable
    pub fn format_3(coordinate: i16, device: Device) -> Self {
        Self::Format3(CaretValueFormat3::new(coordinate, device))
    }
}

impl Default for CaretValue {
    fn default() -> Self {
        Self::Format1(Default::default())
    }
}

impl FontWrite for CaretValue {
    fn write_into(&self, writer: &mut TableWriter) {
        match self {
            Self::Format1(item) => item.write_into(writer),
            Self::Format2(item) => item.write_into(writer),
            Self::Format3(item) => item.write_into(writer),
        }
    }
    fn name(&self) -> &'static str {
        match self {
            Self::Format1(_) => "CaretValue.Format1",
            Self::Format2(_) => "CaretValue.Format2",
            Self::Format3(_) => "CaretValue.Format3",
        }
    }
}

impl Validate for CaretValue {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        match self {
            Self::Format1(item) => item.validate_impl(ctx),
            Self::Format2(item) => item.validate_impl(ctx),
            Self::Format3(item) => item.validate_impl(ctx),
        }
    }
}

impl FromObjRef<read_fonts::tables::gdef::CaretValue<'_>> for CaretValue {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::CaretValue, _: FontData) -> Self {
        use read_fonts::tables::gdef::CaretValue as ObjRefType;
        match obj {
            ObjRefType::Format1(item) => CaretValue::Format1(item.to_owned_table()),
            ObjRefType::Format2(item) => CaretValue::Format2(item.to_owned_table()),
            ObjRefType::Format3(item) => CaretValue::Format3(item.to_owned_table()),
        }
    }
}

impl FromTableRef<read_fonts::tables::gdef::CaretValue<'_>> for CaretValue {}

impl<'a> FontRead<'a> for CaretValue {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::CaretValue as FontRead>::read(data).map(|x| x.to_owned_table())
    }
}

/// [CaretValue Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caretvalue-format-1)
#[derive(Clone, Debug, Default)]
pub struct CaretValueFormat1 {
    /// X or Y value, in design units
    pub coordinate: i16,
}

impl CaretValueFormat1 {
    /// Construct a new `CaretValueFormat1`
    pub fn new(coordinate: i16) -> Self {
        Self { coordinate }
    }
}

impl FontWrite for CaretValueFormat1 {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (1 as u16).write_into(writer);
        self.coordinate.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "CaretValueFormat1"
    }
}

impl Validate for CaretValueFormat1 {
    fn validate_impl(&self, _ctx: &mut ValidationCtx) {}
}

impl<'a> FromObjRef<read_fonts::tables::gdef::CaretValueFormat1<'a>> for CaretValueFormat1 {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::CaretValueFormat1<'a>, _: FontData) -> Self {
        CaretValueFormat1 {
            coordinate: obj.coordinate(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::CaretValueFormat1<'a>> for CaretValueFormat1 {}

impl<'a> FontRead<'a> for CaretValueFormat1 {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::CaretValueFormat1 as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

/// [CaretValue Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caretvalue-format-2)
#[derive(Clone, Debug, Default)]
pub struct CaretValueFormat2 {
    /// Contour point index on glyph
    pub caret_value_point_index: u16,
}

impl CaretValueFormat2 {
    /// Construct a new `CaretValueFormat2`
    pub fn new(caret_value_point_index: u16) -> Self {
        Self {
            caret_value_point_index,
        }
    }
}

impl FontWrite for CaretValueFormat2 {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (2 as u16).write_into(writer);
        self.caret_value_point_index.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "CaretValueFormat2"
    }
}

impl Validate for CaretValueFormat2 {
    fn validate_impl(&self, _ctx: &mut ValidationCtx) {}
}

impl<'a> FromObjRef<read_fonts::tables::gdef::CaretValueFormat2<'a>> for CaretValueFormat2 {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::CaretValueFormat2<'a>, _: FontData) -> Self {
        CaretValueFormat2 {
            caret_value_point_index: obj.caret_value_point_index(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::CaretValueFormat2<'a>> for CaretValueFormat2 {}

impl<'a> FontRead<'a> for CaretValueFormat2 {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::CaretValueFormat2 as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

/// [CaretValue Format 3](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#caretvalue-format-3)
#[derive(Clone, Debug, Default)]
pub struct CaretValueFormat3 {
    /// X or Y value, in design units
    pub coordinate: i16,
    /// Offset to Device table (non-variable font) / Variation Index
    /// table (variable font) for X or Y value-from beginning of
    /// CaretValue table
    pub device: OffsetMarker<Device>,
}

impl CaretValueFormat3 {
    /// Construct a new `CaretValueFormat3`
    pub fn new(coordinate: i16, device: Device) -> Self {
        Self {
            coordinate,
            device: device.into(),
        }
    }
}

impl FontWrite for CaretValueFormat3 {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (3 as u16).write_into(writer);
        self.coordinate.write_into(writer);
        self.device.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "CaretValueFormat3"
    }
}

impl Validate for CaretValueFormat3 {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("CaretValueFormat3", |ctx| {
            ctx.in_field("device", |ctx| {
                self.device.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::gdef::CaretValueFormat3<'a>> for CaretValueFormat3 {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::CaretValueFormat3<'a>, _: FontData) -> Self {
        CaretValueFormat3 {
            coordinate: obj.coordinate(),
            device: obj.device().to_owned_table(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::CaretValueFormat3<'a>> for CaretValueFormat3 {}

impl<'a> FontRead<'a> for CaretValueFormat3 {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::CaretValueFormat3 as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}

/// [Mark Glyph Sets Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#mark-glyph-sets-table)
#[derive(Clone, Debug, Default)]
pub struct MarkGlyphSets {
    /// Array of offsets to mark glyph set coverage tables, from the
    /// start of the MarkGlyphSets table.
    pub coverages: Vec<OffsetMarker<CoverageTable, WIDTH_32>>,
}

impl MarkGlyphSets {
    /// Construct a new `MarkGlyphSets`
    pub fn new(coverages: Vec<CoverageTable>) -> Self {
        Self {
            coverages: coverages.into_iter().map(Into::into).collect(),
        }
    }
}

impl FontWrite for MarkGlyphSets {
    #[allow(clippy::unnecessary_cast)]
    fn write_into(&self, writer: &mut TableWriter) {
        (1 as u16).write_into(writer);
        (array_len(&self.coverages).unwrap() as u16).write_into(writer);
        self.coverages.write_into(writer);
    }
    fn name(&self) -> &'static str {
        "MarkGlyphSets"
    }
}

impl Validate for MarkGlyphSets {
    fn validate_impl(&self, ctx: &mut ValidationCtx) {
        ctx.in_table("MarkGlyphSets", |ctx| {
            ctx.in_field("coverages", |ctx| {
                if self.coverages.len() > (u16::MAX as usize) {
                    ctx.report("array exceeds max length");
                }
                self.coverages.validate_impl(ctx);
            });
        })
    }
}

impl<'a> FromObjRef<read_fonts::tables::gdef::MarkGlyphSets<'a>> for MarkGlyphSets {
    fn from_obj_ref(obj: &read_fonts::tables::gdef::MarkGlyphSets<'a>, _: FontData) -> Self {
        MarkGlyphSets {
            coverages: obj.coverages().map(|x| x.to_owned_table()).collect(),
        }
    }
}

impl<'a> FromTableRef<read_fonts::tables::gdef::MarkGlyphSets<'a>> for MarkGlyphSets {}

impl<'a> FontRead<'a> for MarkGlyphSets {
    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
        <read_fonts::tables::gdef::MarkGlyphSets as FontRead>::read(data)
            .map(|x| x.to_owned_table())
    }
}