//! CPU comparison of a bounds attribute against the `MaxSize` wrapper it
//! replaced, using the same builder calls and the same geometry. The wrapper
//! is gone from this tree, so its side of the comparison is run by checking
//! out a commit that still has it: the fixture is written to build the same
//! way at both.
//!
//!     MODE=cap FRAMES=2000 cargo test --release --test bounds_cost \
//!       -- --ignored --nocapture
//!
//! `MODE` is `plain`, `exact` or `cap`; `REDRAW=1` marks every widget for
//! redraw each frame; `FRAMES` is how many resize frames to measure. Use
//! repeated `perf stat -e instructions:u` runs on the executable directly.
//! Process totals include the cold frame, so compare identical modes and
//! frame counts. Wall time on this machine is not a stable comparison.

mod rig;

use iris::{harness::Harness, prelude::*};
use rig::env;

/// The two widths the loop alternates. The cap of 80 binds at 300 and does
/// not at 100, so the measured frames cross it in both directions.
const WIDTHS: [i32; 2] = [100, 300];

#[test]
#[ignore = "instruction-count measurement"]
fn bounds_cost() {
    let mode = env("MODE", "cap".to_string());
    let redraw = env("REDRAW", 0_u8) != 0;
    let frames = env("FRAMES", 2000_usize);
    let mut h = Harness::new((300, 512));
    let mut column = Span::empty(Dir::DOWN);
    let mut leaves = Vec::new();
    for _ in 0..128 {
        let first = match mode.as_str() {
            "plain" => rect(Color::RED).add_strong(&mut h.rsc).any(),
            "exact" => rect(Color::RED).width(40).add_strong(&mut h.rsc).any(),
            "cap" => rect(Color::RED).max_width(80).add_strong(&mut h.rsc).any(),
            _ => panic!("unknown MODE {mode}"),
        };
        leaves.push(first.id());
        let second = rect(Color::BLUE).add_strong(&mut h.rsc);
        let row = Span {
            children: vec![first, second],
            dir: Dir::RIGHT,
            gap: Px::ZERO,
        };
        column.push(row.height(4).add_strong(&mut h.rsc));
    }
    h.set_root(column);
    let ids: Vec<_> = h.render.active.keys().copied().collect();
    println!(
        "mode={mode}, widgets={}, rule_bytes={}",
        ids.len(),
        std::mem::size_of::<SizeRule>()
    );
    // That the fixture measures what it says is checked on both sides of the
    // crossing here rather than inside the measured loop, which is what the
    // other rigs do. Per frame it measured only 0.65% of the total (5.780B
    // against 5.743B instructions at MODE=cap, FRAMES=2000), but none of it
    // is the layout the number is about.
    for width in WIDTHS {
        h.resize((width, 512));
        h.frame();
        let expected = match mode.as_str() {
            "plain" => width / 2,
            "exact" => 40,
            "cap" => (width / 2).min(80),
            _ => unreachable!("the mode was checked while building"),
        };
        for id in &leaves {
            assert_eq!(h.region(id).unwrap().size().x, Px::from_int(expected));
        }
        println!(
            "width {width}: first leaf {}",
            h.region(&leaves[0]).unwrap()
        );
    }
    for frame in 0..frames {
        if redraw {
            for &id in &ids {
                h.rsc.widgets_mut().mark_for_redraw(id);
            }
        }
        h.resize((WIDTHS[frame % WIDTHS.len()], 512));
        h.frame();
    }
}