#[path = "scenario/mod.rs"]
mod scenario;

use iris::prelude::*;
use iris::random::{Edits, Plan, plan};

fn check_requests(edit: impl Fn(&mut Plan) + Sync) {
    let count = scenario::env("IRIS_DEFERRED_SEEDS", 20_u64);
    let depth = scenario::env("IRIS_DEFERRED_DEPTH", 4_usize);
    let seeds = std::env::var("IRIS_DEFERRED_SEED")
        .ok()
        .and_then(|seed| seed.parse().ok())
        .map_or_else(|| (1..=count).collect(), |seed| vec![seed]);
    scenario::over_seeds(seeds, |seed| {
        let mut grown = plan(seed, depth, &Edits::default());
        edit(&mut grown);
        for case in scenario::ALL {
            if let Some(how) = scenario::diverges(&grown, case, seed) {
                panic!(
                    "request seed {seed} depth {depth} after {}: {how}",
                    case.name()
                );
            }
        }
    });
}

#[test]
fn deferred_requests_agree_warm_and_cold() {
    check_requests(|grown| {
        let mut index = 0;
        grown.walk_mut(&mut |node| {
            if let Some(rules) = &mut node.size {
                for axis in Axis::BOTH {
                    index += 1;
                    rules[axis] = match index % 7 {
                        0 => leftover(1).clamp(20, 120).into(),
                        1 => leftover(1).min(rel(0.5)).into(),
                        2 => (leftover(1) + px(30)).min(leftover(2)).into(),
                        _ => rules[axis].clone(),
                    };
                }
            }
        });
    });
}

#[test]
fn relative_intrinsic_bounds_agree_warm_and_cold() {
    check_requests(|grown| {
        grown.walk_mut(&mut |node| {
            if let Some(rules) = &mut node.size {
                for axis in Axis::BOTH {
                    rules[axis] = match rules[axis] {
                        SizeRule::Min(_) => SizeRule::Min(Len::rel(0.25)),
                        SizeRule::Max(_) => SizeRule::Max(Len::rel(0.75)),
                        SizeRule::Clamp { .. } => SizeRule::Clamp {
                            min: Len::rel(0.25),
                            max: Len::rel(0.75),
                        },
                        ref rule => rule.clone(),
                    };
                }
            }
        });
    });
}