open Test_harness

let build_dir () = try Sys.getenv "DELTA_BUILD_DIR" with Not_found -> "_build"

let ocamlopt () = try Sys.getenv "DELTA_OCAMLOPT" with Not_found -> "ocamlopt"

let unique name =
  Printf.sprintf "%s_%d_%d" name (Unix.getpid ()) (Random.self_init (); Random.int 1000000)

let write_file path text =
  let channel = open_out path in
  output_string channel text;
  close_out channel

let run command =
  let log = Filename.temp_file "delta_test" ".log" in
  let fd = Unix.openfile log [ Unix.O_WRONLY; Unix.O_CREAT; Unix.O_TRUNC ] 0o600 in
  let argv = Array.of_list command in
  let pid = Unix.create_process argv.(0) argv Unix.stdin fd fd in
  let status = snd (Unix.waitpid [] pid) in
  Unix.close fd;
  let text = Native.read_file log in
  (try Sys.remove log with _ -> ());
  (status, text)

let compile source_path output_path =
  let command =
    [ ocamlopt (); "-I"; build_dir (); "-I"; "+unix"; "-o"; output_path;
      Filename.concat (build_dir ()) "delta_runtime.cmxa"; "unix.cmxa"; source_path ]
  in
  match run command with
  | Unix.WEXITED 0, _ -> None
  | _, text -> Some text

let example_driver =
  {|
let () =
  let rows =
    [ (1, { customer = "Ada"; total = 1500 });
      (2, { customer = "Bo"; total = 900 });
      (3, { customer = "Lin"; total = 2200 }) ]
  in
  let state = Query.init rows in
  print_endline (Query.output_to_string (Query.result state));
  print_endline (Delta_runtime.counters_to_string (Query.counters ()))
|}

let run_generated name plan driver =
  let dir = Filename.temp_file "delta_gen" "" in
  Sys.remove dir;
  Unix.mkdir dir 0o700;
  let source_path = Filename.concat dir (unique name ^ ".ml") in
  let exe_path = Filename.concat dir (unique name ^ ".exe") in
  write_file source_path (Emit.program_to_string plan ^ driver);
  let result =
    match compile source_path exe_path with
    | Some message -> Error ("the generated program did not compile:\n" ^ message)
    | None -> (
        match run [ exe_path ] with
        | Unix.WEXITED 0, text -> Ok text
        | _, text -> Error ("the generated program failed:\n" ^ text))
  in
  Native.remove_dir dir;
  result

let sample_plan fixture =
  let typed = infer (read_fixture fixture) in
  Simplify.simplify (Graph.build (Anf.program (Specialize.program typed)))

let codegen_cases =
  [
    ( "the emitted module initializes the example query",
      fun () ->
        let plan = sample_plan "expensive_order.delta" in
        match run_generated "expensive_orders" plan example_driver with
        | Error message -> fail "emitted program" message
        | Ok output ->
            let lines = String.split_on_char '\n' output in
            check_equal_string "output"
              "[ (1, (\"Ada\", 300)); (3, (\"Lin\", 440)) ]"
              (List.nth lines 0);
            check "counters are reported" (String.length (List.nth lines 1) > 0) );
    ( "the emitted module handles an integer query",
      fun () ->
        let plan = sample_plan "revenue.delta" in
        let driver =
          {|
let () =
  let rows = [ (1, { customer = "Ada"; total = 1000 }); (2, { customer = "Bo"; total = 250 }) ] in
  let state = Query.init rows in
  print_endline (Query.output_to_string (Query.result state))
|}
        in
        (match run_generated "revenue" plan driver with
        | Error message -> fail "emitted program" message
        | Ok output -> check_equal_string "revenue" "250" (String.trim output)) );
    ( "the emitted module handles a count query",
      fun () ->
        let plan = sample_plan "count_large.delta" in
        let driver =
          {|
let () =
  let rows =
    [ (1, { customer = "Ada"; total = 1000 });
      (2, { customer = "Bo"; total = 250 });
      (3, { customer = "Lin"; total = 501 }) ]
  in
  let state = Query.init rows in
  print_endline (Query.output_to_string (Query.result state))
|}
        in
        (match run_generated "count_large" plan driver with
        | Error message -> fail "emitted program" message
        | Ok output -> check_equal_string "count" "2" (String.trim output)) );
    ( "the emitted module compiles for a tuple valued query",
      fun () ->
        let typed =
          infer
            "type line = { price : int; quantity : int }\ninput lines : collection line\nquery q = lines |> filter (fun l -> l.quantity > 0) |> map (fun l -> (l.price, l.price * l.quantity))\n"
        in
        let plan = Simplify.simplify (Graph.build (Anf.program (Specialize.program typed))) in
        let driver = "let _ = Query.init []\n" in
        (match run_generated "tuple_query" plan driver with
        | Error message -> fail "emitted program" message
        | Ok _ -> check "compiles and runs" true) );
    ( "the emitted module compiles for a boolean valued query",
      fun () ->
        let typed =
          infer
            "type line = { price : int; quantity : int }\ninput lines : collection line\nquery q = lines |> map (fun l -> (l.price > 0, l.quantity))\n"
        in
        let plan = Simplify.simplify (Graph.build (Anf.program (Specialize.program typed))) in
        (match run_generated "bool_query" plan "let _ = Query.init []\n" with
        | Error message -> fail "emitted program" message
        | Ok _ -> check "compiles and runs" true) );
    ( "the generated module keeps generated identifiers distinct",
      fun () ->
        let typed =
          infer
            "input rows : collection int\nlet scale n = n * 2\nlet quad n = scale (scale n)\nquery q = rows |> map (fun r -> quad r + quad r)\n"
        in
        let plan = Simplify.simplify (Graph.build (Anf.program (Specialize.program typed))) in
        let text = Emit.program_to_string plan in
        check "no duplicated let binding in the emitted mapping function"
          (not (Util.starts_with "internal error" text));
        (match run_generated "identifiers" plan "let _ = Query.init []\n" with
        | Error message -> fail "emitted program" message
        | Ok _ -> check "compiles and runs" true) );
  ]

let update_driver =
  {|
let rows =
  [ (1, { customer = "Ada"; total = 1500 });
    (2, { customer = "Bo"; total = 900 });
    (3, { customer = "Lin"; total = 2200 }) ]

let batches =
  [ [ Query.Insert (4, { customer = "Cy"; total = 4000 }) ];
    [ Query.Replace (1, { customer = "Ada"; total = 100 }) ];
    [ Query.Remove 3 ];
    [ Query.Replace (4, { customer = "Cy"; total = 2000 }); Query.Replace (2, { customer = "Bo"; total = 5000 }) ];
    [ Query.Remove 99 ] ]

let () =
  let state = ref (Query.init rows) in
  print_endline (Query.output_to_string (Query.result !state));
  List.iter
    (fun ops ->
      match Query.apply_batch !state ops with
      | Delta_runtime.Failure message -> print_endline ("failure: " ^ message)
      | Delta_runtime.Success (next, _) ->
          state := next;
          print_endline (Query.output_to_string (Query.result !state)))
    batches
|}

let rec show_value value =
  match value with
  | Value.VInt number -> string_of_int number
  | Value.VBool truth -> string_of_bool truth
  | Value.VString text -> Printf.sprintf "%S" text
  | Value.VUnit -> "()"
  | Value.VTuple items -> "(" ^ String.concat ", " (List.map show_value items) ^ ")"
  | Value.VRecord (_, fields) ->
      "{ " ^ String.concat "; " (List.map (fun (label, item) -> label ^ " = " ^ show_value item) fields) ^ " }"
  | Value.VCollection _ -> "collection"

let show_output value =
  match value with
  | Value.VCollection map ->
      "[ "
      ^ String.concat "; "
          (List.map
             (fun (key, item) -> Printf.sprintf "(%d, %s)" key (show_value item))
             (Delta_runtime.Pure_map.bindings map))
      ^ " ]"
  | other -> show_value other

let row customer total =
  Value.VRecord ("order", [ ("customer", Value.VString customer); ("total", Value.VInt total) ])

let expected_from_reference fixture batches =
  let typed = infer (read_fixture fixture) in
  let entries = [ (1, row "Ada" 1500); (2, row "Bo" 900); (3, row "Lin" 2200) ] in
  let lines = ref [ show_output (Interpret.program typed entries) ] in
  let state = ref (Value.collection_of_list entries) in
  let advance batch =
    match Change.validate_batch ~existing:!state batch with
    | Change.Failure message ->
        lines := !lines @ [ "failure: " ^ message ]
    | Change.Success (temp, _) ->
        state := temp;
        lines := !lines @ [ show_output (Interpret.program typed (Delta_runtime.Pure_map.bindings temp)) ]
  in
  List.iter advance batches;
  !lines

let update_cases =
  [
    ( "the emitted update functions follow the reference interpreter",
      fun () ->
        let plan = sample_plan "expensive_order.delta" in
        let batches =
          [
            [ Change.OpInsert (4, row "Cy" 4000) ];
            [ Change.OpReplace (1, row "Ada" 100) ];
            [ Change.OpRemove 3 ];
            [ Change.OpReplace (4, row "Cy" 2000); Change.OpReplace (2, row "Bo" 5000) ];
            [ Change.OpRemove 99 ];
          ]
        in
        (match run_generated "updates" plan update_driver with
        | Error message -> fail "emitted program" message
        | Ok output ->
            let lines = List.filter (fun line -> line <> "") (String.split_on_char '\n' output) in
            let expected = expected_from_reference "expensive_order.delta" batches in
            check_equal_int "one line per step" (List.length expected) (List.length lines);
            List.iter2
              (fun want got -> if want <> got then fail "step output" (Printf.sprintf "expected %s, got %s" want got))
              expected lines) );
    ( "an invalid batch is rejected and the state stays usable",
      fun () ->
        let plan = sample_plan "expensive_order.delta" in
        let driver =
          {|
let () =
  let rows = [ (1, { customer = "Ada"; total = 1500 }) ] in
  let state = Query.init rows in
  (match Query.apply_batch state [ Query.Insert (1, { customer = "Bo"; total = 10 }) ] with
   | Delta_runtime.Failure message -> print_endline ("failure: " ^ message)
   | Delta_runtime.Success _ -> print_endline "unexpected success");
  (match Query.apply_batch state [ Query.Insert (2, { customer = "Bo"; total = 2000 }) ] with
   | Delta_runtime.Failure message -> print_endline ("failure: " ^ message)
   | Delta_runtime.Success (next, _) -> print_endline (Query.output_to_string (Query.result next)))
|}
        in
        (match run_generated "invalid_batch" plan driver with
        | Error message -> fail "emitted program" message
        | Ok output ->
            let lines = List.filter (fun line -> line <> "") (String.split_on_char '\n' output) in
            check_equal_string "duplicate insert"
              "failure: cannot insert key 1: it is already present" (List.nth lines 0);
            check_equal_string "state still usable"
              "[ (1, (\"Ada\", 300)); (2, (\"Bo\", 400)) ]" (List.nth lines 1)) );
    ( "a runtime error during a batch is reported and leaves the state usable",
      fun () ->
        let typed =
          infer
            "type line = { price : int; quantity : int }\ninput lines : collection line\nquery q = lines |> map (fun l -> l.price / l.quantity) |> sum\n"
        in
        let plan = Simplify.simplify (Graph.build (Anf.program (Specialize.program typed))) in
        let driver =
          {|
let () =
  let rows = [ (1, { price = 100; quantity = 2 }) ] in
  let state = Query.init rows in
  (match Query.apply_batch state [ Query.Replace (1, { price = 100; quantity = 0 }) ] with
   | Delta_runtime.Failure message -> print_endline ("failure: " ^ message)
   | Delta_runtime.Success _ -> print_endline "unexpected success");
  (match Query.apply_batch state [ Query.Insert (2, { price = 50; quantity = 5 }) ] with
   | Delta_runtime.Failure message -> print_endline ("failure: " ^ message)
   | Delta_runtime.Success (next, _) -> print_endline (Query.output_to_string (Query.result next)))
|}
        in
        (match run_generated "runtime_error" plan driver with
        | Error message -> fail "emitted program" message
        | Ok output ->
            let lines = List.filter (fun line -> line <> "") (String.split_on_char '\n' output) in
            check_equal_string "division by zero"
              "failure: division by zero while applying the batch" (List.nth lines 0);
            check_equal_string "state still usable" "60" (List.nth lines 1)) );
    ( "an integer query reports additive changes",
      fun () ->
        let plan = sample_plan "revenue.delta" in
        let driver =
          {|
let () =
  let rows = [ (1, { customer = "Ada"; total = 1000 }) ] in
  let state = Query.init rows in
  (match Query.apply_batch state [ Query.Insert (2, { customer = "Bo"; total = 250 }) ] with
   | Delta_runtime.Failure message -> print_endline ("failure: " ^ message)
   | Delta_runtime.Success (next, change) ->
       print_endline (Query.output_to_string (Query.result next));
       print_endline (Query.output_change_to_string change))
|}
        in
        (match run_generated "int_updates" plan driver with
        | Error message -> fail "emitted program" message
        | Ok output ->
            let lines = List.filter (fun line -> line <> "") (String.split_on_char '\n' output) in
            check_equal_string "result" "250" (List.nth lines 0);
            check_equal_string "additive change" "+50" (List.nth lines 1)) );
  ]