//! Rust 测试框架验证语法根、生成 Visitor、原文定位和版本化 JSON 接口，不执行编译后代码。
use frontend::ast::visitor::{Visitor, walk_expr, walk_function};
use frontend::ast::{
    AST_SCHEMA_ID, AstDocument, AstError, AstRoot, Expr, ExprKind, Function, Spanned, StmtKind,
};
use frontend::{EndorReader, ParseMode, Span, parse_ast, parse_source_ast};

#[test]
/// 由 Rust 测试框架调用：块内允许多个调用表达式语句及无 return 空体，但显式 return 必须位于块末尾。
fn function_bodies_accept_method_statements_and_optional_trailing_return() {
    // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
    let root = parse_ast(
        "function click(): Unit { title.setText(\"changed\") card.setColor(\"#FFEEDD\") }",
        ParseMode::Module,
    )
    .unwrap();
    // 模块模式必须产出 Program，不能把声明错误地包装成表达式或交互根。
    let AstRoot::Module(program) = root else {
        panic!("expected module")
    };
    // 借用首个顶层函数，用于检查块内语句分类及顺序。
    let function = program.functions().next().unwrap();
    assert_eq!(function.body.statements.len(), 2);
    assert!(
        function
            .body
            .statements
            .iter()
            .all(|s| matches!(s.kind, StmtKind::Expression(_)))
    );
    assert!(parse_ast("function empty(): Unit {}", ParseMode::Module).is_ok());
    assert!(
        parse_ast(
            "function invalid(): Unit { return value other() }",
            ParseMode::Module
        )
        .is_err()
    );
}

#[test]
/// 由 Rust 测试框架调用：核对模块/表达式/单条交互的根类型与语句种类，文档范围有效，来源诊断保留 Unicode 行列。
fn parse_modes_produce_distinct_roots_and_preserve_source_diagnostics() {
    // 保留与 AST 跨度相对应的原始 UTF-8 文本，后续不规范化空白或换行。
    let source = "function echo(value: String): String { let copy = value return copy }";
    // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
    let root = parse_ast(source, ParseMode::Module).unwrap();
    // 模块模式必须产出 Program，不能把声明错误地包装成表达式或交互根。
    let AstRoot::Module(program) = &root else {
        panic!("expected module")
    };
    // 借用首个顶层函数，用于检查块内语句分类及顺序。
    let function = program.functions().next().unwrap();
    assert_eq!(function.body.statements.len(), 2);
    // 第一条是 let Binding，不能与后面的 Return 混成同一语句种类。
    assert!(matches!(
        function.body.statements[0].kind,
        StmtKind::Binding(_)
    ));
    // 第二条明确为末尾 Return，顺序应与源码一致。
    assert!(matches!(
        function.body.statements[1].kind,
        StmtKind::Return(_)
    ));
    AstDocument::new(root)
        .unwrap()
        .validate_source(source)
        .unwrap();

    // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
    let root = parse_ast("echo(\"日\")", ParseMode::Expression).unwrap();
    // Expression 模式只能返回表达式根，不带交互语句包装。
    assert!(matches!(root, AstRoot::Expression(_)));
    // 一条 let、一次调用和一个函数声明分别构成交互提交，均应只含一个语句。
    for text in ["let value = \"日\"", "echo(value)", source] {
        // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
        let root = parse_ast(text, ParseMode::Interactive).unwrap();
        // 解构交互根并借用其单条语句，避免只检查解析成功而忽略根形状。
        let AstRoot::Interactive(input) = &root else {
            panic!("expected interactive")
        };
        assert_eq!(input.statements.len(), 1);
        AstDocument::new(root)
            .unwrap()
            .validate_source(text)
            .unwrap();
    }
    assert!(parse_ast("let x = 1 let y = 2", ParseMode::Interactive).is_err());
    assert!(parse_ast("", ParseMode::Interactive).is_err());
    // 给语法错误附会话来源身份，字符串中的日字使字节偏移与 Unicode 列不同。
    let source = EndorReader::from_text("<session:1>", "\"日\" + )");
    // 故意错误的快照解析必须返回带来源诊断，之后核对实际显示行列。
    let error = parse_source_ast(&source, ParseMode::Expression).unwrap_err();
    assert_eq!(error.location.line, 1);
    assert_eq!(error.location.column, 7);
    assert!(error.to_string().starts_with("<session:1>:1:7:"));
}

#[test]
/// 由 Rust 测试框架调用：自定义访问器收集函数名与引用名，并验证子遍历提前失败后，成功进入的祖先节点退出钩子仍全部配平。
fn generated_visitors_reach_names_and_unwind_node_hooks_on_error() {
    #[derive(Default)]
    /// 本测试的可变访问器状态；节点只借用，收集文本拥有副本，depth 跟踪默认节点钩子的配平。
    struct Names {
        // 自定义 visit_function 记录声明名，和表达式引用名分开。
        functions: Vec<String>,
        // visit_expr 仅收集 ExprKind::Name，不包含类型注解或属性名。
        references: Vec<String>,
        // enter/leave 计数，遍历结束或提前失败后都应回到零。
        depth: usize,
        // 为 true 时在第一个引用名处主动失败，用来检查错误回溯退出路径。
        stop: bool,
    }
    impl Visitor for Names {
        type Error = &'static str;
        /// 生成的默认 visit 方法成功进入节点时调用，记录当前已进入祖先数量。
        fn enter_node(&mut self, _span: Span) -> Result<(), Self::Error> {
            self.depth += 1;
            Ok(())
        }
        /// 默认 visit 在子遍历完成或失败后调用，撤销此前成功进入的节点计数。
        fn leave_node(&mut self) {
            self.depth -= 1;
        }
        /// 自定义函数访问入口先记录名称，再显式 walk_function 保持所有字段的递归访问。
        fn visit_function(&mut self, node: &Function) -> Result<(), Self::Error> {
            self.functions.push(node.name.text.clone());
            walk_function(self, node)
        }
        /// 自定义表达式访问入口只特殊处理引用名；其余结构继续由 walk_expr 分派。
        fn visit_expr(&mut self, node: &Expr) -> Result<(), Self::Error> {
            // 仅变量引用表达式进入收集/主动失败分支，字面量等节点仍照常递归。
            if let ExprKind::Name(name) = &node.kind {
                // 在调用 walk_expr 之前失败；默认祖先 visit 必须仍执行各自的 leave_node。
                if self.stop {
                    return Err("stopped at reference");
                }
                self.references.push(name.clone());
            }
            walk_expr(self, node)
        }
    }
    // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
    let root = parse_ast(
        "function echo(value: String): String { let copy = value return copy }",
        ParseMode::Module,
    )
    .unwrap();
    // 正常遍历从空状态开始，检查名称收集顺序及最终深度。
    let mut names = Names::default();
    names.visit_ast_root(&root).unwrap();
    assert_eq!(names.functions, ["echo"]);
    assert_eq!(names.references, ["value", "copy"]);
    assert_eq!(names.depth, 0);
    // 第二份访问器主动终止在引用名，不能复用正常访问器掩盖深度泄漏。
    let mut stopped = Names {
        stop: true,
        ..Names::default()
    };
    assert_eq!(stopped.visit_ast_root(&root), Err("stopped at reference"));
    assert_eq!(stopped.depth, 0);
}

#[test]
/// 由 Rust 测试框架调用：括号范围对应原文，CRLF 按一行、Unicode 按一列；安全定位拒绝逆序、越界及切断字符的范围。
fn spans_share_unicode_locations_and_safe_original_source_access() {
    // 保留与 AST 跨度相对应的原始 UTF-8 文本，后续不规范化空白或换行。
    let source = " \r\n(値)";
    // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
    let root = parse_ast(source, ParseMode::Expression).unwrap();
    assert_eq!(root.source_text(source), Some("(値)"));
    // 用同一原文把根节点的字节范围转换成一基行列，CRLF 只增加一行。
    let location = root.location(source).unwrap();
    assert_eq!((location.line, location.column), (2, 1));
    assert_eq!(Span::new(1, 3).slice("値"), None);
    assert_eq!(Span::new(2, 1).slice("値"), None);
    assert_eq!(Span::new(0, 4).location("値"), None);
}

#[test]
/// 由 Rust 测试框架调用：三个语法根 JSON 往返不丢文本/数值拼写，文档 schema 与生成的 JSON Schema/TypeScript 标识一致。
fn versioned_json_roundtrips_all_roots_and_preserves_number_spelling() {
    // 分别覆盖含长十进制的模块、含符号/转义字符串的表达式和交互绑定。
    for (source, mode) in [
        (
            "function f(): Number { return 00012345678901234567890.00100 }",
            ParseMode::Module,
        ),
        ("f(.名前, \"日\\n\")", ParseMode::Expression),
        ("let value = 1", ParseMode::Interactive),
    ] {
        // 用当前 schema 包装合法解析树并验证结构，为后续往返或定点破坏提供基线。
        let document = AstDocument::new(parse_ast(source, mode).unwrap()).unwrap();
        // 序列化前接口再次验证文档；输出应保留 schema、节点种类和原文字节范围。
        let json = document.to_json().unwrap();
        // 解码后重新验证文档结构，结果应与原文档完整相等。
        let restored = AstDocument::from_json(&json).unwrap();
        assert_eq!(restored, document);
        restored.validate_source(source).unwrap();
        assert!(json.contains(AST_SCHEMA_ID));
        // 模块案例包含带前导零和尾零的长数值，JSON 必须保留原拼写而非转浮点数。
        if mode == ParseMode::Module {
            assert!(json.contains("00012345678901234567890.00100"));
        }
    }
    // 读取仓库已生成的 JSON Schema，只检查标识与常量，不在测试中重新生成文件。
    let schema: serde_json::Value =
        serde_json::from_str(include_str!("../editor/ast.schema.json")).unwrap();
    assert_eq!(schema["$id"], AST_SCHEMA_ID);
    assert_eq!(
        schema["$defs"]["AstDocument"]["properties"]["schema"]["const"],
        AST_SCHEMA_ID
    );
    assert!(include_str!("../editor/ast.ts").contains(AST_SCHEMA_ID));
}

#[test]
/// 由 Rust 测试框架调用：分别拒绝错误 schema、未知字段、子节点越界、逆序范围以及对原文切断 UTF-8 字符的范围。
fn json_interfaces_reject_unknown_fields_schema_changes_and_invalid_ranges() {
    // 保留与 AST 跨度相对应的原始 UTF-8 文本，后续不规范化空白或换行。
    let source = "(f(値))";
    // 用当前 schema 包装合法解析树并验证结构，为后续往返或定点破坏提供基线。
    let document = AstDocument::new(parse_ast(source, ParseMode::Expression).unwrap()).unwrap();
    // 用可编辑 JSON 值破坏一个属性；每个错误案例之后重新从合法 document 创建。
    let mut value = serde_json::to_value(&document).unwrap();
    // 首先只破坏版本身份，应在 schema 比较阶段报告 SchemaMismatch。
    value["schema"] = "urn:endor:ast:unknown".into();
    assert!(matches!(
        AstDocument::from_json(&value.to_string()),
        Err(AstError::SchemaMismatch { .. })
    ));
    value = serde_json::to_value(&document).unwrap();
    // 恢复合法 JSON 后增加未知字段，生成类型的 deny_unknown_fields 应在解码阶段拒绝。
    value["root"]["data"]["unexpected"] = true.into();
    assert!(matches!(
        AstDocument::from_json(&value.to_string()),
        Err(AstError::Json(_))
    ));
    value = serde_json::to_value(&document).unwrap();
    // 再次恢复后缩小父范围，子节点仍在原位置，应报告 ChildOutsideParent。
    value["root"]["data"]["span"]["end"] = 1.into();
    assert!(matches!(
        AstDocument::from_json(&value.to_string()),
        Err(AstError::ChildOutsideParent { .. })
    ));
    // 取出合法表达式后直接破坏其范围，验证 new 也拒绝无效手工构造树。
    let AstRoot::Expression(mut expression) = document.root else {
        unreachable!()
    };
    // 无需原文也能识别 end 小于 start 的逆序范围。
    expression.span = Span::new(5, 4);
    assert!(matches!(
        AstDocument::new(AstRoot::Expression(expression)),
        Err(AstError::InvalidSpan(_))
    ));
    // 无原文时范围本身合法，但放回三字节字符原文时起点切断 UTF-8，应由 validate_source 拒绝。
    let root = AstRoot::Expression(Expr {
        kind: ExprKind::Name("値".into()),
        span: Span::new(1, 3),
    });
    assert!(matches!(
        AstDocument::new(root).unwrap().validate_source("値"),
        Err(AstError::InvalidSpan(_))
    ));
}

#[test]
/// 由 Rust 测试框架调用：普通赋值使用独立 AST 节点并保留 Unicode 原文；链式赋值和非成员调用目标赋值语法失败。
fn bare_assignment_has_its_own_ast_and_unicode_source_ranges() {
    // 保留与 AST 跨度相对应的原始 UTF-8 文本，后续不规范化空白或换行。
    let source = "标题 = ui.text(\"你好\")";
    // 仅解析指定模式的源码，取得拥有型 AstRoot，不分配 VM 对象。
    let root = parse_ast(source, ParseMode::Interactive).unwrap();
    // 解构交互根并借用其单条语句，避免只检查解析成功而忽略根形状。
    let AstRoot::Interactive(input) = &root else {
        panic!("interactive input")
    };
    // 普通赋值不是 let Binding，也不是成员赋值；名称节点和整句范围都要保持原文。
    let StmtKind::Assignment(assignment) = &input.statements[0].kind else {
        panic!("assignment")
    };
    assert_eq!(assignment.name.text, "标题");
    assert_eq!(assignment.name.source_text(source), Some("标题"));
    assert_eq!(assignment.source_text(source), Some(source));
    // 用当前 schema 包装合法解析树并验证结构，为后续往返或定点破坏提供基线。
    let document = AstDocument::new(root).unwrap();
    document.validate_source(source).unwrap();
    // 序列化前接口再次验证文档；输出应保留 schema、节点种类和原文字节范围。
    let json = document.to_json().unwrap();
    assert_eq!(AstDocument::from_json(&json).unwrap(), document);
    assert!(parse_ast("value = 1 = 2", ParseMode::Interactive).is_err());
    // 单独解析属性写入，确保普通赋值的新增路径没有抢走 MemberAssignment。
    let member = parse_ast("object.field = 1", ParseMode::Interactive).unwrap();
    // 必须检查节点类别，不能只根据字符串包含点就假定走了成员赋值规则。
    let AstRoot::Interactive(member) = member else {
        panic!("interactive")
    };
    // 属性写入使用 MemberAssignment，不能退化为普通目标名赋值。
    assert!(matches!(
        &member.statements[0].kind,
        StmtKind::MemberAssignment(_)
    ));
    assert!(parse_ast("object() = 1", ParseMode::Interactive).is_err());
}