fontcull-skrifa 0.39.2

#[cfg(test)]
pub mod test_glyph_defs;

use fontcull_read_fonts::{
    tables::colr::{CompositeMode, Extend},
    types::{BoundingBox, GlyphId, Point},
    FontRef,
};
use serde::{Deserialize, Serialize};

use std::{
    env,
    fs::OpenOptions,
    io::{self, BufRead, Write},
    string::String,
};

use crate::{
    alloc::vec::Vec,
    color::{
        transform::Transform, traversal_tests::test_glyph_defs::*, Brush, ColorPainter, ColorStop,
    },
    setting::VariationSetting,
    MetadataProvider,
};

#[derive(Serialize, Deserialize, Default, PartialEq)]
struct PaintDump {
    glyph_id: u32,
    ops: Vec<PaintOps>,
}

impl From<Brush<'_>> for BrushParams {
    fn from(brush: Brush) -> Self {
        match brush {
            Brush::Solid {
                palette_index,
                alpha,
            } => BrushParams::Solid {
                palette_index,
                alpha,
            },
            Brush::LinearGradient {
                p0,
                p1,
                color_stops,
                extend,
            } => BrushParams::LinearGradient {
                p0,
                p1,
                color_stops: color_stops.to_vec(),
                extend,
            },
            Brush::RadialGradient {
                c0,
                r0,
                c1,
                r1,
                color_stops,
                extend,
            } => BrushParams::RadialGradient {
                c0,
                r0,
                c1,
                r1,
                color_stops: color_stops.to_vec(),
                extend,
            },
            Brush::SweepGradient {
                c0,
                start_angle,
                end_angle,
                color_stops,
                extend,
            } => BrushParams::SweepGradient {
                c0,
                start_angle,
                end_angle,
                color_stops: color_stops.to_vec(),
                extend,
            },
        }
    }
}

// Needed as a mirror struct with owned ColorStops for serialization, deserialization.
#[derive(Serialize, Deserialize, PartialEq)]
pub enum BrushParams {
    Solid {
        palette_index: u16,
        alpha: f32,
    },
    // Normalized to a straight line between points p0 and p1,
    // color stops normalized to align with both points.
    LinearGradient {
        p0: Point<f32>,
        p1: Point<f32>,
        color_stops: Vec<ColorStop>,
        extend: Extend,
    },
    RadialGradient {
        c0: Point<f32>,
        r0: f32,
        c1: Point<f32>,
        r1: f32,
        color_stops: Vec<ColorStop>,
        extend: Extend,
    },
    SweepGradient {
        c0: Point<f32>,
        start_angle: f32,
        end_angle: f32,
        color_stops: Vec<ColorStop>,
        extend: Extend,
    },
}

// Wrapping Transform for tests, as the results of trigonometric functions, in
// particular the tan() cases in PaintSkew need floating point PartialEq
// comparisons with an epsilon because the result of the tan() function differs
// on different platforms/archictectures.
#[derive(Serialize, Deserialize)]
struct DumpTransform(Transform);

// Using the same value as in SK_ScalarNearlyZero from Skia (see SkScalar.h).
const NEARLY_EQUAL_TOLERANCE: f32 = 1.0 / (1 << 12) as f32;

fn nearly_equal(a: f32, b: f32) -> bool {
    (a - b).abs() < NEARLY_EQUAL_TOLERANCE
}

impl PartialEq<DumpTransform> for DumpTransform {
    fn eq(&self, other: &DumpTransform) -> bool {
        nearly_equal(self.0.xx, other.0.xx)
            && nearly_equal(self.0.xy, other.0.xy)
            && nearly_equal(self.0.yx, other.0.yx)
            && nearly_equal(self.0.yy, other.0.yy)
            && nearly_equal(self.0.dx, other.0.dx)
            && nearly_equal(self.0.dy, other.0.dy)
    }
}

impl From<Transform> for DumpTransform {
    fn from(value: Transform) -> Self {
        Self(value)
    }
}

#[derive(Serialize, Deserialize, PartialEq)]
enum PaintOps {
    PushTransform {
        transform: DumpTransform,
    },
    PopTransform,
    PushClipGlyph {
        gid: u32,
    },
    PushClipBox {
        clip_box: BoundingBox<f32>,
    },
    PopClip,
    FillBrush {
        brush: BrushParams,
    },
    FillGlyph {
        gid: u32,
        transform: DumpTransform,
        brush: BrushParams,
    },
    PushLayer {
        composite_mode: u8,
    },
    PopLayer,
}

impl ColorPainter for PaintDump {
    fn push_transform(&mut self, transform: Transform) {
        self.ops.push(PaintOps::PushTransform {
            transform: transform.into(),
        });
    }
    fn pop_transform(&mut self) {
        self.ops.push(PaintOps::PopTransform);
    }

    fn push_clip_glyph(&mut self, glyph: GlyphId) {
        self.ops.push(PaintOps::PushClipGlyph {
            gid: glyph.to_u32(),
        });
    }

    fn push_clip_box(&mut self, clip_box: BoundingBox<f32>) {
        self.ops.push(PaintOps::PushClipBox { clip_box });
    }

    fn pop_clip(&mut self) {
        self.ops.push(PaintOps::PopClip);
    }

    fn fill(&mut self, brush: Brush) {
        self.ops.push(PaintOps::FillBrush {
            brush: brush.into(),
        });
    }

    fn fill_glyph(&mut self, glyph_id: GlyphId, transform: Option<Transform>, brush: Brush) {
        self.ops.push(PaintOps::FillGlyph {
            gid: glyph_id.to_u32(),
            transform: transform.unwrap_or_default().into(),
            brush: brush.into(),
        });
    }

    fn push_layer(&mut self, composite_mode: CompositeMode) {
        self.ops.push(PaintOps::PushLayer {
            composite_mode: composite_mode as u8,
        });
    }
    fn pop_layer(&mut self) {
        self.ops.push(PaintOps::PopLayer);
    }
}

impl PaintDump {
    pub fn new(gid: u32) -> Self {
        Self {
            glyph_id: gid,
            ..Default::default()
        }
    }
}

fn location_to_filename<I>(set_name: &str, settings: I) -> String
where
    I: IntoIterator,
    I::Item: Into<VariationSetting>,
{
    let formatted_settings: Vec<String> = settings
        .into_iter()
        .map(|entry| {
            let entry_setting = entry.into();
            format!("{:}_{:}", entry_setting.selector, entry_setting.value)
        })
        .collect();
    let suffix = match formatted_settings.len() {
        0 => String::new(),
        _ => format!("_{}", formatted_settings.join("_")),
    };
    format!("colrv1_{}{}", set_name.to_lowercase(), suffix)
}

fn should_rebaseline() -> bool {
    env::var("REBASELINE_COLRV1_TESTS").is_ok()
}

// To regenerate the baselines, set the environment variable `REBASELINE_COLRV1_TESTS`
// when running tests, for example like this:
// $ REBASELINE_COLRV1_TESTS=1 cargo test color::traversal
fn colrv1_traversal_test(
    set_name: &str,
    test_chars: &[char],
    settings: &[(&str, f32)],
    required_format: crate::color::ColorGlyphFormat,
) {
    let colr_font = fontcull_font_test_data::COLRV0V1_VARIABLE;
    let font = FontRef::new(colr_font).unwrap();

    let location = font.axes().location(settings);

    let dumpfile_path = format!(
        "../font-test-data/test_data/colrv1_json/{}",
        location_to_filename(set_name, settings)
    );

    let test_gids = test_chars
        .iter()
        .map(|codepoint| font.charmap().map(*codepoint).unwrap());

    let paint_dumps_iter = test_gids.map(|gid| {
        let mut color_painter = PaintDump::new(gid.to_u32());

        let color_glyph = font.color_glyphs().get_with_format(gid, required_format);

        assert!(color_glyph.is_some());

        let result = color_glyph
            .unwrap()
            .paint(location.coords(), &mut color_painter);

        assert!(result.is_ok());

        color_painter
    });

    if should_rebaseline() {
        let mut file = OpenOptions::new()
            .write(true)
            .create(true)
            .truncate(true)
            .open(dumpfile_path)
            .unwrap();

        paint_dumps_iter.for_each(|dump| {
            writeln!(file, "{}", serde_json::to_string(&dump).unwrap())
                .expect("Writing to file failed.")
        });
    } else {
        let expected = fontcull_font_test_data::colrv1_json::expected(set_name, settings);
        let mut lines = io::BufReader::new(expected.as_bytes()).lines();
        for dump in paint_dumps_iter {
            match lines.next() {
                Some(line) => {
                    assert!(
                        dump == serde_json::from_str(
                            line.as_ref().expect("Failed to read expectations line from file.")
                        )
                        .expect("Failed to parse expectations line."),
                        "Result did not match expectation for glyph id: {}\nActual: {}\nExpected: {}\n",
                        dump.glyph_id, serde_json::to_string(&dump).unwrap(), &line.unwrap()
                    )
                }
                None => panic!("Expectation not found for glyph id: {}", dump.glyph_id),
            }
        }
    }
}

macro_rules! colrv1_traversal_tests {
        ($($test_name:ident: $glyph_set:ident, $settings:expr,)*) => {
        $(
            #[test]
            fn $test_name() {
                colrv1_traversal_test(stringify!($glyph_set), $glyph_set, $settings, crate::color::ColorGlyphFormat::ColrV1);
            }
        )*
    }
}

colrv1_traversal_tests!(
clipbox_default:CLIPBOX,&[],
clipbox_var_1:CLIPBOX, &[("CLIO", 200.0)],
comp_mode_default:COMPOSITE_MODE,&[],
extend_mode_default:EXTEND_MODE,&[],
extend_mode_var1:EXTEND_MODE,&[("COL1", -0.25), ("COL3", 0.25)],
extend_mode_var2:EXTEND_MODE,&[("COL1", 0.5), ("COL3", -0.5)],
extend_mode_var3:EXTEND_MODE,&[("COL3", 0.5)],
extend_mode_var4:EXTEND_MODE,&[("COL3", 1.0)],
extend_mode_var5:EXTEND_MODE,&[("COL1", -1.5)],
extend_mode_var6:EXTEND_MODE,&[("GRR0", -200.0), ("GRR1", -300.0)],
extend_mode_var7:EXTEND_MODE,&[("GRX0", -1000.0), ("GRX1", -1000.0), ("GRR0", -1000.0), ("GRR1", -900.0)],
extend_mode_var8:EXTEND_MODE,&[("GRX0", 1000.0), ("GRX1", -1000.0), ("GRR0", -1000.0), ("GRR1", 200.0)],
extend_mode_var9:EXTEND_MODE,&[("GRR0", -50.0), ("COL3", -2.0), ("COL2", -2.0), ("COL1", -0.9)],
extend_mode_var10:EXTEND_MODE,&[("GRR0", -50.0), ("COL3", -2.0), ("COL2", -2.0), ("COL1", -1.1)],
extend_mode_var11:EXTEND_MODE,&[("COL3", 1.0), ("COL2", 1.5), ("COL1", 2.0)],
extend_mode_var12:EXTEND_MODE,&[("COL2", -0.3)],
extend_mode_var13:EXTEND_MODE,&[("GRR0", 430.0), ("GRR1", 40.0)],
foreground_color_default:FOREGROUND_COLOR,&[],
gradient_skewed:GRADIENT_P2_SKEWED,&[],
gradient_stops_repeat:GRADIENT_STOPS_REPEAT,&[],
paint_rotate_default:PAINT_ROTATE,&[],
paint_rotate_var1:PAINT_ROTATE,&[("ROTA", 40.0)],
paint_rotate_var2:PAINT_ROTATE,&[("ROTX", -250.0), ("ROTY", -250.0)],
paint_scale_default:PAINT_SCALE,&[],
paint_scale_var1:PAINT_SCALE,&[("SCOX", 200.0), ("SCOY", 200.0)],
paint_scale_var2:PAINT_SCALE,&[("SCSX", 0.25), ("SCOY", 0.25)],
paint_scale_var3:PAINT_SCALE,&[("SCSX", -1.0), ("SCOY", -1.0)],
paint_skew_default:PAINT_SKEW,&[],
paint_skew_var1:PAINT_SKEW,&[("SKXA", 20.0)],
paint_skew_var2:PAINT_SKEW,&[("SKYA", 20.0)],
paint_skew_var3:PAINT_SKEW,&[("SKCX", 200.0),("SKCY", 200.0)],
paint_transform_default:PAINT_TRANSFORM,&[],
paint_translate_default:PAINT_TRANSLATE,&[],
paint_translate_var_1:PAINT_TRANSLATE,&[("TLDX", 100.0), ("TLDY", 100.0)],
paint_sweep_default:SWEEP_VARSWEEP,&[],
paint_sweep_var1:SWEEP_VARSWEEP,&[("SWPS", 0.0)],
paint_sweep_var2:SWEEP_VARSWEEP,&[("SWPS", 90.0)],
paint_sweep_var3:SWEEP_VARSWEEP,&[("SWPE", -90.0)],
paint_sweep_var4:SWEEP_VARSWEEP,&[("SWPE", -45.0)],
paint_sweep_var5:SWEEP_VARSWEEP,&[("SWPS", -45.0),("SWPE", 45.0)],
paint_sweep_var6:SWEEP_VARSWEEP,&[("SWC1", -0.25), ("SWC2", 0.083333333), ("SWC3", 0.083333333), ("SWC4", 0.25)],
paint_sweep_var7:SWEEP_VARSWEEP,&[("SWPS", 45.0), ("SWPE", -45.0), ("SWC1", -0.25), ("SWC2", -0.416687), ("SWC3", -0.583313), ("SWC4", -0.75)],
variable_alpha_default:VARIABLE_ALPHA,&[],
variable_alpha_var1:VARIABLE_ALPHA,&[("APH1", -0.7)],
variable_alpha_var2:VARIABLE_ALPHA,&[("APH2", -0.7), ("APH3", -0.2)],
nocycle_multi_colrglyph:NO_CYCLE_MULTI_COLRGLYPH,&[],
sweep_coincident:SWEEP_COINCIDENT,&[],
paint_glyph_nested:PAINT_GLYPH_NESTED,&[],
);

macro_rules! colrv0_traversal_tests {
    ($($test_name:ident: $glyph_set:ident,)*) => {
    $(
        #[test]
        fn $test_name() {
            colrv1_traversal_test(stringify!($glyph_set), $glyph_set, &[], crate::color::ColorGlyphFormat::ColrV0);
        }
    )*
}
}

colrv0_traversal_tests!(
    colored_circles:COLORED_CIRCLES_V0,
);