tokitai-operator 0.1.0

use std::fs;

use tokitai_operator::verify::{
    APPLICATION_EVIDENCE_MATRIX_CSV_HEADER, BASELINE_SCALE_COMPARISON_CSV_HEADER,
    CLAIM_TO_TEST_MATRIX_CSV_HEADER, MATH_BOUND_AUDIT_TRACE_ARTIFACT,
    MATH_BOUND_AUDIT_TRACE_SCHEMA_FIELDS, MEASUREMENT_SUMMARY_CSV_HEADER,
    PADIC_STRATIFIED_BENCHMARK_FIXTURE_SCHEMA_FIELDS, PADIC_STRATIFIED_BENCHMARK_REPORT_ARTIFACT,
    PADIC_STRATIFIED_BENCHMARK_REPORT_SCHEMA_FIELDS, PADIC_STRATIFIED_BENCHMARK_ROW_SCHEMA_FIELDS,
    PAPER_BENCHMARK_RESULTS_ARTIFACT, PAPER_BENCHMARK_RESULTS_SCHEMA_FIELDS,
    PAPER_RESULTS_CSV_HEADER, PROOF_ASSISTANT_ADAPTER_REGISTRY_ARTIFACT,
    PROOF_ASSISTANT_ADAPTER_REGISTRY_SCHEMA_FIELDS, PROOF_ASSISTANT_CHECKER_OUTPUT_ARTIFACT,
    PROOF_ASSISTANT_CHECKER_OUTPUT_SCHEMA_FIELDS, PROOF_ASSISTANT_CHECKER_RESULT_INDEX_ARTIFACT,
    PROOF_ASSISTANT_CHECKER_RESULT_INDEX_SCHEMA_FIELDS,
    PROOF_ASSISTANT_CHECKER_TRANSCRIPT_ARTIFACT, PROOF_ASSISTANT_CHECKER_TRANSCRIPT_SCHEMA_FIELDS,
    PROOF_ASSISTANT_LEAN_CHECKABLE_ARTIFACT, PROOF_ASSISTANT_LEAN_CHECKABLE_SCHEMA_FIELDS,
    PROOF_ASSISTANT_NATIVE_ADMISSION_ARTIFACT, PROOF_ASSISTANT_NATIVE_ADMISSION_SCHEMA_FIELDS,
    PROOF_REPLAY_REPORT_ARTIFACT, PROOF_REPLAY_REPORT_SCHEMA_FIELDS,
    PROOF_REPLAY_TRACE_BENCHMARK_ARTIFACT, PROOF_REPLAY_TRACE_BENCHMARK_SCHEMA_FIELDS,
    PROOF_REPLAY_TRACE_MANIFEST_ARTIFACT, PROOF_REPLAY_TRACE_MANIFEST_SCHEMA_FIELDS,
    PROOF_REPLAY_TRACE_TUNING_ARTIFACT, PROOF_REPLAY_TRACE_TUNING_SCHEMA_FIELDS,
    TAMPER_MATRIX_CSV_HEADER, THEORY_ENGINEERING_RELEASE_GATE_ARTIFACT,
    THEORY_ENGINEERING_RELEASE_GATE_SCHEMA_FIELDS, THEORY_SUPPORT_MATRIX_ARTIFACT,
    THEORY_SUPPORT_MATRIX_ROW_SCHEMA_FIELDS, THEORY_SUPPORT_MATRIX_SCHEMA_FIELDS,
    TRACE_ARCHITECTURE_CSV_HEADER,
};

fn compact_json(json: &str) -> String {
    json.chars()
        .filter(|character| !character.is_whitespace())
        .collect()
}

fn schema_required_fields(schema: &str, artifact: &str) -> Vec<String> {
    let schema = compact_json(schema);
    let artifact_marker = format!("\"artifact\":\"{artifact}\"");
    let artifact_start = schema
        .find(&artifact_marker)
        .unwrap_or_else(|| panic!("schema should include artifact {artifact}"));
    let required_start = schema[artifact_start..]
        .find("\"required_fields\":[")
        .map(|offset| artifact_start + offset + "\"required_fields\":[".len())
        .unwrap_or_else(|| panic!("schema artifact {artifact} should include required_fields"));
    let required_end = schema[required_start..]
        .find(']')
        .map(|offset| required_start + offset)
        .unwrap();
    schema[required_start..required_end]
        .split(',')
        .map(|field| field.trim_matches('"').to_string())
        .filter(|field| !field.is_empty())
        .collect()
}

fn schema_nested_required_fields(schema: &str, artifact: &str, nested_path: &str) -> Vec<String> {
    let schema = compact_json(schema);
    let artifact_marker = format!("\"artifact\":\"{artifact}\"");
    let artifact_start = schema
        .find(&artifact_marker)
        .unwrap_or_else(|| panic!("schema should include artifact {artifact}"));
    let nested_marker = format!("\"{nested_path}\":[");
    let nested_start = schema[artifact_start..]
        .find(&nested_marker)
        .map(|offset| artifact_start + offset + nested_marker.len())
        .unwrap_or_else(|| {
            panic!("schema artifact {artifact} should include nested fields for {nested_path}")
        });
    let nested_end = schema[nested_start..]
        .find(']')
        .map(|offset| nested_start + offset)
        .unwrap();
    schema[nested_start..nested_end]
        .split(',')
        .map(|field| field.trim_matches('"').to_string())
        .filter(|field| !field.is_empty())
        .collect()
}

fn schema_csv_header(schema: &str, filename: &str) -> String {
    let schema = compact_json(schema);
    let filename_marker = format!("\"filename\":\"{filename}\"");
    let filename_start = schema
        .find(&filename_marker)
        .unwrap_or_else(|| panic!("CSV schema should include {filename}"));
    let header_start = schema[filename_start..]
        .find("\"header\":\"")
        .map(|offset| filename_start + offset + "\"header\":\"".len())
        .unwrap_or_else(|| panic!("CSV schema entry {filename} should include header"));
    let header_end = schema[header_start..]
        .find('"')
        .map(|offset| header_start + offset)
        .unwrap();
    schema[header_start..header_end].to_string()
}

fn assert_schema_fields(schema: &str, artifact: &str, expected: &[&str]) {
    let actual = schema_required_fields(schema, artifact);
    let expected = expected
        .iter()
        .map(|field| field.to_string())
        .collect::<Vec<_>>();
    assert_eq!(
        actual, expected,
        "schema required_fields drifted for {artifact}"
    );
}

fn assert_nested_schema_fields(schema: &str, artifact: &str, nested_path: &str, expected: &[&str]) {
    let actual = schema_nested_required_fields(schema, artifact, nested_path);
    let expected = expected
        .iter()
        .map(|field| field.to_string())
        .collect::<Vec<_>>();
    assert_eq!(
        actual, expected,
        "schema nested_required_fields drifted for {artifact} {nested_path}"
    );
}

#[test]
fn generated_artifact_schema_matches_rust_schema_constants() {
    let schema = fs::read_to_string("docs/schemas/tokitai-artifacts-v1.schema.json")
        .expect("artifact schema should exist");

    assert_schema_fields(
        &schema,
        PROOF_REPLAY_TRACE_MANIFEST_ARTIFACT,
        PROOF_REPLAY_TRACE_MANIFEST_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_REPLAY_REPORT_ARTIFACT,
        PROOF_REPLAY_REPORT_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_ASSISTANT_ADAPTER_REGISTRY_ARTIFACT,
        PROOF_ASSISTANT_ADAPTER_REGISTRY_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_ASSISTANT_LEAN_CHECKABLE_ARTIFACT,
        PROOF_ASSISTANT_LEAN_CHECKABLE_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_ASSISTANT_CHECKER_TRANSCRIPT_ARTIFACT,
        PROOF_ASSISTANT_CHECKER_TRANSCRIPT_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_ASSISTANT_CHECKER_OUTPUT_ARTIFACT,
        PROOF_ASSISTANT_CHECKER_OUTPUT_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_ASSISTANT_NATIVE_ADMISSION_ARTIFACT,
        PROOF_ASSISTANT_NATIVE_ADMISSION_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_ASSISTANT_CHECKER_RESULT_INDEX_ARTIFACT,
        PROOF_ASSISTANT_CHECKER_RESULT_INDEX_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_REPLAY_TRACE_TUNING_ARTIFACT,
        PROOF_REPLAY_TRACE_TUNING_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PROOF_REPLAY_TRACE_BENCHMARK_ARTIFACT,
        PROOF_REPLAY_TRACE_BENCHMARK_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        MATH_BOUND_AUDIT_TRACE_ARTIFACT,
        MATH_BOUND_AUDIT_TRACE_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PAPER_BENCHMARK_RESULTS_ARTIFACT,
        PAPER_BENCHMARK_RESULTS_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        THEORY_SUPPORT_MATRIX_ARTIFACT,
        THEORY_SUPPORT_MATRIX_SCHEMA_FIELDS,
    );
    assert_nested_schema_fields(
        &schema,
        THEORY_SUPPORT_MATRIX_ARTIFACT,
        "rows[]",
        THEORY_SUPPORT_MATRIX_ROW_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        PADIC_STRATIFIED_BENCHMARK_REPORT_ARTIFACT,
        PADIC_STRATIFIED_BENCHMARK_REPORT_SCHEMA_FIELDS,
    );
    assert_nested_schema_fields(
        &schema,
        PADIC_STRATIFIED_BENCHMARK_REPORT_ARTIFACT,
        "rows[]",
        PADIC_STRATIFIED_BENCHMARK_ROW_SCHEMA_FIELDS,
    );
    assert_nested_schema_fields(
        &schema,
        PADIC_STRATIFIED_BENCHMARK_REPORT_ARTIFACT,
        "fixtures[]",
        PADIC_STRATIFIED_BENCHMARK_FIXTURE_SCHEMA_FIELDS,
    );
    assert_schema_fields(
        &schema,
        THEORY_ENGINEERING_RELEASE_GATE_ARTIFACT,
        THEORY_ENGINEERING_RELEASE_GATE_SCHEMA_FIELDS,
    );
}

#[test]
fn generated_csv_schema_matches_rust_header_constants() {
    let schema = fs::read_to_string("docs/schemas/tokitai-paper-csv-v1.schema.json")
        .expect("CSV schema should exist");

    assert_eq!(
        schema_csv_header(&schema, "paper-results.csv"),
        PAPER_RESULTS_CSV_HEADER
    );
    assert_eq!(
        schema_csv_header(&schema, "measurement-summary.csv"),
        MEASUREMENT_SUMMARY_CSV_HEADER
    );
    assert_eq!(
        schema_csv_header(&schema, "baseline-scale-comparison.csv"),
        BASELINE_SCALE_COMPARISON_CSV_HEADER
    );
    assert_eq!(
        schema_csv_header(&schema, "application-evidence-matrix.csv"),
        APPLICATION_EVIDENCE_MATRIX_CSV_HEADER
    );
    assert_eq!(
        schema_csv_header(&schema, "tamper-matrix.csv"),
        TAMPER_MATRIX_CSV_HEADER
    );
    assert_eq!(
        schema_csv_header(&schema, "claim-to-test-matrix.csv"),
        CLAIM_TO_TEST_MATRIX_CSV_HEADER
    );
    assert_eq!(
        schema_csv_header(&schema, "trace-architecture.csv"),
        TRACE_ARCHITECTURE_CSV_HEADER
    );
}

#[test]
fn generated_schema_versions_are_pinned_to_v1() {
    let artifact_schema = fs::read_to_string("docs/schemas/tokitai-artifacts-v1.schema.json")
        .expect("artifact schema should exist");
    let csv_schema = fs::read_to_string("docs/schemas/tokitai-paper-csv-v1.schema.json")
        .expect("CSV schema should exist");
    let compact_artifact_schema = compact_json(&artifact_schema);
    let compact_csv_schema = compact_json(&csv_schema);

    assert!(compact_artifact_schema.contains("\"schema_version\":1"));
    assert!(compact_artifact_schema.contains("\"artifact_version\":1"));
    assert!(compact_csv_schema.contains("\"schema_version\":1"));
    assert!(compact_csv_schema.contains("\"artifact_version\":1"));
    assert!(
        !compact_artifact_schema.contains("\"version\":2"),
        "P116 migration guard: artifact schema must not silently bump artifact versions"
    );
    assert!(
        !compact_csv_schema.contains("\"schema_version\":2"),
        "P116 migration guard: CSV schema must not silently bump schema versions"
    );
}