//! Pattern editing mode: the tile edge in the Tile Edge Color, and Show Swatch Bounds.

use super::*;
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::pattern::{PatternDef, PatternEdit, TileType};
use vectorcraft_doc::{Appearance, Node};
use vectorcraft_geom::shapes;

/// A document editing a 20×20 pattern tile of type `tt` (a red 10×10 square in its corner, no
/// preview copies), its tile edge and swatch bounds shown as asked.
fn editing(tt: TileType, edge: bool, bounds: bool) -> Document {
    let mut d = Document::new(200.0, 200.0);
    let id = d.alloc_id();
    let red = Node::path(
        id,
        shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)),
        Appearance::basic(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::None, 0.0),
    );
    let mut def = PatternDef::new("Checks", vec![Arc::new(red.clone())]);
    def.tile = Rect::new(0.0, 0.0, 20.0, 20.0);
    (def.tile_type, def.copies, def.show_tile_edge, def.show_swatch_bounds) = (tt, 1, edge, bounds);
    d.patterns.push(def);
    let layer = d.add_layer(Some("Pattern Editing Mode"));
    d.insert(Some(layer), 0, red).unwrap();
    d.pattern_edit = Some(PatternEdit { pattern: "Checks".into(), layer, original: None });
    d
}

/// `d` at 1:1 with the tile's corner at the centre of pixel (50, 50), on white.
fn render(d: &Document, tile_edge: Option<[u8; 3]>) -> Rendered {
    let opts = RenderOptions { background: Some([255; 4]), tile_edge: tile_edge.unwrap_or(RenderOptions::default().tile_edge), ..Default::default() };
    Renderer::new().render(d, 120, 120, Affine::translate((50.5, 50.5)), &opts)
}

fn is_white(p: [u8; 4]) -> bool {
    p[0] > 245 && p[1] > 245 && p[2] > 245
}

#[test]
fn the_tile_edge_takes_the_tile_edge_color() {
    let green = render(&editing(TileType::Grid, true, false), Some([0, 200, 0]));
    // The left edge below the red square, and the bottom edge.
    for (x, y) in [(50, 65), (60, 70), (70, 55)] {
        let p = green.pixel(x, y);
        assert!(p[1] > 150 && p[0] < 100 && p[2] < 100, "({x},{y}) {p:?}");
    }
    assert!(is_white(green.pixel(65, 65)), "inside the tile");
    // The default is the first layer colour (light blue).
    let [r, g, b] = RenderOptions::default().tile_edge;
    let p = render(&editing(TileType::Grid, true, false), None).pixel(50, 65);
    assert!(p[0].abs_diff(r) < 30 && p[1].abs_diff(g) < 30 && p[2].abs_diff(b) < 30, "{p:?}");
    // Hidden: nothing there.
    assert!(is_white(render(&editing(TileType::Grid, false, false), Some([0, 200, 0])).pixel(50, 65)));
}

#[test]
fn swatch_bounds_outline_the_period_dashed() {
    // Brick by row repeats every two rows: the swatch is 20×40 from the tile's corner.
    let tt = TileType::BrickByRow { offset: 0.5 };
    let on = render(&editing(tt, false, true), Some([0, 200, 0]));
    let green = |p: [u8; 4]| p[1] > 150 && p[0] < 100 && p[2] < 100;
    let bottom: Vec<bool> = (51..70).map(|x| green(on.pixel(x, 90))).collect();
    assert!(bottom.iter().any(|g| *g) && bottom.iter().any(|g| !*g), "dashed: {bottom:?}");
    assert!((51..90).any(|y| green(on.pixel(70, y))), "right side");
    assert!(!(51..70).any(|x| green(on.pixel(x, 70))), "the tile edge itself stays hidden");
    // Off: no outline.
    let off = render(&editing(tt, false, false), Some([0, 200, 0]));
    assert!((51..70).all(|x| is_white(off.pixel(x, 90))));
}