#[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 {
                    let bound = &mut rules[axis].bound;
                    if bound.min.is_some() {
                        bound.min = Some(Len::rel(0.25));
                    }
                    if bound.max.is_some() {
                        bound.max = Some(Len::rel(0.75));
                    }
                }
            }
        });
    });
}

#[test]
fn preferred_requests_with_independent_bounds_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].request = Some(match index % 4 {
                        0 => leftover(1).into(),
                        1 => rel(0.5).into(),
                        2 => px(80).into(),
                        _ => (leftover(1) + px(30)).min(leftover(2)),
                    });
                }
            }
        });
    });
}