//! `wai.live.remote` (extensions/remote-desktop.md): the committed corpus `live-conformance/remote/`
//! regenerates byte for byte from its fixed seeds, holds no other file, every case in it gets the
//! outcome it states at the commitment level and at the opened level, and the extension's §12
//! lists exactly the reasons the reference reports: the verification codes in its first table,
//! the host's refusals, with their numbers, in its second, the reasons a floor statement is
//! refused in its third, and the reasons a seal is not opened in its fourth. The generator itself
//! asserts that the corpus gives every one of them.
#![cfg(feature = "remote_desktop")]

use std::collections::BTreeMap;
use std::path::PathBuf;
use wai::remote_desktop::{corpus, FloorRefusal, Reason, Refusal, SealFault};

fn wai_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("..")
}

fn committed() -> BTreeMap<String, String> {
    let dir = wai_dir().join("live-conformance/remote");
    std::fs::read_dir(&dir)
        .expect("the committed corpus")
        .flatten()
        .map(|e| (e.file_name().to_string_lossy().into_owned(), e.path()))
        .filter(|(n, _)| n != "README.md")
        .map(|(n, p)| (n, std::fs::read_to_string(p).expect("a text file")))
        .collect()
}

#[test]
fn the_committed_corpus_regenerates_from_its_seeds() {
    let files = committed();
    let generated: BTreeMap<String, String> = corpus::generate().into_iter().collect();
    let extra: Vec<&String> = files.keys().filter(|k| !generated.contains_key(*k)).collect();
    let missing: Vec<&String> = generated.keys().filter(|k| !files.contains_key(*k)).collect();
    let differ: Vec<&String> = generated.iter().filter(|(k, v)| files.get(*k).is_some_and(|f| f != *v)).map(|(k, _)| k).collect();
    assert!(extra.is_empty() && missing.is_empty() && differ.is_empty(), "extra {extra:?}, missing {missing:?}, differ {differ:?}: run `wai_remote_desktop_vectors gen`");
}

#[test]
fn every_case_gets_its_stated_outcome() {
    let fails = corpus::verify(&committed());
    assert!(fails.is_empty(), "{}", fails.join("\n"));
}

/// §12 of the extension: its first table lists exactly the codes `Reason::ALL` has, each once, in
/// order; its second, exactly `Refusal::ALL`'s, each with its number; its third, exactly
/// `FloorRefusal::ALL`'s; its fourth, exactly `SealFault::ALL`'s.
#[test]
fn the_extension_lists_the_reasons() {
    let text = std::fs::read_to_string(wai_dir().join("extensions/remote-desktop.md")).expect("the extension");
    let at = text.find("\n## 12. Reasons").expect("a §12");
    let end = text[at + 1..].find("\n## ").map_or(text.len(), |e| at + 1 + e);
    let section = &text[at..end];
    // The tables, in order: each a run of lines that begin with `|`.
    let mut tables: Vec<Vec<&str>> = Vec::new();
    let mut cur: Vec<&str> = Vec::new();
    for l in section.lines() {
        if l.starts_with('|') {
            cur.push(l);
        } else if !cur.is_empty() {
            tables.push(std::mem::take(&mut cur));
        }
    }
    if !cur.is_empty() {
        tables.push(cur);
    }
    assert_eq!(tables.len(), 4, "§12 has four tables");
    let codes = |t: &[&str]| t.iter().filter(|l| l.starts_with("| `")).filter_map(|l| l.split('`').nth(1).map(String::from)).collect::<Vec<_>>();
    let want: Vec<String> = Reason::ALL.iter().map(|r| r.code().to_string()).collect();
    assert_eq!(codes(&tables[0]), want, "§12's first table and Reason::ALL differ");
    let want: Vec<String> = FloorRefusal::ALL.iter().map(|r| r.code().to_string()).collect();
    assert_eq!(codes(&tables[2]), want, "§12's third table and FloorRefusal::ALL differ");
    let want: Vec<String> = SealFault::ALL.iter().map(|r| r.code().to_string()).collect();
    assert_eq!(codes(&tables[3]), want, "§12's fourth table and SealFault::ALL differ");
    let numbered: Vec<(u8, String)> = tables[1]
        .iter()
        .filter_map(|l| {
            let cells: Vec<&str> = l.split('|').map(str::trim).collect();
            let n: u8 = cells.get(1)?.parse().ok()?;
            Some((n, cells.get(2)?.trim_matches('`').to_string()))
        })
        .collect();
    let want: Vec<(u8, String)> = Refusal::ALL.iter().map(|r| (r.number(), r.code().to_string())).collect();
    assert_eq!(numbered, want, "§12's second table and Refusal::ALL differ");
}