//! Step 2 check: box existence over the enumerated corpus (`handoff.md` -> "Step 2").
//! Exit: box existence matches on the whole corpus, `display: none` subtrees included.
//!
//! `--random` additionally runs the seeded random corpus (`harness::cases::random`,
//! `crates/harness/src/cases.rs`) through the same comparison, at the seed and count
//! `crosscheck.rs` already measures the browsers against each other with (`--seed`,
//! `--count` override either). The random corpus is not part of step 2's exit gate by
//! declaration, but its mismatches still fail this binary's exit code, so a real
//! disagreement cannot pass silently.

use std::path::PathBuf;

use anyhow::{bail, Context, Result};
use dom::Document;
use harness::cases;
use harness::oracle::Oracle;
use layout::boxtree::BoxTree;

/// Seed and count `crosscheck.rs` already established for the held-out random corpus
/// (`crates/harness/src/bin/crosscheck.rs`), reused here as the default so a bare
/// `--random` measures the same set other tools report against.
const DEFAULT_RANDOM_SEED: u64 = 0xC0FFEE;
const DEFAULT_RANDOM_COUNT: usize = 200;

struct Args {
    include_random: bool,
    include_smt: bool,
    seed: u64,
    count: usize,
}

fn parse_args() -> Result<Args> {
    let mut include_random = false;
    let mut include_smt = false;
    let mut seed = DEFAULT_RANDOM_SEED;
    let mut count = DEFAULT_RANDOM_COUNT;
    let mut args = std::env::args().skip(1);
    while let Some(arg) = args.next() {
        match arg.as_str() {
            "--random" => include_random = true,
            "--smt" => include_smt = true,
            "--seed" => seed = args.next().context("--seed needs a value")?.parse()?,
            "--count" => count = args.next().context("--count needs a value")?.parse()?,
            other => bail!("unknown argument: {other}"),
        }
    }
    Ok(Args { include_random, include_smt, seed, count })
}

fn main() -> Result<()> {
    let repo_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .parent()
        .and_then(|p| p.parent())
        .expect("crate sits two levels below the repository root")
        .to_path_buf();

    let args = parse_args()?;
    let mut oracle = Oracle::start(&repo_root, None, None)?;
    println!("engines: {}", oracle.engines.join(", "));

    let mut cases = cases::enumerated();
    if args.include_random {
        println!("random corpus: seed=0x{:x} count={}", args.seed, args.count);
        cases.extend(cases::random(args.seed, args.count));
    }
    if args.include_smt {
        #[cfg(feature = "smt")]
        {
            let smt_cases = harness::smt::sampled_cases(0xC0FFEE, 20);
            println!("SMT-sampled corpus: {} cases", smt_cases.len());
            cases.extend(smt_cases);
        }
        #[cfg(not(feature = "smt"))]
        bail!("--smt requires building with --features smt");
    }
    let mut total = 0usize;
    let mut mismatches = 0usize;
    let mut shape_mismatches = 0usize;

    for case in &cases {
        let (browser_dumps, errors) = oracle.dump(&case.html)?;
        for (engine, msg) in &errors {
            eprintln!("{}: {engine} failed: {msg}", case.id);
        }
        let Some(reference) = browser_dumps.get("chromium").or_else(|| browser_dumps.values().next()) else {
            eprintln!("{}: no browser dump available, skipping", case.id);
            continue;
        };

        let document = Document::parse(&case.html);
        let tree = BoxTree::build(&document);
        let elements = document.elements_in_document_order();

        if elements.len() != reference.nodes.len() {
            shape_mismatches += 1;
            println!(
                "{:<34} shape mismatch: engine has {} node(s), {} has {}",
                case.id,
                elements.len(),
                reference.engine,
                reference.nodes.len()
            );
            continue;
        }

        for (&el, browser_node) in elements.iter().zip(reference.nodes.iter()) {
            let engine_tag = el.tag();
            if engine_tag != browser_node.tag {
                shape_mismatches += 1;
                println!(
                    "{:<34} node {} shape mismatch: engine tag={engine_tag} {} tag={}",
                    case.id, browser_node.index, reference.engine, browser_node.tag
                );
                break;
            }

            total += 1;
            let engine_has_box = tree.has_box_for(el);
            let browser_has_box = !browser_node.rects.is_empty();
            if engine_has_box != browser_has_box {
                mismatches += 1;
                println!(
                    "{:<34} node {} ({engine_tag}) box existence: engine={engine_has_box} {}={browser_has_box}",
                    case.id, browser_node.index, reference.engine
                );
            }
        }
    }

    println!("\n== summary ==");
    println!("{}/{} node(s) matched on box existence", total - mismatches, total);
    println!("{shape_mismatches} shape mismatch(es)");

    oracle.shutdown()?;

    if mismatches > 0 || shape_mismatches > 0 {
        bail!("step 2 exit criterion not met: {mismatches} box-existence mismatch(es), {shape_mismatches} shape mismatch(es)");
    }
    Ok(())
}