//! Metrics scaling.
//!
//! Uses the widths and blues computations to generate unscaled metrics for a
//! given style/script.
//!
//! Then applies a scaling factor to those metrics, computes a potentially
//! modified scale, and tags active blue zones.

use super::super::{
    metrics::{
        fixed_div, fixed_mul, fixed_mul_div, pix_round, BlueZones, Scale, ScaledAxisMetrics,
        ScaledBlue, ScaledStyleMetrics, ScaledWidth, UnscaledAxisMetrics, UnscaledBlue,
        UnscaledStyleMetrics, WidthMetrics,
    },
    shape::{Shaper, ShaperMode},
    style::{ScriptGroup, StyleClass},
    topo::Dimension,
    QuirksMode,
};
use crate::{instance::NormalizedCoord, prelude::Size, FontRef, MetadataProvider};
use raw::types::F2Dot14;

impl UnscaledStyleMetrics {
    /// Creates a set of metrics for the given font, normalized coordinates
    /// and style class.
    pub fn new(font: &FontRef, coords: &[NormalizedCoord], style: &StyleClass) -> Self {
        let shaper_mode = if cfg!(feature = "autohint_shaping") {
            ShaperMode::BestEffort
        } else {
            ShaperMode::Nominal
        };
        let shaper = Shaper::new(font, shaper_mode);
        compute_unscaled_style_metrics(&shaper, coords, style, QuirksMode::Aot)
    }

    /// Applies the given scale to this set of style metrics.
    pub fn scale(&self, scale: Scale) -> ScaledStyleMetrics {
        scale_style_metrics(self, scale, QuirksMode::Aot)
    }
}

/// Computes unscaled metrics for the Latin writing system.
///
/// See <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/autofit/aflatin.c#L1134>
pub(crate) fn compute_unscaled_style_metrics(
    shaper: &Shaper,
    coords: &[F2Dot14],
    style: &StyleClass,
    quirks: QuirksMode,
) -> UnscaledStyleMetrics {
    let charmap = shaper.charmap();
    // We don't attempt to produce any metrics if we don't have a Unicode
    // cmap
    // See <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/autofit/aflatin.c#L1146>
    if charmap.is_symbol() {
        return UnscaledStyleMetrics {
            class_ix: style.index as u16,
            axes: [
                UnscaledAxisMetrics {
                    dim: Dimension::Horizontal,
                    ..Default::default()
                },
                UnscaledAxisMetrics {
                    dim: Dimension::Vertical,
                    ..Default::default()
                },
            ],
            ..Default::default()
        };
    }
    let [hwidths, vwidths] = super::widths::compute_widths(shaper, coords, style, quirks);
    let [hblues, vblues] = super::blues::compute_unscaled_blues(shaper, coords, style);
    let glyph_metrics = shaper.font().glyph_metrics(Size::unscaled(), coords);
    let mut digit_advance = None;
    let mut digits_have_same_width = true;
    for ch in '0'..='9' {
        if let Some(advance) = charmap
            .map(ch)
            .and_then(|gid| glyph_metrics.advance_width(gid))
        {
            if digit_advance.is_some() && digit_advance != Some(advance) {
                digits_have_same_width = false;
                break;
            }
            digit_advance = Some(advance);
        }
    }
    UnscaledStyleMetrics {
        class_ix: style.index as u16,
        digits_have_same_width,
        axes: [
            UnscaledAxisMetrics {
                dim: Dimension::Horizontal,
                blues: hblues,
                width_metrics: hwidths.0,
                widths: hwidths.1,
            },
            UnscaledAxisMetrics {
                dim: Dimension::Vertical,
                blues: vblues,
                width_metrics: vwidths.0,
                widths: vwidths.1,
            },
        ],
    }
}

/// Computes scaled metrics for the Latin writing system.
///
/// See <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/autofit/aflatin.c#L1491>
pub(crate) fn scale_style_metrics(
    unscaled_metrics: &UnscaledStyleMetrics,
    mut scale: Scale,
    quirks: QuirksMode,
) -> ScaledStyleMetrics {
    let scale_axis_fn = if unscaled_metrics.style_class().script.group == ScriptGroup::Default {
        scale_default_axis_metrics
    } else {
        scale_cjk_axis_metrics
    };
    let mut scale_axis = |axis: &UnscaledAxisMetrics| {
        scale_axis_fn(
            axis.dim,
            &axis.widths,
            axis.width_metrics,
            &axis.blues,
            &mut scale,
            quirks,
        )
    };
    let axes = [
        scale_axis(&unscaled_metrics.axes[0]),
        scale_axis(&unscaled_metrics.axes[1]),
    ];
    ScaledStyleMetrics { scale, axes }
}

/// Computes scaled metrics for a single axis.
///
/// See <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/autofit/aflatin.c#L1168>
fn scale_default_axis_metrics(
    dim: Dimension,
    widths: &[i32],
    width_metrics: WidthMetrics,
    blues: &[UnscaledBlue],
    scale: &mut Scale,
    quirks: QuirksMode,
) -> ScaledAxisMetrics {
    let mut axis = ScaledAxisMetrics {
        dim,
        ..Default::default()
    };
    if dim == Dimension::Horizontal {
        axis.scale = scale.x_scale;
        axis.delta = scale.x_delta;
    } else {
        axis.scale = scale.y_scale;
        axis.delta = scale.y_delta;
    };
    // Correct Y scale to optimize alignment
    if let Some(blue_ix) = blues
        .iter()
        .position(|blue| blue.zones.contains(BlueZones::ADJUSTMENT))
    {
        let unscaled_blue = &blues[blue_ix];
        let scaled = fixed_mul(axis.scale, unscaled_blue.overshoot);
        let fitted = (scaled + 40) & !63;
        if scaled != fitted && dim == Dimension::Vertical {
            let new_scale = fixed_mul_div(axis.scale, fitted, scaled);
            // Scaling should not adjust by more than 2 pixels
            let mut max_height = scale.units_per_em;
            for blue in blues {
                max_height = max_height.max(blue.ascender).max(-blue.descender);
            }
            let mut dist = fixed_mul(max_height, new_scale - axis.scale).abs();
            dist &= !127;
            if dist == 0 {
                axis.scale = new_scale;
                scale.y_scale = new_scale;
            }
        }
    }
    // Now scale the widths. FreeType ensures there is always at least one
    // width entry (the standard width), even if width extraction found none.
    axis.width_metrics = width_metrics;
    if widths.is_empty() && quirks == QuirksMode::Aot {
        let scaled = fixed_mul(axis.scale, axis.width_metrics.standard_width);
        axis.widths.push(ScaledWidth {
            scaled,
            fitted: scaled,
        });
    } else {
        for unscaled_width in widths {
            let scaled = fixed_mul(axis.scale, *unscaled_width);
            axis.widths.push(ScaledWidth {
                scaled,
                fitted: scaled,
            });
        }
    }
    // Compute extra light property: this is a standard width that is
    // less than 5/8 pixels
    axis.width_metrics.is_extra_light =
        fixed_mul(axis.width_metrics.standard_width, axis.scale) < (32 + 8);
    if dim == Dimension::Vertical {
        // And scale the blue zones
        for unscaled_blue in blues {
            let scaled_position = fixed_mul(axis.scale, unscaled_blue.position) + axis.delta;
            let scaled_overshoot = fixed_mul(axis.scale, unscaled_blue.overshoot) + axis.delta;
            let mut blue = ScaledBlue {
                position: ScaledWidth {
                    scaled: scaled_position,
                    fitted: scaled_position,
                },
                overshoot: ScaledWidth {
                    scaled: scaled_overshoot,
                    fitted: scaled_overshoot,
                },
                zones: unscaled_blue.zones,
                is_active: false,
            };
            // Only activate blue zones less than 3/4 pixel tall
            let dist = fixed_mul(unscaled_blue.position - unscaled_blue.overshoot, axis.scale);
            if (-48..=48).contains(&dist) {
                let mut delta = dist.abs();
                if delta < 32 {
                    delta = 0;
                } else if delta < 48 {
                    delta = 32;
                } else {
                    delta = 64;
                }
                if dist < 0 {
                    delta = -delta;
                }
                blue.position.fitted = pix_round(blue.position.scaled);
                blue.overshoot.fitted = blue.position.fitted - delta;
                blue.is_active = true;
            }
            axis.blues.push(blue);
        }
        // Use sub-top blue zone if it doesn't overlap with another
        // non-sub-top blue zone
        for blue_ix in 0..axis.blues.len() {
            let blue = axis.blues[blue_ix];
            if !blue.zones.is_sub_top() || !blue.is_active {
                continue;
            }
            for blue2 in &axis.blues {
                if blue2.zones.is_sub_top() || !blue2.is_active {
                    continue;
                }
                if blue2.position.fitted <= blue.overshoot.fitted
                    && blue2.overshoot.fitted >= blue.position.fitted
                {
                    axis.blues[blue_ix].is_active = false;
                    break;
                }
            }
        }
    }
    axis
}

/// Computes scaled metrics for a single axis for the CJK script group.
///
/// See <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/autofit/afcjk.c#L661>
fn scale_cjk_axis_metrics(
    dim: Dimension,
    widths: &[i32],
    width_metrics: WidthMetrics,
    blues: &[UnscaledBlue],
    scale: &mut Scale,
    _quirks: QuirksMode,
) -> ScaledAxisMetrics {
    let mut axis = ScaledAxisMetrics {
        dim,
        ..Default::default()
    };
    axis.dim = dim;
    if dim == Dimension::Horizontal {
        axis.scale = scale.x_scale;
        axis.delta = scale.x_delta;
    } else {
        axis.scale = scale.y_scale;
        axis.delta = scale.y_delta;
    };
    let scale = axis.scale;
    // Scale the blue zones
    for unscaled_blue in blues {
        let position = fixed_mul(unscaled_blue.position, scale) + axis.delta;
        let overshoot = fixed_mul(unscaled_blue.overshoot, scale) + axis.delta;
        let mut blue = ScaledBlue {
            position: ScaledWidth {
                scaled: position,
                fitted: position,
            },
            overshoot: ScaledWidth {
                scaled: overshoot,
                fitted: overshoot,
            },
            zones: unscaled_blue.zones,
            is_active: false,
        };
        // A blue zone is only active if it is less than 3/4 pixels tall
        let dist = fixed_mul(unscaled_blue.position - unscaled_blue.overshoot, scale);
        if (-48..=48).contains(&dist) {
            blue.position.fitted = pix_round(blue.position.scaled);
            // For CJK, "overshoot" is actually undershoot
            let delta1 = fixed_div(blue.position.fitted, scale) - unscaled_blue.overshoot;
            let mut delta2 = fixed_mul(delta1.abs(), scale);
            if delta2 < 32 {
                delta2 = 0;
            } else {
                delta2 = pix_round(delta2);
            }
            if delta1 < 0 {
                delta2 = -delta2;
            }
            blue.overshoot.fitted = blue.position.fitted - delta2;
            blue.is_active = true;
        }
        axis.blues.push(blue);
    }
    // FreeType never seems to compute scaled width values. We'll just
    // match this behavior for now.
    // <https://github.com/googlefonts/fontations/issues/1129>
    for _ in 0..widths.len() {
        axis.widths.push(ScaledWidth::default());
    }
    axis.width_metrics = width_metrics;
    axis
}

#[cfg(test)]
mod tests {
    use super::{
        super::super::{shape::ShaperMode, style},
        *,
    };
    use crate::attribute::Style;
    use raw::{FontRef, TableProvider};

    #[test]
    fn scaled_metrics_default() {
        // Note: expected values scraped from a FreeType debugging
        // session
        let scaled_metrics = make_scaled_metrics(
            font_test_data::NOTOSERIFHEBREW_AUTOHINT_METRICS,
            StyleClass::HEBR,
        );
        // Check scale and deltas
        assert_eq!(scaled_metrics.scale.x_scale, 67109);
        assert_eq!(scaled_metrics.scale.y_scale, 67109);
        assert_eq!(scaled_metrics.scale.x_delta, 0);
        assert_eq!(scaled_metrics.scale.y_delta, 0);
        // Horizontal widths
        let h_axis = &scaled_metrics.axes[0];
        let expected_h_widths = [55];
        // No horizontal blues
        check_axis(h_axis, &expected_h_widths, &[]);
        // Not extra light
        assert!(!h_axis.width_metrics.is_extra_light);
        // Vertical widths
        let v_axis = &scaled_metrics.axes[1];
        let expected_v_widths = [22, 112];
        // Vertical blues
        #[rustfmt::skip]
        let expected_v_blues = [
            // ((scaled_pos, fitted_pos), (scaled_shoot, fitted_shoot), flags, is_active)
            ScaledBlue::from(((606, 576), (606, 576), BlueZones::TOP, true)),
            ScaledBlue::from(((0, 0), (-9, 0), BlueZones::default(), true)),
            ScaledBlue::from(((-246, -256), (-246, -256), BlueZones::default(), true)),
        ];
        check_axis(v_axis, &expected_v_widths, &expected_v_blues);
        // This one is extra light
        assert!(v_axis.width_metrics.is_extra_light);
    }

    #[test]
    fn cjk_scaled_metrics() {
        // Note: expected values scraped from a FreeType debugging
        // session
        let scaled_metrics = make_scaled_metrics(
            font_test_data::NOTOSERIFTC_AUTOHINT_METRICS,
            StyleClass::HANI,
        );
        // Check scale and deltas
        assert_eq!(scaled_metrics.scale.x_scale, 67109);
        assert_eq!(scaled_metrics.scale.y_scale, 67109);
        assert_eq!(scaled_metrics.scale.x_delta, 0);
        assert_eq!(scaled_metrics.scale.y_delta, 0);
        // Horizontal widths
        let h_axis = &scaled_metrics.axes[0];
        let expected_h_widths = [0];
        check_axis(h_axis, &expected_h_widths, &[]);
        // Not extra light
        assert!(!h_axis.width_metrics.is_extra_light);
        // Vertical widths
        let v_axis = &scaled_metrics.axes[1];
        let expected_v_widths = [0];
        // Vertical blues
        #[rustfmt::skip]
        let expected_v_blues = [
            // ((scaled_pos, fitted_pos), (scaled_shoot, fitted_shoot), flags, is_active)
            ScaledBlue::from(((857, 832), (844, 832), BlueZones::TOP, true)),
            ScaledBlue::from(((-80, -64), (-68, -64), BlueZones::default(), true)),
        ];
        // No horizontal blues
        check_axis(v_axis, &expected_v_widths, &expected_v_blues);
        // Also not extra light
        assert!(!v_axis.width_metrics.is_extra_light);
    }

    fn make_scaled_metrics(font_data: &[u8], style_class: usize) -> ScaledStyleMetrics {
        let font = FontRef::new(font_data).unwrap();
        let class = &style::STYLE_CLASSES[style_class];
        let shaper = Shaper::new(&font, ShaperMode::Nominal);
        let unscaled_metrics = compute_unscaled_style_metrics(
            &shaper,
            Default::default(),
            class,
            QuirksMode::default(),
        );
        let scale = Scale::new(
            16.0,
            font.head().unwrap().units_per_em() as i32,
            Style::Normal,
            Default::default(),
            class.script.group,
        );
        scale_style_metrics(&unscaled_metrics, scale, QuirksMode::default())
    }

    fn check_axis(
        axis: &ScaledAxisMetrics,
        expected_widths: &[i32],
        expected_blues: &[ScaledBlue],
    ) {
        let widths = axis
            .widths
            .iter()
            .map(|width| width.scaled)
            .collect::<Vec<_>>();
        assert_eq!(widths, expected_widths);
        assert_eq!(axis.blues.as_slice(), expected_blues);
    }

    impl From<(i32, i32)> for ScaledWidth {
        fn from(value: (i32, i32)) -> Self {
            Self {
                scaled: value.0,
                fitted: value.1,
            }
        }
    }

    impl From<((i32, i32), (i32, i32), BlueZones, bool)> for ScaledBlue {
        fn from(value: ((i32, i32), (i32, i32), BlueZones, bool)) -> Self {
            Self {
                position: value.0.into(),
                overshoot: value.1.into(),
                zones: value.2,
                is_active: value.3,
            }
        }
    }
}