//! Traces the four-widget trees in `unsettled.rs`, to see what box their text
//! is actually drawn in on a first frame against a settled one.

#![cfg(feature = "layout-diagnostics")]

use iris::core::layout_diagnostics::{self as diag, TraceEvent};
use iris::harness::Harness;
use iris::prelude::*;

fn plant(h: &mut Harness) -> Vec<WidgetId> {
    let plain = wtext("Wrapping").size(16).wrap(false).add(&mut h.rsc);
    let wrapped = wtext("Wrapping shapes")
        .size(16)
        .wrap(true)
        .width(76)
        .add(&mut h.rsc);
    h.rsc
        .widgets_mut()
        .set_alignment(wrapped, Axis::X, AxisAlign::POS);
    h.rsc
        .widgets_mut()
        .set_alignment(wrapped, Axis::Y, AxisAlign::POS);
    let stack = Stack {
        children: vec![plain.add_strong(&mut h.rsc), wrapped.add_strong(&mut h.rsc)],
        size: StackSize::Child(0),
    }
    .add(&mut h.rsc);
    let root = (stack,).span(Dir::RIGHT).add(&mut h.rsc);
    h.state.root = Some(root.add_strong(&mut h.rsc));
    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
}

fn dump(label: &str, report: &diag::Report, text: WidgetId) {
    println!("--- {label} ---");
    for event in report.traces() {
        match event {
            TraceEvent::DrawRequest {
                id,
                region,
                region_px,
                ..
            } if *id == text => {
                println!(
                    "  draw in {:.2}x{:.2}  region {region:?}",
                    region_px.x, region_px.y
                )
            }
            TraceEvent::SizeReported { id, size } if *id == text => {
                println!("  reported {size}")
            }
            TraceEvent::SizeRead { id, reader, size } if *id == text => {
                println!("  size read by {reader:?}: {size}")
            }
            TraceEvent::RegionNode { id, parent, region } if *id == text => {
                println!("  region node under {parent:?} at {region:?}")
            }
            TraceEvent::Reuse { id, outcome } if *id == text => println!("  reuse: {outcome:?}"),
            _ => {}
        }
    }
}

#[test]
#[ignore = "a diagnostic, not a check"]
fn what_box_the_text_is_drawn_in() {
    diag::clear_traced_widgets();
    let _ = diag::take();
    let mut h = Harness::new((640, 900));
    let ids = plant(&mut h);
    let text = ids[1];
    diag::trace_widget(text);
    let _ = diag::take();

    h.frame();
    dump("first frame", &diag::take(), text);

    for _ in 0..2 {
        for &id in &ids {
            h.rsc.widgets_mut().get_dyn_mut(id);
        }
        let _ = diag::take();
        h.frame();
        dump("repaint", &diag::take(), text);
    }
    diag::clear_traced_widgets();
}

fn plant_fixed(h: &mut Harness) -> Vec<WidgetId> {
    let words = "Wrapping shapes one source into as many lines as the box leaves";
    let text = wtext(words).size(16).wrap(true).add(&mut h.rsc);
    h.rsc
        .widgets_mut()
        .set_alignment(text, Axis::X, AxisAlign::NEG);
    let inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
    let filler = rect(Color::RED).add(&mut h.rsc);
    let root = (filler, inner).span(Dir::RIGHT).add(&mut h.rsc);
    h.state.root = Some(root.add_strong(&mut h.rsc));
    vec![text.id(), inner.id(), filler.id(), root.id()]
}

#[test]
#[ignore = "a diagnostic, not a check"]
fn what_box_the_fixed_text_is_drawn_in() {
    diag::clear_traced_widgets();
    let _ = diag::take();
    let mut h = Harness::new((1920, 1200));
    let ids = plant_fixed(&mut h);
    let text = ids[0];
    diag::trace_widget(text);
    let _ = diag::take();

    h.frame();
    dump("first frame at 1920", &diag::take(), text);
    h.resize((640, 900));
    h.frame();
    dump("after resize to 640", &diag::take(), text);

    let mut cold = Harness::new((640, 900));
    let cids = plant_fixed(&mut cold);
    diag::clear_traced_widgets();
    diag::trace_widget(cids[0]);
    let _ = diag::take();
    cold.frame();
    dump("cold at 640", &diag::take(), cids[0]);
    diag::clear_traced_widgets();
}