//! WPT (Web Platform Tests) test harness.
//!
//! Discovers `.html` test files under `tests/wpt/`, parses them, executes
//! inline scripts with a testharness.js shim, and reports pass/fail/skip
//! counts grouped by test directory.
//!
//! Run with: `cargo test -p we-browser --test wpt -- --nocapture`

use std::cell::RefCell;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::rc::Rc;

/// Workspace root relative to the crate directory.
const WORKSPACE_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../");

/// Maximum instructions per test (prevents infinite loops).
const INSTRUCTION_LIMIT: u64 = 2_000_000;

/// Minimal testharness.js shim that implements the WPT test API.
///
/// This provides `test()`, `async_test()`, `promise_test()`, `assert_*()`,
/// and the `Event` constructor needed to run WPT-style HTML tests.
const TESTHARNESS_PREAMBLE: &str = r#"
// --- WPT testharness.js shim ---

// Global results array: each entry is { name, status, message }.
// status: 0 = PASS, 1 = FAIL, 2 = TIMEOUT, 3 = NOTRUN
var __wpt_results__ = [];
var __wpt_test_count__ = 0;

function test(func, name) {
    if (name === undefined) {
        name = "test " + __wpt_test_count__;
    }
    __wpt_test_count__ = __wpt_test_count__ + 1;
    try {
        func();
        __wpt_results__.push({ name: name, status: 0, message: "" });
    } catch (e) {
        var msg = "";
        if (typeof e === "string") {
            msg = e;
        } else if (e && e.message) {
            msg = e.message;
        } else {
            msg = String(e);
        }
        __wpt_results__.push({ name: name, status: 1, message: msg });
    }
}

// Async test support — simplified for synchronous execution model.
function async_test(nameOrFunc, name) {
    if (typeof nameOrFunc === "function") {
        // async_test(func, name) — run immediately
        test(nameOrFunc, name);
        return { step: function(f) { f(); }, done: function() {} };
    }
    // async_test(name) — returns test handle
    var testName = nameOrFunc;
    if (testName === undefined) {
        testName = "async_test " + __wpt_test_count__;
    }
    __wpt_test_count__ = __wpt_test_count__ + 1;
    var completed = false;
    var t = {
        step: function(func) {
            if (completed) { return; }
            try {
                func();
            } catch (e) {
                completed = true;
                var msg = typeof e === "string" ? e : (e && e.message ? e.message : String(e));
                __wpt_results__.push({ name: testName, status: 1, message: msg });
            }
        },
        step_func: function(func) {
            var self = this;
            return function() {
                self.step(func);
            };
        },
        done: function() {
            if (!completed) {
                completed = true;
                __wpt_results__.push({ name: testName, status: 0, message: "" });
            }
        }
    };
    return t;
}

// Promise test support — simplified for synchronous execution model.
function promise_test(func, name) {
    if (name === undefined) {
        name = "promise_test " + __wpt_test_count__;
    }
    __wpt_test_count__ = __wpt_test_count__ + 1;
    try {
        var result = func();
        // If result is a promise, we can't actually await it in sync mode.
        // Mark as pass if no error thrown.
        __wpt_results__.push({ name: name, status: 0, message: "" });
    } catch (e) {
        var msg = typeof e === "string" ? e : (e && e.message ? e.message : String(e));
        __wpt_results__.push({ name: name, status: 1, message: msg });
    }
}

// --- Assertion functions ---

function assert_equals(actual, expected, description) {
    if (actual === expected) { return; }
    // Handle NaN
    if (actual !== actual && expected !== expected) { return; }
    var msg = "assert_equals: ";
    if (description) { msg = description + ": "; }
    msg = msg + "expected " + String(expected) + " but got " + String(actual);
    throw new Error(msg);
}

function assert_not_equals(actual, unexpected, description) {
    if (actual !== unexpected) { return; }
    var msg = "assert_not_equals: ";
    if (description) { msg = description + ": "; }
    msg = msg + "got disallowed value " + String(unexpected);
    throw new Error(msg);
}

function assert_true(actual, description) {
    if (actual === true) { return; }
    var msg = "assert_true: ";
    if (description) { msg = description + ": "; }
    msg = msg + "expected true but got " + String(actual);
    throw new Error(msg);
}

function assert_false(actual, description) {
    if (actual === false) { return; }
    var msg = "assert_false: ";
    if (description) { msg = description + ": "; }
    msg = msg + "expected false but got " + String(actual);
    throw new Error(msg);
}

function assert_throws_js(constructor, func, description) {
    var threw = false;
    try {
        func();
    } catch (e) {
        threw = true;
    }
    if (!threw) {
        var msg = "assert_throws_js: ";
        if (description) { msg = description + ": "; }
        msg = msg + "function did not throw";
        throw new Error(msg);
    }
}

function assert_throws_dom(name, func, description) {
    var threw = false;
    try {
        func();
    } catch (e) {
        threw = true;
    }
    if (!threw) {
        var msg = "assert_throws_dom: ";
        if (description) { msg = description + ": "; }
        msg = msg + "function did not throw";
        throw new Error(msg);
    }
}

function assert_array_equals(actual, expected, description) {
    if (actual.length !== expected.length) {
        var msg = "assert_array_equals: ";
        if (description) { msg = description + ": "; }
        msg = msg + "lengths differ: " + actual.length + " vs " + expected.length;
        throw new Error(msg);
    }
    for (var i = 0; i < actual.length; i = i + 1) {
        if (actual[i] !== expected[i]) {
            var msg2 = "assert_array_equals: ";
            if (description) { msg2 = description + ": "; }
            msg2 = msg2 + "element " + i + " differs: " + actual[i] + " vs " + expected[i];
            throw new Error(msg2);
        }
    }
}

function assert_class_string(object, expected, description) {
    // Simplified: just check that the object exists
    if (object === null || object === undefined) {
        var msg = "assert_class_string: ";
        if (description) { msg = description + ": "; }
        msg = msg + "object is " + String(object);
        throw new Error(msg);
    }
}

function assert_readonly(object, name, description) {
    // Simplified: just verify the property exists
    if (!(name in object)) {
        var msg = "assert_readonly: ";
        if (description) { msg = description + ": "; }
        msg = msg + "property " + name + " not found";
        throw new Error(msg);
    }
}

function assert_unreached(description) {
    var msg = "assert_unreached: ";
    if (description) { msg = msg + description; }
    throw new Error(msg);
}

// Event constructor shim (for tests that create events).
if (typeof Event === "undefined") {
    function Event(type, options) {
        this.type = type;
        this.bubbles = false;
        this.cancelable = false;
        if (options) {
            if (options.bubbles) { this.bubbles = options.bubbles; }
            if (options.cancelable) { this.cancelable = options.cancelable; }
        }
        this.defaultPrevented = false;
        this.target = null;
        this.currentTarget = null;
    }
}

// setup() is a no-op in our harness.
function setup(func_or_properties, maybe_properties) {}

// done() for manual tests — no-op in our synchronous model.
function done() {}

// format_value helper used by some tests.
function format_value(value) {
    return String(value);
}

// After all scripts run, dump results to console for the harness to read.
// This is invoked by the test runner after script execution.
"#;

/// A captured console that stores output.
struct CapturedConsole {
    messages: RefCell<Vec<String>>,
}

impl CapturedConsole {
    fn new() -> Self {
        Self {
            messages: RefCell::new(Vec::new()),
        }
    }
}

impl we_js::vm::ConsoleOutput for CapturedConsole {
    fn log(&self, message: &str) {
        self.messages.borrow_mut().push(message.to_string());
    }
    fn error(&self, _message: &str) {}
    fn warn(&self, _message: &str) {}
}

/// Wrapper to make Rc<CapturedConsole> implement ConsoleOutput.
struct RcConsole(Rc<CapturedConsole>);

impl we_js::vm::ConsoleOutput for RcConsole {
    fn log(&self, message: &str) {
        self.0.log(message);
    }
    fn error(&self, message: &str) {
        self.0.error(message);
    }
    fn warn(&self, message: &str) {
        self.0.warn(message);
    }
}

/// Result of a single subtest within an HTML test file.
#[derive(Debug)]
struct SubtestResult {
    name: String,
    status: SubtestStatus,
    message: String,
}

#[derive(Debug, Clone, Copy, PartialEq)]
enum SubtestStatus {
    Pass,
    Fail,
    Timeout,
    NotRun,
}

/// Result of running an entire HTML test file.
#[derive(Debug)]
enum TestFileResult {
    /// Test file executed, subtests collected.
    Executed(Vec<SubtestResult>),
    /// Test file was skipped.
    Skip(String),
    /// Test file caused a panic.
    Panic,
}

/// Category statistics for reporting.
struct CategoryStats {
    pass: usize,
    fail: usize,
    skip: usize,
    timeout: usize,
    error: usize,
}

impl CategoryStats {
    fn new() -> Self {
        Self {
            pass: 0,
            fail: 0,
            skip: 0,
            timeout: 0,
            error: 0,
        }
    }

    fn total(&self) -> usize {
        self.pass + self.fail + self.skip + self.timeout + self.error
    }

    fn executed(&self) -> usize {
        self.pass + self.fail
    }

    fn pass_rate(&self) -> f64 {
        let executed = self.executed();
        if executed == 0 {
            0.0
        } else {
            (self.pass as f64 / executed as f64) * 100.0
        }
    }
}

/// Recursively collect `.html` test files under a directory.
fn collect_test_files(dir: &Path, files: &mut Vec<PathBuf>) {
    let entries = match std::fs::read_dir(dir) {
        Ok(e) => e,
        Err(_) => return,
    };
    let mut entries: Vec<_> = entries.filter_map(|e| e.ok()).collect();
    entries.sort_by_key(|e| e.file_name());

    for entry in entries {
        let path = entry.path();
        if path.is_dir() {
            collect_test_files(&path, files);
        } else if path
            .extension()
            .map_or(false, |e| e == "html" || e == "htm")
        {
            files.push(path);
        }
    }
}

/// Check if an HTML file is a testharness.js test (contains a reference
/// to testharness.js or uses test()/async_test()/promise_test()).
fn is_testharness_test(html: &str) -> bool {
    html.contains("testharness.js")
        || html.contains("test(function")
        || html.contains("test(()") // arrow function variant
        || html.contains("async_test(")
        || html.contains("promise_test(")
}

/// Extract inline script content from all `<script>` elements in the DOM,
/// skipping references to testharness.js and testharnessreport.js.
fn extract_inline_scripts(doc: &we_dom::Document) -> Vec<String> {
    let mut scripts = Vec::new();
    let mut stack = vec![doc.root()];

    while let Some(node) = stack.pop() {
        if doc.tag_name(node) == Some("script") {
            // Skip external testharness.js references
            if let Some(src) = doc.get_attribute(node, "src") {
                if src.contains("testharness") {
                    continue;
                }
            }

            // Collect inline script text
            let mut text = String::new();
            for child in doc.children(node) {
                if let Some(data) = doc.text_content(child) {
                    text.push_str(data);
                }
            }
            if !text.trim().is_empty() {
                scripts.push(text);
            }
        }

        // Push children in reverse order so they're processed in document order
        let children: Vec<_> = doc.children(node).collect();
        for child in children.into_iter().rev() {
            stack.push(child);
        }
    }

    scripts
}

/// Parse the results array from the VM after test execution.
///
/// Evaluates `__wpt_results__` in the VM and extracts the test results.
/// We use console.log to serialize results since we can't directly read
/// JS objects from Rust.
fn collect_results_from_vm(vm: &mut we_js::vm::Vm) -> Vec<SubtestResult> {
    // Evaluate a script that serializes results to console.
    let collect_script = r#"
        var __r__ = "";
        for (var __i__ = 0; __i__ < __wpt_results__.length; __i__ = __i__ + 1) {
            var __t__ = __wpt_results__[__i__];
            __r__ = __r__ + __t__.status + "\t" + __t__.name + "\t" + __t__.message + "\n";
        }
        __r__
    "#;

    let ast = match we_js::parser::Parser::parse(collect_script) {
        Ok(ast) => ast,
        Err(_) => return Vec::new(),
    };
    let func = match we_js::compiler::compile(&ast) {
        Ok(f) => f,
        Err(_) => return Vec::new(),
    };
    let result = match vm.execute(&func) {
        Ok(v) => v.to_js_string(&vm.gc),
        Err(_) => return Vec::new(),
    };

    // Parse the tab-separated results.
    let mut subtests = Vec::new();
    for line in result.lines() {
        let parts: Vec<&str> = line.splitn(3, '\t').collect();
        if parts.len() >= 2 {
            let status = match parts[0] {
                "0" => SubtestStatus::Pass,
                "1" => SubtestStatus::Fail,
                "2" => SubtestStatus::Timeout,
                _ => SubtestStatus::NotRun,
            };
            let name = parts[1].to_string();
            let message = if parts.len() > 2 {
                parts[2].to_string()
            } else {
                String::new()
            };
            subtests.push(SubtestResult {
                name,
                status,
                message,
            });
        }
    }

    subtests
}

/// Run a single WPT test HTML file.
fn run_test_file(path: &Path) -> TestFileResult {
    let html = match std::fs::read_to_string(path) {
        Ok(s) => s,
        Err(e) => return TestFileResult::Skip(format!("read error: {e}")),
    };

    // Skip non-testharness tests (e.g., reftests, manual tests).
    if !is_testharness_test(&html) {
        return TestFileResult::Skip("not a testharness test".to_string());
    }

    // Wrap in catch_unwind to handle panics gracefully.
    let result =
        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| run_test_file_inner(&html)));

    match result {
        Ok(r) => r,
        Err(_) => TestFileResult::Panic,
    }
}

/// Inner implementation of test file execution (may panic).
fn run_test_file_inner(html: &str) -> TestFileResult {
    // Parse HTML to DOM.
    let doc = we_html::parse_html(html);

    // Create VM with DOM access.
    let console = Rc::new(CapturedConsole::new());
    let mut vm = we_js::vm::Vm::new();
    vm.set_console_output(Box::new(RcConsole(console.clone())));
    vm.attach_document(doc);

    // Set instruction limit.
    vm.set_instruction_limit(INSTRUCTION_LIMIT);

    // Execute testharness.js preamble.
    let preamble_ast = match we_js::parser::Parser::parse(TESTHARNESS_PREAMBLE) {
        Ok(ast) => ast,
        Err(e) => {
            return TestFileResult::Skip(format!("preamble parse error: {e}"));
        }
    };
    let preamble_func = match we_js::compiler::compile(&preamble_ast) {
        Ok(f) => f,
        Err(e) => {
            return TestFileResult::Skip(format!("preamble compile error: {e}"));
        }
    };
    if let Err(e) = vm.execute(&preamble_func) {
        return TestFileResult::Skip(format!("preamble runtime error: {e}"));
    }

    // Reset instruction limit for the actual test code.
    vm.set_instruction_limit(INSTRUCTION_LIMIT);

    // Get the current document from VM to extract scripts.
    // We need to temporarily detach to read the DOM.
    let doc = match vm.detach_document() {
        Some(d) => d,
        None => return TestFileResult::Skip("no document".to_string()),
    };

    // Extract inline scripts (skip testharness.js/testharnessreport.js references).
    let scripts = extract_inline_scripts(&doc);

    // Re-attach document.
    vm.attach_document(doc);

    if scripts.is_empty() {
        return TestFileResult::Skip("no inline scripts".to_string());
    }

    // Execute each inline script.
    for (i, script) in scripts.iter().enumerate() {
        let label = format!("script[{i}]");
        let ast = match we_js::parser::Parser::parse(script) {
            Ok(ast) => ast,
            Err(e) => {
                eprintln!("  [wpt] parse error in {label}: {e}");
                continue;
            }
        };
        let func = match we_js::compiler::compile(&ast) {
            Ok(f) => f,
            Err(e) => {
                eprintln!("  [wpt] compile error in {label}: {e}");
                continue;
            }
        };
        if let Err(e) = vm.execute(&func) {
            // Script errors are expected in some tests (e.g., assert failures).
            // The testharness.js shim catches them. This is for uncaught errors.
            let _ = e; // suppress
        }
    }

    // Pump event loop for any pending microtasks.
    let _ = vm.pump_event_loop();

    // Collect results from the VM.
    let results = collect_results_from_vm(&mut vm);

    // Clean up.
    let _ = vm.detach_document();

    if results.is_empty() {
        TestFileResult::Skip("no test results collected".to_string())
    } else {
        TestFileResult::Executed(results)
    }
}

/// Install a silent panic hook to avoid noise from expected panics.
fn set_silent_panic_hook() {
    std::panic::set_hook(Box::new(|_| {}));
}

/// Restore the default panic hook.
fn restore_panic_hook() {
    let _ = std::panic::take_hook();
}

/// Verify the testharness.js preamble compiles and basic assertions work.
#[test]
fn wpt_harness_preamble() {
    // Preamble should evaluate without errors.
    we_js::evaluate(TESTHARNESS_PREAMBLE).expect("preamble should evaluate cleanly");

    // test() with passing assertion should produce a PASS result.
    let script = format!(
        "{}\n{}",
        TESTHARNESS_PREAMBLE,
        r#"
        test(function() {
            assert_true(true);
        }, "basic pass");

        test(function() {
            assert_equals(1, 1);
        }, "equals pass");

        test(function() {
            assert_equals(1, 2);
        }, "equals fail");

        var pass_count = 0;
        var fail_count = 0;
        for (var i = 0; i < __wpt_results__.length; i = i + 1) {
            if (__wpt_results__[i].status === 0) { pass_count = pass_count + 1; }
            if (__wpt_results__[i].status === 1) { fail_count = fail_count + 1; }
        }
        String(pass_count) + "," + String(fail_count)
        "#
    );

    let result = we_js::evaluate(&script).expect("test script should evaluate");
    assert_eq!(result, "2,1", "expected 2 passes and 1 fail");
}

/// Verify that async_test works.
#[test]
fn wpt_harness_async_test() {
    let script = format!(
        "{}\n{}",
        TESTHARNESS_PREAMBLE,
        r#"
        var t = async_test("async pass");
        t.step(function() {
            assert_true(true);
        });
        t.done();

        var pass_count = 0;
        for (var i = 0; i < __wpt_results__.length; i = i + 1) {
            if (__wpt_results__[i].status === 0) { pass_count = pass_count + 1; }
        }
        String(pass_count)
        "#
    );

    let result = we_js::evaluate(&script).expect("async test should evaluate");
    assert_eq!(result, "1", "expected 1 async test pass");
}

/// Main WPT test suite runner.
#[test]
fn wpt_dom_tests() {
    // Run in a thread with a large stack for deep recursion safety.
    let builder = std::thread::Builder::new()
        .name("wpt".into())
        .stack_size(32 * 1024 * 1024);
    let handle = builder
        .spawn(wpt_dom_tests_inner)
        .expect("failed to spawn wpt thread");
    handle.join().expect("wpt thread panicked");
}

fn wpt_dom_tests_inner() {
    let test_dir = PathBuf::from(WORKSPACE_ROOT).join("tests/wpt");

    if !test_dir.exists() {
        eprintln!("WPT tests not found at {}", test_dir.display());
        eprintln!("Skipping WPT tests.");
        return;
    }

    // Collect test files from the WPT test directories we care about.
    let subdirs = [
        "dom/nodes",
        "dom/events",
        "dom/collections",
        "html/dom",
        "console",
    ];

    let mut all_files: Vec<PathBuf> = Vec::new();
    for subdir in &subdirs {
        let dir = test_dir.join(subdir);
        if dir.exists() {
            collect_test_files(&dir, &mut all_files);
        }
    }

    if all_files.is_empty() {
        eprintln!("No WPT test files found under {}", test_dir.display());
        return;
    }

    // Suppress panic output during test execution.
    set_silent_panic_hook();

    eprintln!("\n=== WPT DOM Tests ===\n");

    let mut groups: HashMap<String, CategoryStats> = HashMap::new();
    let mut total = CategoryStats::new();
    let mut failed_tests: Vec<(String, String)> = Vec::new();

    for path in &all_files {
        // Determine the group (e.g., "dom/nodes", "dom/events").
        let rel = path.strip_prefix(&test_dir).unwrap_or(path);
        let group = rel
            .parent()
            .map(|p| p.to_string_lossy().to_string())
            .unwrap_or_default();

        let stats = groups
            .entry(group.clone())
            .or_insert_with(CategoryStats::new);
        let file_name = rel.to_string_lossy().to_string();

        match run_test_file(path) {
            TestFileResult::Executed(subtests) => {
                for subtest in &subtests {
                    match subtest.status {
                        SubtestStatus::Pass => {
                            stats.pass += 1;
                            total.pass += 1;
                        }
                        SubtestStatus::Fail => {
                            stats.fail += 1;
                            total.fail += 1;
                            failed_tests.push((
                                format!("{}: {}", file_name, subtest.name),
                                subtest.message.clone(),
                            ));
                        }
                        SubtestStatus::Timeout => {
                            stats.timeout += 1;
                            total.timeout += 1;
                        }
                        SubtestStatus::NotRun => {
                            stats.skip += 1;
                            total.skip += 1;
                        }
                    }
                }
            }
            TestFileResult::Skip(_reason) => {
                stats.skip += 1;
                total.skip += 1;
            }
            TestFileResult::Panic => {
                stats.error += 1;
                total.error += 1;
                failed_tests.push((file_name, "PANIC: test file caused a panic".to_string()));
            }
        }
    }

    // Print results grouped by directory.
    let mut group_names: Vec<&String> = groups.keys().collect();
    group_names.sort();

    for name in &group_names {
        let stats = &groups[*name];
        if stats.total() > 0 {
            eprintln!(
                "  {:<30} {:>4} pass  {:>4} fail  {:>4} skip  {:>4} error  ({:.0}%)",
                name,
                stats.pass,
                stats.fail,
                stats.skip,
                stats.error,
                stats.pass_rate()
            );
        }
    }

    eprintln!();
    eprintln!(
        "  {:<30} {:>4} pass  {:>4} fail  {:>4} skip  {:>4} error  ({:.0}%)",
        "TOTAL",
        total.pass,
        total.fail,
        total.skip,
        total.error,
        total.pass_rate()
    );
    eprintln!(
        "  {} total subtests, {} executed, {} files",
        total.total(),
        total.executed(),
        all_files.len()
    );

    // Print failed test details (up to 50).
    if !failed_tests.is_empty() {
        eprintln!("\n  --- Failed Tests ---");
        for (i, (name, msg)) in failed_tests.iter().enumerate() {
            if i >= 50 {
                eprintln!("  ... and {} more", failed_tests.len() - 50);
                break;
            }
            let short_msg = if msg.len() > 100 {
                let end = msg.floor_char_boundary(100);
                format!("{}...", &msg[..end])
            } else {
                msg.clone()
            };
            eprintln!("  FAIL: {} — {}", name, short_msg);
        }
    }

    eprintln!();

    // Restore default panic hook.
    restore_panic_hook();

    // The test passes as long as the harness works. We report pass rate but
    // don't assert a minimum — the rate will increase as more features land.
    // We do expect at least some subtests to execute.
    assert!(
        total.pass + total.fail > 0,
        "Expected at least some WPT subtests to execute"
    );
}