// Copyright 2026 ppyq882
// Licensed under the Apache License, Version 2.0

///|
fn main {
  let args = @env.args()
  if args.length() <= 1 {
    print_usage()
  } else {
    match args[1] {
      "demo" => run_all_demos()
      "benchmark" => run_benchmark()
      "version" | "--version" => println("moon-privacy-budget 0.1.1")
      "help" | "--help" | "-h" => print_usage()
      command => {
        println("Unknown command: " + command)
        println("")
        print_usage()
      }
    }
  }
}

///|
fn print_usage() -> Unit {
  println("moon-privacy-budget 0.1.1")
  println("Auditable differential-privacy budgets and private query plans.")
  println("")
  println("Usage: moon run main -- ")
  println("")
  println("Commands:")
  println("  demo       run the end-to-end budget, query, and audit examples")
  println("  benchmark  measure a deterministic private-query workload")
  println("  version    print the CLI version")
  println("  help       print this message")
}

///|
fn run_all_demos() -> Unit {
  println("moon-privacy-budget 0.1.1")
  println("")
  run_budget_demo()
  run_sql_demo()
  run_audit_demo()
}

///|
fn benchmark_table(rows : Int) -> Result[@query.Table, String] {
  match @core.DomainBound::new(0.0, 1000.0) {
    Err(error) => Err(error)
    Ok(bound) => {
      let values : Array[Double] = Array::new()
      for i in 0.. Ok(table)
        Err(error) => Err(error)
      }
    }
  }
}

///|
fn run_benchmark() -> Unit {
  let rows = 10000
  let iterations = 50
  let table = match benchmark_table(rows) {
    Ok(value) => value
    Err(error) => {
      println("benchmark setup failed: " + error)
      return
    }
  }
  let plan = match
    @query.parse_sql_plan(
      "SELECT COUNT(*) FROM benchmark WHERE value > 500 LIMIT 5000",
    ) {
    Ok(value) => value
    Err(error) => {
      println("benchmark plan failed: " + error)
      return
    }
  }
  let epsilon = match @core.Epsilon::new(1.0) {
    Ok(value) => value
    Err(error) => {
      println("benchmark epsilon failed: " + error)
      return
    }
  }
  let start = @env.now()
  let mut completed = 0
  let mut last_result : Array[Double] = []
  for i in 0.. {
        last_result = result
        completed = completed + 1
      }
      Err(error) => {
        println("benchmark execution failed: " + error)
        return
      }
    }
  }
  let elapsed = @env.now() - start
  println("benchmark=private_count")
  println("rows=" + rows.to_string())
  println("iterations=" + iterations.to_string())
  println("completed=" + completed.to_string())
  println("elapsed_ticks=" + elapsed.to_string())
  println("last_noisy_count=" + last_result[0].to_string())
}