use hcie_brush_engine::{BrushStyle, BrushTip};

fn make_round_tip(size: f32, hardness: f32) -> BrushTip {
    BrushTip {
        style: BrushStyle::Round,
        size,
        hardness,
        ..BrushTip::default()
    }
}

#[test]
fn test_generate_brush_stamp_size() {
    let tip = make_round_tip(10.0, 0.5);
    let stamp = hcie_brush_engine::generate_brush_stamp(&tip);
    let expected_d = 20usize;
    assert_eq!(
        stamp.len(),
        expected_d * expected_d,
        "stamp should be square"
    );
}

#[test]
fn test_generate_brush_stamp_center_nonzero() {
    let tip = make_round_tip(10.0, 1.0);
    let stamp = hcie_brush_engine::generate_brush_stamp(&tip);
    let d = 20usize;
    let center = d / 2;
    assert!(stamp[center * d + center] > 0, "center should be opaque");
}

#[test]
fn test_generate_brush_stamp_hardness_gradient() {
    let soft = hcie_brush_engine::generate_brush_stamp(&make_round_tip(10.0, 0.0));
    let hard = hcie_brush_engine::generate_brush_stamp(&make_round_tip(10.0, 1.0));
    assert_eq!(
        soft.len(),
        hard.len(),
        "same size stamp should have same length"
    );
}

#[test]
fn test_brush_spacing_pixels() {
    let spacing = hcie_brush_engine::brush_spacing_pixels(20.0, 0.5);
    assert_eq!(spacing, 10.0, "spacing should be size * ratio");
    let min_spacing = hcie_brush_engine::brush_spacing_pixels(20.0, 0.0);
    assert!(
        (min_spacing - 0.2).abs() < 0.001,
        "min spacing should be ~0.2, got {}",
        min_spacing
    );
}

#[test]
fn test_jitter_offset_within_bounds() {
    let (jx, jy) = hcie_brush_engine::jitter_offset(0.0, 10.0);
    assert_eq!(jx, 0.0, "no jitter");
    assert_eq!(jy, 0.0, "no jitter");
}

#[test]
fn test_bitmap_stamp_fallback_to_round() {
    let tip = BrushTip {
        style: BrushStyle::Bitmap,
        size: 10.0,
        bitmap_pixels: vec![],
        bitmap_w: 0,
        bitmap_h: 0,
        ..BrushTip::default()
    };
    let stamp = hcie_brush_engine::generate_brush_stamp(&tip);
    assert!(!stamp.is_empty(), "empty bitmap should fallback to round");
}