//! `GDEF` font table parsing and glyph lookup and layout properties.

pub mod morx;

use std::borrow::Cow;

use std::collections::BTreeMap;

use std::marker::PhantomData;

use std::ops::RangeInclusive;

use std::sync::Arc;

use std::sync::Mutex;

use log::warn;

use crate::binary::read::{

    CheckIndex, ReadArray, ReadBinary, ReadBinaryDep, ReadCache, ReadCtxt, ReadFixedSizeDep,

    ReadFrom, ReadScope, ReadScopeOwned,

};

use crate::binary::{U16Be, U32Be};

use crate::context::{ContextLookupHelper, GlyphTable, LookupFlag, MatchContext};

use crate::error::ParseError;

use crate::tables::variable_fonts::{owned, ItemVariationStore, Tuple};

use crate::tables::F2Dot14;

use crate::{size, tag, GlyphId, SafeFrom};

pub enum GSUB {}

pub enum GPOS {}

pub struct GDEFTable {

    pub opt_glyph_classdef: Option<ClassDef>,

    // pub opt_attach_list: Option<ReadScope<'a>>,

    // pub opt_lig_caret_list: Option<ReadScope<'a>>,

    pub opt_mark_attach_classdef: Option<ClassDef>,

    // TODO read additional GDEF 1.2 fields

    pub opt_mark_glyph_sets: Option<MarkGlyphSets>,

    pub opt_item_variation_store: Option<owned::ItemVariationStore>,

}

// GSUB and GPOS tables have the same top-level structure

pub struct LayoutTable<T> {

    pub opt_script_list: Option<ScriptList>,

    pub opt_feature_list: Option<FeatureList>,

    pub opt_lookup_list: Option<LookupList<T>>,

    pub opt_feature_variations: Option<FeatureVariationsOwned>,

}

pub struct ScriptList {

    script_records: Vec<ScriptRecord>,

}

pub struct ScriptRecord {

    pub script_tag: u32,

    script_table: ScriptTable,

}

pub struct ScriptTable {

    opt_default_langsys: Option<LangSys>,

    langsys_records: Vec<LangSysRecord>,

}

pub struct LangSysRecord {

    pub langsys_tag: u32,

    langsys_table: LangSys,

}

pub struct LangSys {

    _required_feature_index: u16, // not used during shaping for now

    feature_indices: Vec<u16>,

}

pub struct FeatureList {

    feature_records: Vec<FeatureRecord>,

}

pub struct FeatureRecord {

    pub feature_tag: u32,

    feature_table: FeatureTable,

}

#[derive(Clone)]

pub struct FeatureTable {

    pub lookup_indices: Vec<u16>,

}

/// FeatureVariations table.

///

/// A feature variations table describes variations on the effects of features based on various

/// conditions. That is, it allows the default set of lookups for a given feature to be substituted

/// with alternates of lookups under particular conditions.

///

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#featurevariations-table>

pub struct FeatureVariations<'a> {

    record_scope: ReadScope<'a>,

    records: ReadArray<'a, FeatureVariationRecord>,

}

/// Owned version of [FeatureVariations].

pub struct FeatureVariationsOwned {

    record_scope: ReadScopeOwned,

    records: Vec<FeatureVariationRecord>,

}

/// A feature variation record containing conditions and substitute feature table.

struct FeatureVariationRecord {

    /// Offset to a condition set table, from beginning of FeatureVariations table.

    ///

    /// If the ConditionSet offset is 0, there is no condition set table. This is treated as the

    /// universal condition: all contexts are matched.

    condition_set_offset: u32,

    /// Offset to a feature table substitution table, from beginning of the FeatureVariations

    /// table.

    ///

    /// If the FeatureTableSubstitution offset is 0, there is no feature table substitution table,

    /// and no substitutions are made.

    feature_table_substitution_offset: u32,

}

enum ConditionSet<'a> {

    Universal,

    Set(ConditionSetTable<'a>),

}

struct ConditionSetTable<'a> {

    condition_scope: ReadScope<'a>,

    /// Array of offsets to condition tables, from beginning of the ConditionSet table.

    ///

    /// If a given condition set contains no conditions, then it matches all contexts, and the

    /// associated feature table substitution is always applied, unless there was a

    /// FeatureVariation record earlier in the array with a condition set matching the current

    /// context.

    condition_offsets: ReadArray<'a, U32Be>,

}

#[derive(Debug, Clone)]

enum ConditionTable {

    Unknown,

    /// Condition Table Format 1: Font Variation Axis Range

    Format1(ConditionFormat1),

}

#[derive(Debug, Copy, Clone)]

struct ConditionFormat1 {

    /// Index (zero-based) for the variation axis within the 'fvar' table.

    axis_index: u16,

    /// Minimum value of the font variation instances that satisfy this condition.

    filter_range_min_value: F2Dot14,

    /// Maximum value of the font variation instances that satisfy this condition.

    filter_range_max_value: F2Dot14,

}

/// A feature table substitution.

pub enum FeatureTableSubstitution<'a> {

    /// This substitution performs no substitution.

    NoSubstitution,

    /// The substitute feature table.

    Table(FeatureTableSubstitutionTable<'a>),

}

/// Substitute feature table.

pub struct FeatureTableSubstitutionTable<'a> {

    substitution_scope: ReadScope<'a>,

    substitutions: ReadArray<'a, FeatureTableSubstitutionRecord>,

}

/// A feature table substitution that indicates the alternate feature table for a feature index.

pub struct FeatureTableSubstitutionRecord {

    /// The feature table index to match.

    feature_index: u16,

    /// Offset to an alternate feature table, from start of the FeatureTableSubstitution table.

    alternate_feature_offset: u32,

}

pub struct LookupList<T> {

    scope_owned: ReadScopeOwned,

    lookup_offsets: Vec<u16>,

    phantom: PhantomData<T>,

}

pub struct Lookup<'a, T: LayoutTableType> {

    scope: ReadScope<'a>,

    lookup_type: LookupType<T>,

    pub lookup_flag: LookupFlag,

    subtable_offsets: ReadArray<'a, U16Be>,

    /// Index (base 0) into GDEF mark glyph sets structure.

    ///

    /// This field is only present if the USE_MARK_FILTERING_SET lookup flag is set.

    mark_filtering_set: Option<u16>,

    phantom: PhantomData<T>,

}

pub struct ExtensionSubst<'a, T: LayoutTableType> {

    scope: ReadScope<'a>,

    extension_lookup_type: T::BaseLookupType,

    extension_offset: u32,

}

pub struct LookupSubtableIter<'a, 'b, T: LayoutTableType> {

    lookup: &'b Lookup<'a, T>,

    index: usize,

}

pub struct ExtensionLookupSubtableIter<'a, 'b, T: LayoutTableType> {

    lookup_type: T::BaseLookupType,

    iter: LookupSubtableIter<'a, 'b, T>,

}

pub enum SmartLookupSubtableIter<'a, 'b, T: LayoutTableType> {

    Normal(T::BaseLookupType, LookupSubtableIter<'a, 'b, T>),

    Extension(ExtensionLookupSubtableIter<'a, 'b, T>),

}

pub enum LookupType<T: LayoutTableType> {

    Normal(T::BaseLookupType),

    Extension,

}

#[derive(Copy, Clone, PartialEq)]

pub enum SubstLookupType {

    SingleSubst,

    MultipleSubst,

    AlternateSubst,

    LigatureSubst,

    ContextSubst,

    ChainContextSubst,

    ReverseChainSingleSubst,

}

#[derive(Copy, Clone, PartialEq)]

pub enum PosLookupType {

    SinglePos,

    PairPos,

    CursivePos,

    MarkBasePos,

    MarkLigPos,

    MarkMarkPos,

    ContextPos,

    ChainContextPos,

}

pub enum SubstLookup {

    SingleSubst(Vec<SingleSubst>),

    MultipleSubst(Vec<MultipleSubst>),

    AlternateSubst(Vec<AlternateSubst>),

    LigatureSubst(Vec<LigatureSubst>),

    ContextSubst(Vec<ContextLookup<GSUB>>),

    ChainContextSubst(Vec<ChainContextLookup<GSUB>>),

    ReverseChainSingleSubst(Vec<ReverseChainSingleSubst>),

}

pub enum PosLookup {

    SinglePos(Vec<SinglePos>),

    PairPos(Vec<PairPos>),

    CursivePos(Vec<CursivePos>),

    MarkBasePos(Vec<MarkBasePos>),

    MarkLigPos(Vec<MarkLigPos>),

    MarkMarkPos(Vec<MarkBasePos>),

    ContextPos(Vec<ContextLookup<GPOS>>),

    ChainContextPos(Vec<ChainContextLookup<GPOS>>),

}

pub trait LayoutTableType: Sized {

    type LookupType;

    type BaseLookupType: Copy + PartialEq;

    fn check_lookup_type(lookup_type: u16) -> Result<LookupType<Self>, ParseError>;

}

impl ReadBinary for GDEFTable {

    type HostType<'a> = Self;

        // MarkAttachClassDef was added to GDEF in OpenType 1.2 but they did not change the GDEF

        // version. This means that it's not possible to know from the version alone whether the

        // field should be read. Some implementations use GSUB/GPOS to determine if it should be

        // read, others use heuristics based on the offsets in the prior fields.  Based on testing

        // of this code and the fact that HarfBuzz _appears_ to always attempt to read the field we

        // do the same.

        //

        // See: https://github.com/yeslogic/prince/issues/297 for more detail.

        };

        // Offset to the table of mark glyph set definitions, from beginning of GDEF header (may be NULL).

        } else {

        };

        // Offset to the item variation store table, from beginning of GDEF header (may be NULL).

        } else {

        };

        } else {

        };

        /*

                let opt_attach_list = if attach_list_offset >= table.data().len() {

                    return Err(ParseError::BadOffset);

                } else if attach_list_offset == 0 {

                    None

                } else if attach_list_offset < gdef_header_size {

                    return Err(ParseError::BadOffset);

                } else {

                    Some(table.offset(attach_list_offset))

                };

                let opt_lig_caret_list = if lig_caret_list_offset >= table.data().len() {

                    return Err(ParseError::BadOffset);

                } else if lig_caret_list_offset == 0 {

                    None

                } else if lig_caret_list_offset < gdef_header_size {

                    return Err(ParseError::BadOffset);

                } else {

                    Some(table.offset(lig_caret_list_offset))

                };

        */

        } else {

            Some(

            )

        };

        } else {

            Some(

            )

        };

}

impl<T> ReadBinary for LayoutTable<T> {

    type HostType<'a> = Self;

        // We handle versions 1.x

        } else {

        };

        } else {

        };

        } else {

        };

        // Version 1.1 also includes an offset to a FeatureVariations table.

}

impl ReadBinary for ScriptList {

    type HostType<'a> = Self;

}

impl ReadBinaryDep for ScriptRecord {

    type Args<'a> = ReadScope<'a>;

    type HostType<'a> = ScriptRecord;

}

impl ReadFixedSizeDep for ScriptRecord {

}

impl ReadBinary for ScriptTable {

    type HostType<'a> = Self;

        } else {

        };

}

impl ReadBinary for FeatureList {

    type HostType<'a> = Self;

}

impl FeatureList {

}

impl FeatureRecord {

}

impl ReadBinaryDep for FeatureRecord {

    type Args<'a> = ReadScope<'a>;

    type HostType<'a> = FeatureRecord;

}

impl ReadFixedSizeDep for FeatureRecord {

}

impl ReadBinary for FeatureTable {

    type HostType<'a> = Self;

}

impl ReadBinary for FeatureVariations<'_> {

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

}

impl FeatureVariationsOwned {

    /// Match this record against a variation tuple and return the feature table substitution if it matches.

            // The first feature variation record for which the condition set matches the runtime

            // context will be considered as a candidate: if the version of the

            // FeatureTableSubstitution table is supported, then this feature variation record will

            // be used, and no additional feature variation records will be considered. If the

            // version of the FeatureTableSubstitution table is not supported, then this feature

            // variation record is rejected and processing will move to the next feature variation

            // record.

            //

            // https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#featurevariations-table

            }

        }

}

impl ReadBinary for FeatureVariationsOwned {

    type HostType<'a> = FeatureVariationsOwned;

}

impl FeatureVariationRecord {

    /// Match this record against a variation tuple and return the feature table substitution if it matches.

        } else {

        }

        // If the ConditionSet offset is 0, there is no condition set table. This is treated as

        // the universal condition: all contexts are matched.

        } else {

        }

        // If the FeatureTableSubstitution offset is 0, there is no feature table substitution table,

        // and no substitutions are made.

        } else {

        }

}

impl ReadFrom for FeatureVariationRecord {

    type ReadType = (U32Be, U32Be);

}

impl FeatureTableSubstitution<'_> {

    /// Perform feature table substitution for the supplied `feature_index`.

                        // "If a record is encountered with a higher feature index value,

                        // stop searching for that feature index; no substitution is made."

                }

            }

        }

}

impl ReadBinary for FeatureTableSubstitutionTable<'_> {

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

}

impl ReadFrom for FeatureTableSubstitutionRecord {

    type ReadType = (U16Be, U32Be);

}

impl ConditionSet<'_> {

        }

}

impl ConditionSetTable<'_> {

        // For a given condition set, conditions are conjunctively related (boolean AND): all of

        // the specified conditions must be met in order for the associated feature table

        // substitution to be applied. A condition set does not need to specify conditional values

        // for all possible factors. If no values are specified for some factor, then the condition

        // set matches all runtime values for that factor.

}

impl ReadBinary for ConditionSetTable<'_> {

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

}

impl ConditionTable {

            // New condition table formats for other condition qualifiers may be added in the

            // future. If a layout engine encounters a condition table with an unrecognized format,

            // it should fail to match the condition set, but continue to test other condition

            // sets. In this way, new condition formats can be defined and used in fonts that can

            // work in a backward-compatible way in existing implementations.

                // A font variation axis range condition is met if the currently-selected variation

                // instance has a value for the given axis that is greater than or equal to the

                // filterRangeMinValue, and that is less than or equal to the filterRangeMaxValue.

                };

            }

        }

}

impl ReadBinary for ConditionTable {

    type HostType<'a> = Self;

        }

}

impl ReadFrom for ConditionFormat1 {

    type ReadType = (U16Be, F2Dot14, F2Dot14);

}

impl<T> ReadBinary for LookupList<T> {

    type HostType<'a> = Self;

}

impl ReadBinary for LangSys {

    type HostType<'a> = Self;

}

impl LangSysRecord {

}

impl LangSys {

}

impl<T> LayoutTable<T> {

            } else {

            }

                    // see if feature index is in feature_variations

            }

        } else {

        }

        }

}

impl ScriptList {

        }

}

impl ScriptRecord {

}

impl ScriptTable {

        }

            },

        }

}

impl ReadBinaryDep for LangSysRecord {

    type Args<'a> = ReadScope<'a>;

    type HostType<'a> = LangSysRecord;

}

impl ReadFixedSizeDep for LangSysRecord {

}

impl<T: LayoutTableType> LookupList<T> {

}

impl LookupList<GSUB> {

            SubstLookupType::SingleSubst => {

            }

            SubstLookupType::MultipleSubst => {

            }

            SubstLookupType::AlternateSubst => {

            }

            SubstLookupType::LigatureSubst => {

            }

            SubstLookupType::ContextSubst => {

            }

            SubstLookupType::ChainContextSubst => SubstLookup::ChainContextSubst(

            ),

            SubstLookupType::ReverseChainSingleSubst => SubstLookup::ReverseChainSingleSubst(

            ),

        };

}

impl LookupList<GPOS> {

            PosLookupType::SinglePos => {

            }

            PosLookupType::CursivePos => {

            }

            PosLookupType::MarkBasePos => {

            }

            PosLookupType::MarkLigPos => {

            }

            PosLookupType::MarkMarkPos => {

            }

            PosLookupType::ContextPos => {

            }

            PosLookupType::ChainContextPos => PosLookup::ChainContextPos(

            ),

        };

}

impl<'a, T: LayoutTableType + 'static> Lookup<'a, T> {

            }

            LookupType::Extension => {

                } else {

                }

            }

        }

            }

        }

            }

        }

}

impl<T: LayoutTableType> ReadBinary for Lookup<'_, T> {

    type HostType<'a> = Lookup<'a, T>;

        } else {

        };

}

impl<T: LayoutTableType> ReadBinary for ExtensionSubst<'_, T> {

    type HostType<'a> = ExtensionSubst<'a, T>;

            1 => {

                };

            }

        }

}

impl<'a, T: LayoutTableType> Iterator for LookupSubtableIter<'a, '_, T> {

    type Item = ReadScope<'a>;

        } else {

        }

}

impl<'a, T: LayoutTableType> Iterator for ExtensionLookupSubtableIter<'a, '_, T> {

    type Item = Result<ReadScope<'a>, ParseError>;

                }

            }

        } else {

        }

}

impl<'a, T: LayoutTableType> Iterator for SmartLookupSubtableIter<'a, '_, T> {

    type Item = Result<ReadScope<'a>, ParseError>;

        }

        }

}

impl<T: LayoutTableType> SmartLookupSubtableIter<'_, '_, T> {

        }

}

impl LayoutTableType for GSUB {