//! Runtime autohinting support.

mod hint;
mod instance;
mod metrics;
mod outline;
mod recorder;
mod shape;
mod style;
mod topo;

pub use instance::GlyphStyles;
pub(crate) use instance::Instance;
pub use metrics::{
    BlueZones, Scale, ScaleFlags, ScaledAxisMetrics, ScaledBlue, ScaledStyleMetrics, ScaledWidth,
    UnscaledAxisMetrics, UnscaledBlue, UnscaledStyleMetrics, WidthMetrics,
};
pub use outline::Direction;
pub use recorder::{EdgeAction, EdgeHint, HintAction, PointAction, PointHint};
pub use style::{GlyphStyle, ScriptClass, ScriptGroup, StyleClass};
pub use style::{SCRIPT_CLASSES, STYLE_CLASSES};
pub use topo::{Axis, BlueProvenance, Dimension, Edge, Segment, TopoFlags};

use crate::outline::{DrawError, Target};
use crate::{FontRef, MetadataProvider};
use alloc::vec::Vec;
use raw::types::{F2Dot14, GlyphId};

/// Controls quirks for the different autohinters.
#[derive(Copy, Clone, PartialEq, Eq, Default, Debug)]
enum QuirksMode {
    /// Just in time hinter; matches FreeType.
    #[default]
    Jit,
    /// Ahead of time hinter; matches ttfautohint.
    Aot,
}

/// Plan for hinting an outline.
#[derive(Clone, Debug, Default)]
pub struct HintPlan {
    hints: Vec<HintAction>,
    axes: [Option<Axis>; 2],
}

impl HintPlan {
    /// Creates a new hint plan.
    pub fn new(
        font: &FontRef,
        coords: &[F2Dot14],
        ppem: f32,
        target: Target,
        glyph_id: GlyphId,
        glyph_style: GlyphStyle,
    ) -> Result<Self, DrawError> {
        let style_class = glyph_style
            .style_class()
            .ok_or(DrawError::GlyphNotFound(glyph_id))?;
        let outline_glyph = font
            .outline_glyphs()
            .get(glyph_id)
            .ok_or(DrawError::GlyphNotFound(glyph_id))?;

        let shaper_mode = if cfg!(feature = "autohint_shaping") {
            shape::ShaperMode::BestEffort
        } else {
            shape::ShaperMode::Nominal
        };
        let shaper = shape::Shaper::new(font, shaper_mode);
        let metrics =
            metrics::compute_unscaled_style_metrics(&shaper, coords, style_class, QuirksMode::Aot);

        let mut outline = outline::Outline::default();
        outline.fill(&outline_glyph, coords, QuirksMode::Aot)?;

        let scale = metrics::Scale::new(
            ppem,
            outline_glyph.units_per_em() as i32,
            font.attributes().style,
            target,
            metrics.style_class().script.group,
        );

        let mut recorder = recorder::HintsRecorder::default();
        let hinted_plan = hint::hint_outline_with_recorder(
            &mut outline,
            &metrics,
            &scale,
            Some(glyph_style),
            &mut recorder,
        );

        Ok(Self {
            hints: recorder.actions,
            axes: hinted_plan.axes,
        })
    }

    /// Returns the collection of hinting actions.
    pub fn actions(&self) -> &[HintAction] {
        &self.hints
    }

    /// Returns the topological analysis of the horizontal axis.
    pub fn horizontal_axis(&self) -> Option<&Axis> {
        self.axes[Dimension::Horizontal].as_ref()
    }

    /// Returns the topological analysis of the vertical axis.
    pub fn vertical_axis(&self) -> Option<&Axis> {
        self.axes[Dimension::Vertical].as_ref()
    }
}

/// All constants are defined based on a UPEM of 2048.
///
/// See <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/autofit/aflatin.h#L34>
fn derived_constant(units_per_em: i32, value: i32) -> i32 {
    value * units_per_em / 2048
}