(* The milestone-2 acceptance test: a table of expression/result pairs run
   through a compiled calc-me (plan.org, Build sequence).

   It is a table rather than a golden file because milestone 3 runs the *same*
   table on wasm32 — headless is what makes one test cover both targets. *)

open Flan

let failures = ref 0

let scratch = Filename.get_temp_dir_name ()

let run exe arg =
  let out = Filename.concat scratch "flan-acceptance.out" in
  let cmd =
    Printf.sprintf "%s %s > %s 2>&1"
      (Filename.quote exe)
      (match arg with None -> "" | Some a -> Filename.quote a)
      (Filename.quote out)
  in
  let code = Sys.command cmd in
  let text = In_channel.with_open_bin out In_channel.input_all in
  Sys.remove out;
  (code, text)

let compile ?(opt = "-O2") path =
  let exe =
    Filename.concat scratch
      ("flan-t-" ^ Filename.remove_extension (Filename.basename path))
  in
  let p = Reader.read_file path |> Parse.program |> Check.program in
  ignore (Build.executable ~opts:{ Build.default with opt } p ~out:exe);
  exe

let () =
  match Sys.command "command -v clang > /dev/null 2>&1" with
  | 0 ->
    let exe = compile "../calc-me.flan" in

    let case name arg expected_out expected_code =
      let code, text = run exe arg in
      if text <> expected_out || code <> expected_code then begin
        incr failures;
        Printf.printf
          "FAIL  %s\n        got: %S (exit %d)\n     wanted: %S (exit %d)\n"
          name text code expected_out expected_code
      end
    in
    let evaluates src expected = case src (Some src) (expected ^ "\n") 0 in
    let rejects src = case src (Some src) "calc-me: cannot parse\n" 1 in

    (* Arithmetic and precedence *)
    evaluates "1 + 2 * (3 - 0.5) / 2" "3.5";
    evaluates "1+2*3"                 "7";
    evaluates "2*3+4"                 "10";
    evaluates "(1+2)*3"               "9";
    evaluates "10/4"                  "2.5";
    evaluates "7"                     "7";
    evaluates "  7  "                 "7";
    evaluates "1.5+2.25"              "3.75";

    (* Left-associative: 1-2-3 is (1-2)-3, not 1-(2-3) *)
    evaluates "1-2-3"                 "-4";
    evaluates "8/4/2"                 "1";

    (* Unary minus, including nested *)
    evaluates "-5"                    "-5";
    evaluates "-(1+2)"                "-3";
    evaluates "3 * -2"                "-6";

    (* Whole input or nothing: trailing junk is an error, not ignored *)
    rejects "1 +";
    rejects "(1+2";
    rejects "1 2";
    rejects "";
    rejects "+";
    rejects "1+2)";

    case "no argument" None "usage: calc-me \"1 + 2 * 3\"\n" 1;
    (try Sys.remove exe with Sys_error _ -> ());

    (* Programs whose whole output is fixed. These cover the milestone-2
       surface calc-me does not reach — globals, 2-D arrays, places through a
       pointer, casts, match with either arm taken, and the value semantics of
       spec-memory.md. *)
    let outputs ?opt name path expected =
      let exe = compile ?opt path in
      let code, text = run exe None in
      if text <> expected || code <> 0 then begin
        incr failures;
        Printf.printf
          "FAIL  %s\n        got: %S (exit %d)\n     wanted: %S (exit 0)\n"
          name text code expected
      end;
      (try Sys.remove exe with Sys_error _ -> ())
    in
    let values_out = "1\n5\nel\n" in
    let machine_out = "12\n30\n2\n2\n3\n3.5\n42\n99\n12\n123\n" in
    outputs "value semantics" "programs/values.flan" values_out;
    outputs "machine surface" "programs/machine.flan" machine_out;
    outputs "unit main exits 0" "programs/unit-main.flan" "ok\n";

    (* Again at -O0. Everything above runs through mem2reg, which launders a
       sloppy alloca; -O0 tests the IR actually emitted, so a disagreement
       between the two points at undefined behaviour rather than a typo. *)
    outputs ~opt:"-O0" "value semantics, -O0" "programs/values.flan" values_out;
    outputs ~opt:"-O0" "machine surface, -O0" "programs/machine.flan" machine_out;

    if !failures = 0 then print_endline "acceptance: all tests passed"
    else begin
      Printf.printf "\n%d failure(s)\n" !failures;
      exit 1
    end
  | _ -> print_endline "acceptance: skipped (no clang on PATH)"