///|
/// Parse N-Quads 文件示例：main 只留 argv/路径解析；计时管线在 `bench_all`（wbtest 直调同链）
async fn main {
  let argv = @env.args()
  let path = if argv.length() > 1 { argv[1] } else { "./test_1000.nq" }
  let path = if @fs.exists(path) { path } else { "./src/bench/" + path }
  bench_all(path, @fs.read_file(path).binary())
}

///|
/// 四段管线计时（wbtest 直调同链；main 只留 argv/路径解析）
async fn bench_all(path : String, content : Bytes) -> Unit {
  @async.with_task_group() <| _root => {
    let data = content.to_fixedarray()

    // 1. 仅词法（纯 MoonBit Lexermoon；C FFI 对照见 gen_nquads 的 lexer_bench_wbtest）
    let start1 = @bench.monotonic_clock_start()
    let lexer = @nquads.Lexermoon::new(data[:])
    let mut lexer_count = 0
    for ;; {
      match lexer.next() {
        Some(@nquads.NQuadsEvent::NQuadsEOF) => break
        Some(_) => lexer_count = lexer_count + 1
        None => break
      }
    }
    let elapsed1 = @bench.monotonic_clock_end(start1)

    // 2. NQuadsEngine (不含验证)
    let engine = @nquads.NQuadsEngine::from_bytes(Array::from_fixed_array(data))
    let start2 = @bench.monotonic_clock_start()
    let mut parser_count = 0
    for ;; {
      match engine.next() {
        Some(Ok(_)) => parser_count = parser_count + 1
        Some(Err(_)) => ()
        None => break
      }
    }

    let elapsed2 = @bench.monotonic_clock_end(start2)

    // 3. SliceParser::parse_all (含验证)
    let engine2 = @nquads.NQuadsEngine::from_bytes(
      Array::from_fixed_array(data),
    )
    let slice = @nquads.SliceParser::new(engine2, data)
    let start3 = @bench.monotonic_clock_start()
    let (quads, parse_errors) = slice.parse_all()
    let elapsed3 = @bench.monotonic_clock_end(start3)

    // 4. materialize
    let engine3 = @nquads.NQuadsEngine::from_bytes(
      Array::from_fixed_array(data),
    )
    let slice3 = @nquads.SliceParser::new(engine3, data)
    let (quad_spans, _) = slice3.parse_all()
    let start4 = @bench.monotonic_clock_start()
    let (quad_emits, mat_errors) = @nquads.materialize_all(quad_spans)
    let elapsed4 = @bench.monotonic_clock_end(start4)

    let total_ms = (elapsed3 + elapsed4) / 1000.0
    let quads_per_sec = if total_ms > 0.0 {
      quads.length().to_double() / (total_ms / 1000.0)
    } else {
      0.0
    }
    let ms_per_quad = if quads.length() > 0 {
      total_ms / quads.length().to_double()
    } else {
      0.0
    }

    println("=== MoonBit 解析 \{path} ===")
    println("文件: \{path}")
    println("文件大小: \{data.length()} bytes")
    println("")
    println("=== 性能数据 ===")
    println("Lexer:       \{elapsed1} µs (\{lexer_count} tokens)")
    println("Parser:     \{elapsed2} µs (\{parser_count} quads)")
    println(
      "验证:        \{elapsed3} µs (\{quads.length()} quads, \{parse_errors.length()} errors)",
    )
    println(
      "物化:        \{elapsed4} µs (\{quad_emits.length()} quads, \{mat_errors.length()} errors)",
    )
    println("")
    println("=== 总计 ===")
    println("总时间:      \{total_ms} ms")
    println("三元组数量:  \{quads.length()}")
    println("每秒解析:    \{quads_per_sec.to_string()}")
    println("每三元组:    \{ms_per_quad.to_string()} ms")
  }
}