oxivgl 0.1.2

use crate::common::{ensure_init, fresh_screen, pump};

use oxivgl::draw::{DrawArcDsc, DrawImageDsc, DrawLabelDscOwned, DrawLetterDsc, DrawLineDsc, DrawTriangleDsc};
use oxivgl::draw_buf::{ColorFormat, DrawBuf};
use oxivgl::snapshot::Snapshot;
use oxivgl::style::{color_make, GradDir};
use oxivgl::widgets::{Canvas, Chart, Image, Keyboard, Obj};

// ── Snapshot ─────────────────────────────────────────────────────────────────

#[test]
fn snapshot_take_returns_some() {
    use oxivgl::widgets::Label;
    let screen = fresh_screen();
    let _label = Label::new(&screen).unwrap();
    pump();
    let driver = crate::common::driver();
    let snap = oxivgl::snapshot::Snapshot::take(driver);
    assert!(snap.is_some(), "Snapshot::take should succeed after init");
    let snap = snap.unwrap();
    assert_eq!(snap.width(), 320);
    assert_eq!(snap.height(), 240);
    assert!(!snap.data().is_empty());
}

#[cfg(feature = "png")]
#[test]
fn snapshot_write_png() {
    use oxivgl::widgets::Label;
    let screen = fresh_screen();
    let label = Label::new(&screen).unwrap();
    label.text("PNG test");
    pump();
    let driver = crate::common::driver();
    let snap = oxivgl::snapshot::Snapshot::take(driver).unwrap();

    let dir = std::env::temp_dir().join("oxivgl-test");
    std::fs::create_dir_all(&dir).unwrap();
    let path = dir.join("snapshot_test.png");
    snap.write_png(&path).unwrap();
    assert!(path.exists(), "PNG file should be written");
    assert!(std::fs::metadata(&path).unwrap().len() > 0);
    let _ = std::fs::remove_file(&path);
}

// ── draw::Area ──────────────────────────────────────────────────────────────

#[test]
fn draw_area_width_height() {
    use oxivgl::draw::Area;
    let a = Area {
        x1: 10,
        y1: 20,
        x2: 109,
        y2: 69,
    };
    assert_eq!(a.width(), 100);
    assert_eq!(a.height(), 50);
}

#[test]
fn draw_area_set_width_centered() {
    use oxivgl::draw::Area;
    let mut a = Area {
        x1: 50,
        y1: 0,
        x2: 149,
        y2: 9,
    };
    assert_eq!(a.width(), 100);
    a.set_width_centered(120);
    assert_eq!(a.width(), 120);
    // Center should be roughly preserved
    let old_center = 50 + 149; // 199
    let new_center = a.x1 + a.x2;
    assert!((new_center - old_center).abs() <= 1);
}

#[test]
fn area_align_to_area() {
    use oxivgl::draw::Area;
    use oxivgl::widgets::Align;
    let base = Area { x1: 0, y1: 0, x2: 99, y2: 19 };
    let mut txt = Area { x1: 0, y1: 0, x2: 29, y2: 9 };
    txt.align_to_area(base, Align::RightMid, -10, 0);
    // RightMid aligns txt's right edge to base's right edge, then adds ofs_x.
    // Expected: txt.x2 = base.x2 + ofs_x = 99 + (-10) = 89
    assert_eq!(txt.x2, 89);
}

#[test]
fn area_set_width() {
    use oxivgl::draw::Area;
    let mut a = Area { x1: 10, y1: 0, x2: 29, y2: 9 };
    a.set_width(5);
    assert_eq!(a.x2, 14); // x1=10, new x2 = 10+5-1 = 14
    assert_eq!(a.x1, 10); // x1 unchanged
}

// ── math: trigo_cos, trigo_sin ──────────────────────────────────────────────

#[test]
fn math_trigo_cos_sin() {
    use oxivgl::math::{trigo_cos, trigo_sin};
    // cos(0) should be ~1.0, sin(0) should be ~0
    let cos0 = trigo_cos(0);
    let sin0 = trigo_sin(0);
    assert!(cos0 > 0, "cos(0) should be positive");
    assert!(sin0.abs() < 100, "sin(0) should be near zero");
    // cos(90) should be ~0, sin(90) should be ~1.0
    let cos90 = trigo_cos(90);
    let sin90 = trigo_sin(90);
    assert!(cos90.abs() < 100, "cos(90) should be near zero");
    assert!(sin90 > 0, "sin(90) should be positive");
}

// ── math::bezier3, map ────────────────────────────────────────────────────────

#[test]
fn math_map_basic() {
    use oxivgl::math;
    // map(500, 0, 1000, 0, 100) == 50
    assert_eq!(math::map(500, 0, 1000, 0, 100), 50);
    // map at boundaries
    assert_eq!(math::map(0, 0, 1000, 0, 100), 0);
    assert_eq!(math::map(1000, 0, 1000, 0, 100), 100);
}

#[test]
fn math_bezier3_endpoints() {
    use oxivgl::math;
    // t=0 → result should be near u0=0
    let v0 = math::bezier3(0, 0, 256, 768, 1024);
    assert_eq!(v0, 0);
    // t=1024 → result should be near u3=1024
    let v1024 = math::bezier3(1024, 0, 256, 768, 1024);
    assert_eq!(v1024, 1024);
}

// ── Draw layer types ──────────────────────────────────────────────────────────

#[test]
fn draw_rect_dsc_new() {
    use oxivgl::draw::{DrawRectDsc, DrawLabelDscOwned, RADIUS_CIRCLE};
    use oxivgl::style::color_make;
    let mut dsc = DrawRectDsc::new();
    dsc.bg_color(color_make(255, 170, 170))
        .radius(RADIUS_CIRCLE)
        .border_color(color_make(255, 85, 85))
        .border_width(2)
        .outline_color(color_make(255, 0, 0))
        .outline_width(2)
        .outline_pad(3);
    // Verify the label descriptor initialises a usable font (text_size > 0).
    let label_dsc = DrawLabelDscOwned::default_font();
    let (w, h) = label_dsc.text_size("X");
    assert!(w > 0, "label dsc font width > 0");
    assert!(h > 0, "label dsc font height > 0");
    // dsc construction must not panic (inner fields not pub — smoke-test only).
    let _ = dsc;
}

#[test]
fn draw_label_dsc_owned_text_size() {
    let screen = fresh_screen();
    let dsc = oxivgl::draw::DrawLabelDscOwned::default_font();
    let (w, h) = dsc.text_size("Hello");
    assert!(w > 0, "text width should be > 0");
    assert!(h > 0, "text height should be > 0");
    let _ = screen;
}

// ── draw::DrawLabelDscOwned::set_color ────────────────────────────────────────

#[test]
fn draw_label_dsc_owned_set_color() {
    use oxivgl::draw::DrawLabelDscOwned;
    use oxivgl::style::color_make;
    let _screen = fresh_screen();
    let mut dsc = DrawLabelDscOwned::default_font();
    dsc.set_color(color_make(255, 0, 0));
    let _ = dsc;
}

// ── Draw descriptors ─────────────────────────────────────────────────────────

#[test]
fn draw_arc_dsc_builder() {
    ensure_init();
    let mut dsc = DrawArcDsc::new();
    dsc.center(50, 50).radius(20).angles(0.0, 270.0).width(4).color(color_make(255, 0, 0)).opa(200).rounded(true);
}

#[test]
fn draw_line_dsc_builder() {
    ensure_init();
    let mut dsc = DrawLineDsc::new();
    dsc.p1(10.0, 10.0).p2(90.0, 90.0).width(3).color(color_make(0, 255, 0)).opa(255).round_start(true).round_end(true);
}

#[test]
fn draw_triangle_dsc_builder() {
    ensure_init();
    let mut dsc = DrawTriangleDsc::new();
    dsc.points([(10.0, 10.0), (50.0, 80.0), (90.0, 10.0)])
        .color(color_make(0, 0, 255))
        .opa(128)
        .grad_stops_count(2)
        .grad_dir(GradDir::Ver)
        .grad_stop(0, color_make(255, 0, 0), 0, 255)
        .grad_stop(1, color_make(0, 0, 255), 255, 255);
}

#[test]
fn draw_image_dsc_builder() {
    ensure_init();
    if let Some(buf) = DrawBuf::create(10, 10, ColorFormat::RGB565) {
        let img = buf.image_dsc();
        let mut dsc = DrawImageDsc::from_image_dsc(&img);
        dsc.rotation(450).pivot(5, 5).opa(200);
    }
}

#[test]
fn draw_letter_dsc_builder() {
    ensure_init();
    let mut dsc = DrawLetterDsc::new();
    dsc.unicode(b'A' as u32).color(color_make(255, 255, 0)).rotation(0);
}

#[test]
fn draw_label_dsc_owned_color() {
    ensure_init();
    let mut dsc = DrawLabelDscOwned::default_font();
    dsc.set_color(color_make(128, 0, 0));
    let (w, h) = dsc.text_size("Test");
    assert!(w > 0);
    assert!(h > 0);
}

#[test]
fn draw_label_dsc_set_opa_compiles() {
    // Verify set_opa / opa exist on DrawLabelDsc (compile-time check).
    let screen = crate::common::fresh_screen();
    let _kb = Keyboard::new(&screen).unwrap();
    pump();
}

#[test]
fn draw_task_with_fill_dsc_closure_compiles() {
    // Verify with_fill_dsc / with_label_dsc exist and compile.
    // Actual draw task closure testing requires a render cycle.
    let screen = crate::common::fresh_screen();
    let chart = Chart::new(&screen).unwrap();
    chart.send_draw_task_events();
    pump();
}

// ── DrawLetterDsc::font ─────────────────────────────────────────────────────

#[test]
fn draw_letter_dsc_font_setter() {
    use oxivgl::draw::DrawLetterDsc;
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    use oxivgl::fonts;
    use oxivgl::style::color_make;
    let screen = fresh_screen();
    let buf = DrawBuf::create(100, 100, ColorFormat::RGB565).expect("DrawBuf alloc");
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.fill_bg(color_make(0, 0, 0), 255);
    {
        let mut layer = canvas.init_layer();
        let mut dsc = DrawLetterDsc::new();
        dsc.unicode(b'A' as u32)
            .font(fonts::MONTSERRAT_20)
            .color(color_make(255, 255, 255))
            .rotation(0);
        layer.draw_letter(&dsc, 10, 10);
    }
    pump();
}

// ── Canvas ────────────────────────────────────────────────────────────────────

#[test]
fn canvas_create_and_fill() {
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let screen = fresh_screen();
    let buf = DrawBuf::create(50, 50, ColorFormat::RGB565).unwrap();
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.fill_bg(color_make(255, 0, 0), 255).size(50, 50).center();
    pump();
}

#[test]
fn canvas_set_px_and_get() {
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let screen = fresh_screen();
    let buf = DrawBuf::create(10, 10, ColorFormat::ARGB8888).unwrap();
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.fill_bg(color_make(0, 0, 0), 255);
    canvas.set_px(5, 5, color_make(255, 255, 255), 255);
    // We set a white pixel; verify the canvas accepted the call without panic.
    // (Exact pixel read-back depends on color format internals.)
    pump();
}

#[test]
fn canvas_layer_draw_rect() {
    use oxivgl::draw::{Area, DrawRectDsc};
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let screen = fresh_screen();
    let buf = DrawBuf::create(100, 100, ColorFormat::ARGB8888).unwrap();
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.fill_bg(color_make(200, 200, 200), 255);
    {
        let mut layer = canvas.init_layer();
        let mut dsc = DrawRectDsc::new();
        dsc.bg_color(color_make(255, 0, 0)).radius(5);
        layer.draw_rect(&dsc, Area { x1: 10, y1: 10, x2: 50, y2: 50 });
    }
    pump();
}

#[test]
fn drawbuf_create_returns_some() {
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let buf = DrawBuf::create(100, 100, ColorFormat::RGB565);
    assert!(buf.is_some());
}

#[test]
fn canvas_draw_buf_accessor() {
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let screen = fresh_screen();
    let buf = DrawBuf::create(40, 40, ColorFormat::RGB565).unwrap();
    let canvas = Canvas::new(&screen, buf).unwrap();
    // draw_buf() returns &DrawBuf — just verify we can call image_dsc() on it.
    let _img = canvas.draw_buf().image_dsc();
}

#[test]
fn canvas_layer_draw_label() {
    use oxivgl::draw::{Area, DrawLabelDscOwned};
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let screen = fresh_screen();
    let buf = DrawBuf::create(80, 30, ColorFormat::RGB565).unwrap();
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.fill_bg(color_make(200, 200, 200), 255);
    {
        let mut layer = canvas.init_layer();
        let mut dsc = DrawLabelDscOwned::default_font();
        dsc.set_color(color_make(255, 0, 0));
        layer.draw_label(&dsc, Area { x1: 5, y1: 5, x2: 75, y2: 25 }, "Test");
    }
}

#[test]
fn canvas_layer_draw_letter() {
    use oxivgl::draw::DrawLetterDsc;
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    let screen = fresh_screen();
    let buf = DrawBuf::create(40, 40, ColorFormat::RGB565).unwrap();
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.fill_bg(color_make(200, 200, 200), 255);
    {
        let mut layer = canvas.init_layer();
        let mut dsc = DrawLetterDsc::new();
        dsc.unicode(b'A' as u32)
            .color(color_make(0, 0, 255))
            .rotation(0);
        layer.draw_letter(&dsc, 10, 20);
    }
}

// ── Canvas — draw image from static asset ───────────────────────────────────

#[test]
fn canvas_layer_draw_image_static() {
    use oxivgl::draw::DrawImageDsc;
    use oxivgl::draw_buf::{ColorFormat, DrawBuf};
    oxivgl::image_declare!(img_cogwheel_argb);
    let screen = fresh_screen();
    let buf = DrawBuf::create(100, 100, ColorFormat::ARGB8888).expect("DrawBuf alloc");
    let canvas = Canvas::new(&screen, buf).unwrap();
    canvas.center();
    let mut layer = canvas.init_layer();
    let mut dsc = DrawImageDsc::from_static_dsc(img_cogwheel_argb());
    dsc.opa(255);
    layer.draw_image(&dsc, oxivgl::draw::Area { x1: 0, y1: 0, x2: 99, y2: 99 });
    drop(layer);
    pump();
}

// ── Snapshot (widget) ────────────────────────────────────────────────────────

#[test]
fn snapshot_take_widget() {
    let screen = fresh_screen();
    let obj = Obj::new(&screen).unwrap();
    obj.size(100, 100).center().bg_color(0xff0000).bg_opa(255);
    pump();
    let snap = Snapshot::take_widget(&obj).expect("snapshot allocation");
    assert!(snap.width() > 0);
    assert!(snap.height() > 0);
}

#[test]
fn image_set_src_snapshot() {
    let screen = fresh_screen();
    let obj = Obj::new(&screen).unwrap();
    obj.size(100, 100).center().bg_color(0xff0000).bg_opa(255);
    pump();
    let snap = Snapshot::take_widget(&obj).expect("snapshot allocation");
    let img = Image::new(&screen).unwrap();
    img.set_src_snapshot(&snap);
    pump();
    // Verify image source dimensions match snapshot
    assert!(img.get_src_width() > 0);
}

#[test]
fn snapshot_take_widget_empty_obj() {
    let screen = fresh_screen();
    let obj = Obj::new(&screen).unwrap();
    // Don't set size — LVGL may return zero-sized snapshot or None
    pump();
    // Either works — we just verify no crash
    let _snap = Snapshot::take_widget(&obj);
}