//! OpenType font table parsing and writing.

pub mod aat;

pub mod cmap;

pub mod colr;

pub mod cpal;

pub mod gasp;

pub mod glyf;

pub mod kern;

pub mod loca;

pub mod morx;

pub mod os2;

pub mod svg;

pub mod variable_fonts;

use std::borrow::Cow;

use std::fmt::{self, Formatter};

use encoding_rs::Encoding;

use crate::binary::read::{

    CheckIndex, ReadArray, ReadArrayCow, ReadBinary, ReadBinaryDep, ReadCtxt, ReadFrom, ReadScope,

    ReadUnchecked,

};

use crate::binary::write::{Placeholder, WriteBinary, WriteContext};

use crate::binary::{I16Be, I32Be, I64Be, U16Be, U32Be};

use crate::error::{ParseError, WriteError};

use crate::tag;

use crate::{size, SafeFrom};

/// Magic value identifying a CFF font (`OTTO`)

pub const CFF_MAGIC: u32 = tag::OTTO;

/// Magic number identifying TrueType 1.0

///

/// The version number 1.0 as a 16.16 fixed-point value, indicating TrueType glyph data.

pub const TTF_MAGIC: u32 = 0x00010000;

/// Magic number identifying TrueType (Apple version)

pub const TRUE_MAGIC: u32 = tag::TRUE;

/// Magic value identifying a TrueType font collection `ttcf`

pub const TTCF_MAGIC: u32 = tag::TTCF;

/// 32-bit signed fixed-point number (16.16)

///

/// The integer component is a signed 16-bit integer. The fraction is an unsigned

/// 16-bit numerator for denominator of 0xFFFF (65635). I.e scale of 1/65535.

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

pub struct Fixed(i32);

/// Date represented in number of seconds since 12:00 midnight, January 1, 1904

///

/// The value is represented as a signed 64-bit integer.

type LongDateTime = i64;

pub trait FontTableProvider {

    /// Return data for the specified table if present

    fn table_data(&self, tag: u32) -> Result<Option<Cow<'_, [u8]>>, ParseError>;

    fn has_table(&self, tag: u32) -> bool;

    /// The tags of the tables within this font.

    ///

    /// Returns `None` if the tags cannot be determined.

    fn table_tags(&self) -> Option<Vec<u32>>;

}

pub trait SfntVersion {

    fn sfnt_version(&self) -> u32;

}

/// The F2DOT14 format consists of a signed, 2’s complement integer and an unsigned fraction.

///

/// To compute the actual value, take the integer and add the fraction.

#[repr(transparent)]

#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]

pub struct F2Dot14(i16);

/// The size of the offsets in the `loca` table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/loca>

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

pub enum IndexToLocFormat {

    /// Offsets are 16-bit. The actual local offset divided by 2 is stored.

    Short,

    /// Offsets are 32-bit. The actual local offset is stored.

    Long,

}

#[derive(Clone)]

pub struct OpenTypeFont<'a> {

    pub scope: ReadScope<'a>,

    pub data: OpenTypeData<'a>,

}

/// An OpenTypeFont containing a single font or a collection of fonts

#[derive(Clone)]

pub enum OpenTypeData<'a> {

    Single(OffsetTable<'a>),

    Collection(TTCHeader<'a>),

}

/// TrueType collection header

#[derive(Clone)]

pub struct TTCHeader<'a> {

    pub major_version: u16,

    pub minor_version: u16,

    pub offset_tables: ReadArray<'a, U32Be>,

    // TODO add digital signature fields

}

/// OpenType Offset Table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/otff#organization-of-an-opentype-font>

#[derive(Clone)]

pub struct OffsetTable<'a> {

    pub sfnt_version: u32,

    pub search_range: u16,

    pub entry_selector: u16,

    pub range_shift: u16,

    pub table_records: ReadArray<'a, TableRecord>,

}

pub struct OffsetTableFontProvider<'a> {

    scope: ReadScope<'a>,

    offset_table: OffsetTable<'a>,

}

/// An entry in the Offset Table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/otff#organization-of-an-opentype-font>

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

pub struct TableRecord {

    pub table_tag: u32,

    pub checksum: u32,

    pub offset: u32,

    pub length: u32,

}

/// `head` table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/head>

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

pub struct HeadTable {

    pub major_version: u16,

    pub minor_version: u16,

    pub font_revision: Fixed,

    pub check_sum_adjustment: u32,

    pub magic_number: u32,

    pub flags: u16,

    pub units_per_em: u16,

    pub created: LongDateTime,

    pub modified: LongDateTime,

    pub x_min: i16,

    pub y_min: i16,

    pub x_max: i16,

    pub y_max: i16,

    pub mac_style: MacStyle,

    pub lowest_rec_ppem: u16,

    pub font_direction_hint: i16,

    pub index_to_loc_format: IndexToLocFormat,

    pub glyph_data_format: i16,

}

/// macStyle field in `head`

#[enumflags2::bitflags]

#[repr(u16)]

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

#[allow(non_camel_case_types)]

pub enum MacStyleFlag {

    BOLD = 1 << 0,

    ITALIC = 1 << 1,

    UNDERLINE = 1 << 2,

    OUTLINE = 1 << 3,

    SHADOW = 1 << 4,

    CONDENSED = 1 << 5,

    EXTENDED = 1 << 6,

    // Bits 7–15: Reserved (set to 0).

}

pub type MacStyle = enumflags2::BitFlags<MacStyleFlag>;

/// `hhea` horizontal header table

///

/// > This table contains information for horizontal layout.

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/hhea>

///

/// This struct is also used for the `vhea` table.

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

pub struct HheaTable {

    pub ascender: i16,

    pub descender: i16,

    pub line_gap: i16,

    pub advance_width_max: u16,

    pub min_left_side_bearing: i16,

    pub min_right_side_bearing: i16,

    pub x_max_extent: i16,

    pub caret_slope_rise: i16,

    pub caret_slope_run: i16,

    pub caret_offset: i16,

    pub num_h_metrics: u16,

}

/// `hmtx` horizontal metrics table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/hmtx>

///

/// This struct is also used for `vmtx` table.

#[derive(Debug)]

pub struct HmtxTable<'a> {

    pub h_metrics: ReadArrayCow<'a, LongHorMetric>,

    pub left_side_bearings: ReadArrayCow<'a, I16Be>,

}

/// A `longHorMetric` record in the `hmtx` table.

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/hmtx>

///

/// This struct is also used for LongVerMetric `vmtx` table.

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

pub struct LongHorMetric {

    pub advance_width: u16,

    pub lsb: i16,

}

/// maxp - Maximum profile

///

/// This table establishes the memory requirements for this font. Fonts with CFF data must use

/// Version 0.5 of this table, specifying only the numGlyphs field. Fonts with TrueType outlines

/// must use Version 1.0 of this table, where all data is required.

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/maxp>

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

pub struct MaxpTable {

    pub num_glyphs: u16,

    /// Extra fields, present if maxp table is version 1.0, absent if version 0.5.

    pub version1_sub_table: Option<MaxpVersion1SubTable>,

}

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

pub struct MaxpVersion1SubTable {

    /// Maximum points in a non-composite glyph.

    pub max_points: u16,

    /// Maximum contours in a non-composite glyph.

    pub max_contours: u16,

    /// Maximum points in a composite glyph.

    pub max_composite_points: u16,

    /// Maximum contours in a composite glyph.

    pub max_composite_contours: u16,

    /// 1 if instructions do not use the twilight zone (Z0), or 2 if instructions do use Z0; should

    /// be set to 2 in most cases.

    pub max_zones: u16,

    /// Maximum points used in Z0.

    pub max_twilight_points: u16,

    /// Number of Storage Area locations.

    pub max_storage: u16,

    /// Number of FDEFs, equal to the highest function number + 1.

    pub max_function_defs: u16,

    /// Number of IDEFs.

    pub max_instruction_defs: u16,

    /// Maximum stack depth across Font Program ('fpgm' table), CVT Program ('prep' table) and all

    /// glyph instructions (in the 'glyf' table).

    pub max_stack_elements: u16,

    /// Maximum byte count for glyph instructions.

    pub max_size_of_instructions: u16,

    /// Maximum number of components referenced at “top level” for any composite glyph.

    pub max_component_elements: u16,

    /// Maximum levels of recursion; 1 for simple components.

    pub max_component_depth: u16,

}

/// `name` table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/name>

pub struct NameTable<'a> {

    pub string_storage: ReadScope<'a>,

    pub name_records: ReadArray<'a, NameRecord>,

    /// Language tag records

    ///

    /// Present if `name` table version is 1 or newer. If present, language ids >= 0x8000 refer to

    /// language tag records with 0x8000 the first record, 0x8001 the second, etc.

    pub opt_langtag_records: Option<ReadArray<'a, LangTagRecord>>,

}

/// Record within the `name` table

#[derive(Debug)]

pub struct NameRecord {

    pub platform_id: u16,

    pub encoding_id: u16,

    pub language_id: u16,

    pub name_id: u16,

    pub length: u16,

    pub offset: u16,

}

/// Language-tag record within the `name` table

pub struct LangTagRecord {

    pub length: u16,

    pub offset: u16,

}

/// cvt — Control Value Table

///

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/cvt>

pub struct CvtTable<'a> {

    pub values: ReadArrayCow<'a, I16Be>,

}

impl<'a> OpenTypeFont<'a> {

            }

        }

}

impl ReadBinary for OpenTypeFont<'_> {

    type HostType<'a> = OpenTypeFont<'a>;

            TTF_MAGIC | TRUE_MAGIC | CFF_MAGIC => {

            }

            TTCF_MAGIC => {

            }

        }

}

impl ReadBinary for TTCHeader<'_> {

    type HostType<'a> = TTCHeader<'a>;

            TTCF_MAGIC => {

                // TODO read digital signature fields in TTCHeader version 2

            }

        }

}

impl ReadBinary for OffsetTable<'_> {

    type HostType<'a> = OffsetTable<'a>;

            TTF_MAGIC | TRUE_MAGIC | CFF_MAGIC => {

            }

        }

}

// WEB-LIFT FIX (2026-06-02): plain big-endian reads from a byte slice. Used by the

// manual table-directory scan below. The remill/web lift mis-handles the

// `ReadArray<TableRecord>` read path (the nested-tuple `TableRecord` `read_dep` returns

// `table_tag = 0` for EVERY record — proven via a probe: tags[7]=0x0000 while the bytes

// at that offset are 0x68656164 'head' and `tag::HEAD`==0x6164), so the directory lookup

// never matches and the font fails to parse → text measures height 0. These hand-rolled

// indexed byte reads lift correctly.

#[inline]

#[inline]

impl OffsetTableFontProvider<'_> {

    /// Locate the table directory by hand for a single-font sfnt laid out at the start of

    /// `self.scope` (TTF/OTTO/'true'): returns `(dir_offset, num_tables)`. Returns `None`

    /// for TTC / unrecognised layouts so the caller falls back to the original

    /// `ReadArray`-based path. See the `be32` comment for why this exists.

            // TTF_MAGIC | CFF_MAGIC (OTTO) | TRUE_MAGIC ('true')

        }

}

impl FontTableProvider for OffsetTableFontProvider<'_> {

            }

        // Fallback (TTC / unrecognised): original ReadArray path.

            }

        // Fallback (TTC / unrecognised): original ReadArray path.

        }

}

impl SfntVersion for OffsetTableFontProvider<'_> {

}

impl ReadFrom for TableRecord {

    type ReadType = ((U32Be, U32Be), (U32Be, U32Be));

}

impl WriteBinary<&Self> for TableRecord {

    type Output = ();

}

impl<'a> OffsetTable<'a> {

        // Indexed loop instead of `.iter().find(closure)`: on the lifted/web backend the

        // ReadArray iterator (ReadArrayIter::next) and/or the find-closure mis-lift and

        // yield no match (same class as the css.rs map+collect element-drop). Indexed

        // `read_item` lifts correctly (it's what binary_search uses).

        }

        } else {

        }

}

impl TableRecord {

    pub const SIZE: usize = 4 * size::U32;

}

impl ReadBinary for HeadTable {

    type HostType<'a> = Self;

}

impl WriteBinary<&Self> for HeadTable {

    type Output = Placeholder<U32Be, u32>;

    /// Writes the table to the `WriteContext` and returns a placeholder to the

    /// `check_sum_adjustment` field.

    ///

    /// The `check_sum_adjustment` field requires special handling to calculate. See:

    /// <https://docs.microsoft.com/en-us/typography/opentype/spec/head>

}

impl HeadTable {

    // macStyle:

    // Bit 0: Bold (if set to 1);

    // Bit 1: Italic (if set to 1)

    // Bit 2: Underline (if set to 1)

    // Bit 3: Outline (if set to 1)

    // Bit 4: Shadow (if set to 1)

    // Bit 5: Condensed (if set to 1)

    // Bit 6: Extended (if set to 1)

    // Bits 7–15: Reserved (set to 0).

    // https://docs.microsoft.com/en-us/typography/opentype/spec/head

}

impl ReadBinary for HheaTable {

    type HostType<'a> = Self;

}

impl WriteBinary<&Self> for HheaTable {

    type Output = ();

}

impl ReadBinaryDep for HmtxTable<'_> {

    type Args<'a> = (usize, usize); // num_glyphs, num_h_metrics

    type HostType<'a> = HmtxTable<'a>;

}

impl<'a> WriteBinary<&Self> for HmtxTable<'a> {

    type Output = ();

}

impl HmtxTable<'_> {

    /// Retrieve the horizontal advance for glyph with index `glyph_id`.

        // This is largely the same as `metric` below but it avoids a lookup in the

        // `left_side_bearings` array.

        } else {

            // As an optimization, the number of records can be less than the number of glyphs, in

            // which case the advance width value of the last record applies to all remaining glyph

            // IDs.

            // https://docs.microsoft.com/en-us/typography/opentype/spec/hmtx

        };

    /// Retrieve the advance and left-side bearing for glyph with index `glyph_id`.

        } else {

            // As an optimization, the number of records can be less than the number of glyphs, in

            // which case the advance width value of the last record applies to all remaining glyph

            // IDs. If numberOfHMetrics is less than the total number of glyphs, then the hMetrics

            // array is followed by an array for the left side bearing values of the remaining

            // glyphs.

            // https://docs.microsoft.com/en-us/typography/opentype/spec/hmtx

        }

}

impl ReadFrom for LongHorMetric {

    type ReadType = (U16Be, I16Be);

}

impl WriteBinary for LongHorMetric {

    type Output = ();

}

impl ReadBinary for MaxpTable {

    type HostType<'a> = Self;

        } else {

        };

}

impl WriteBinary<&Self> for MaxpTable {

    type Output = ();

        } else {

        }

}

impl ReadBinary for MaxpVersion1SubTable {

    type HostType<'a> = Self;

}

impl WriteBinary<&Self> for MaxpVersion1SubTable {

    type Output = ();

}

impl NameTable<'_> {

    pub const COPYRIGHT_NOTICE: u16 = 0;

    pub const FONT_FAMILY_NAME: u16 = 1;

    pub const FONT_SUBFAMILY_NAME: u16 = 2;

    pub const UNIQUE_FONT_IDENTIFIER: u16 = 3;

    pub const FULL_FONT_NAME: u16 = 4;

    pub const VERSION_STRING: u16 = 5;

    pub const POSTSCRIPT_NAME: u16 = 6;

    pub const TRADEMARK: u16 = 7;

    pub const MANUFACTURER_NAME: u16 = 8;

    pub const DESIGNER: u16 = 9;

    pub const DESCRIPTION: u16 = 10;

    pub const URL_VENDOR: u16 = 11;

    pub const URL_DESIGNER: u16 = 12;

    pub const LICENSE_DESCRIPTION: u16 = 13;

    pub const LICENSE_INFO_URL: u16 = 14;

    pub const TYPOGRAPHIC_FAMILY_NAME: u16 = 16;

    pub const TYPOGRAPHIC_SUBFAMILY_NAME: u16 = 17;

    pub const COMPATIBLE_FULL: u16 = 18; // (Macintosh only)

    pub const SAMPLE_TEXT: u16 = 19;

    pub const POSTSCRIPT_CID_FINDFONT_NAME: u16 = 20;

    pub const WWS_FAMILY_NAME: u16 = 21; // WWS = Weight, width, slope

    pub const WWS_SUBFAMILY_NAME: u16 = 22;

    pub const LIGHT_BACKGROUND_PALETTE: u16 = 23;

    pub const DARK_BACKGROUND_PALETTE: u16 = 24;

    pub const VARIATIONS_POSTSCRIPT_NAME_PREFIX: u16 = 25;

    /// Return a string for the supplied `name_id`.

    ///

    /// Returns the first match in this order:

    ///

    /// 1. Unicode platform

    /// 2. Windows platform, English language ids

    /// 3. Apple platform, Roman language id

                // Match English records

                    // Unicode

                    // Windows Unicode BMP, English language ids

                    // https://learn.microsoft.com/en-us/typography/opentype/spec/name#windows-language-ids

                    (

                        3,

                        1,

                        0x0C09 | 0x2809 | 0x1009 | 0x2409 | 0x4009 | 0x1809 | 0x2009 | 0x4409

                        | 0x1409 | 0x3409 | 0x4809 | 0x1C09 | 0x2C09 | 0x0809 | 0x0409 | 0x3009,

                    // Windows Unicode full, English language ids

                    // https://learn.microsoft.com/en-us/typography/opentype/spec/name#windows-language-ids

                    (

                        3,

                        10,

                        0x0C09 | 0x2809 | 0x1009 | 0x2409 | 0x4009 | 0x1809 | 0x2009 | 0x4409

                        | 0x1409 | 0x3409 | 0x4809 | 0x1C09 | 0x2C09 | 0x0809 | 0x0409 | 0x3009,

                    // Apple, Roman Script, English

                }

}

impl ReadBinary for NameTable<'_> {

    type HostType<'a> = NameTable<'a>;

        } else {

        };

}

impl<'a> WriteBinary<&Self> for NameTable<'a> {

    type Output = ();

}

impl ReadFrom for NameRecord {

    type ReadType = ((U16Be, U16Be, U16Be), (U16Be, U16Be, U16Be));

}

impl WriteBinary for NameRecord {

    type Output = ();

}

impl ReadFrom for LangTagRecord {

    type ReadType = (U16Be, U16Be);

}

impl WriteBinary for LangTagRecord {

    type Output = ();

}

impl ReadBinaryDep for CvtTable<'_> {

    type Args<'a> = u32;

    type HostType<'a> = CvtTable<'a>;

        // The table contains 'n' values, where n is just as many values can be read for the

        // size of the table. We assume that `ctxt` is limited to the length of the table

        //

        // > The length of the table must be an integral number of FWORD units.

}

impl WriteBinary<&Self> for CvtTable<'_> {

    type Output = ();

}

impl ReadFrom for F2Dot14 {

    type ReadType = I16Be;

}

impl WriteBinary for F2Dot14 {

    type Output = ();

}

impl ReadBinary for IndexToLocFormat {

    type HostType<'a> = Self;

        }

}

impl WriteBinary for IndexToLocFormat {

    type Output = ();

        }

}

impl Fixed {

    /// Create a new `Fixed` with a raw 16.16 value.

}

impl std::ops::Add for Fixed {

    type Output = Self;

}

impl std::ops::Sub for Fixed {

    type Output = Self;

}

impl std::ops::Mul for Fixed {

    type Output = Self;

}

impl std::ops::Div for Fixed {

    type Output = Self;

            // Closest we have to infinity. Same as what FreeType does

            // https://gitlab.freedesktop.org/freetype/freetype/-/blob/a20de84e1608f9eb1d0391d7322b2e0e0f235aba/src/base/ftcalc.c#L267

}

impl std::ops::Neg for Fixed {

    type Output = Self;

}

impl fmt::Debug for Fixed {

}

impl ReadFrom for Fixed {

    type ReadType = I32Be;

}

impl WriteBinary for Fixed {

    type Output = ();

}

impl From<Fixed> for f32 {

}

// When converting from float or double data types to 16.16, the following method must be used:

//

// 1. Multiply the fractional component by 65536, and round the result to the nearest integer (for

//    fractional values of 0.5 and higher, take the next higher integer; for other fractional

//    values, truncate). Store the result in the low-order word.

// 2. Move the two’s-complement representation of the integer component into the high-order word

//

// https://learn.microsoft.com/en-us/typography/opentype/spec/otvaroverview#coordinate-scales-and-normalization

impl From<f32> for Fixed {

}

impl From<f64> for Fixed {