module Path = ImportDataTypes.Path
open Test_migration

let result_testable =
  Alcotest.result Test_migration.expression_testable Alcotest.string

(** Helper used to test the equality between the litteral expression and it’s
    AST *)
let test : string -> Path.t ImportExpression.T.t -> unit =
 fun expr result ->
  let expression = ImportConf.expression_from_string expr in
  Alcotest.check result_testable "" (Ok result) expression

let path_column =
  "column as path" >:: fun () ->
  test ":A" (Path { Path.alias = None; column = 1 })

let path_table =
  "path with table" >:: fun () ->
  test ":table.A" (Path { Path.alias = Some "table"; column = 1 })

let path_subtable =
  "path with table" >:: fun () ->
  test ":table.Name.A" (Path { Path.alias = Some "table.Name"; column = 1 })

let parse_dquoted =
  "parse_dquoted" >:: fun _ ->
  test "match(\"\\(..\\)\", :B)"
    (Function
       ("match", [ Literal "\\(..\\)"; Path { alias = None; column = 2 } ]))

let parse_quoted =
  "parse_quoted" >:: fun _ ->
  test "match('\\(..\\)', :B)"
    (Function
       ("match", [ Literal "\\(..\\)"; Path { alias = None; column = 2 } ]))

let concat =
  "concat" >:: fun _ ->
  test ":A ^ :B"
    (Concat
       [ Path { alias = None; column = 1 }; Path { alias = None; column = 2 } ])

let concat2 =
  "concat2" >:: fun _ ->
  test "'A' ^ '_' ^ 'B'" (Concat [ Literal "A"; Literal "_"; Literal "B" ])

let litteral =
  "litteral" >:: fun _ ->
  (* The text is quoted in shall not be considered as a path *)
  test "':A'" (Literal ":A")

let empty = "empty" >:: fun _ -> test "" Empty

let upper_nvl =
  "upper_nvl" >:: fun _ -> test "NVL('','')" (Nvl [ Empty; Empty ])

let lower_nvl =
  "lower_nvl" >:: fun _ -> test "nvl('','')" (Nvl [ Empty; Empty ])

let numeric = "numeric" >:: fun _ -> test "123" (Integer "123")
let numeric_neg = "numeric_neg" >:: fun _ -> test "-123" (Integer "-123")

let op_priority =
  "operator_priority" >:: fun _ ->
  test "1 + 2 > 2"
    (BOperator (GT, BOperator (Add, Integer "1", Integer "2"), Integer "2"))

let op_priority2 =
  "operator_priority" >:: fun _ ->
  test "1 ^ 2 = 2"
    (BOperator (Equal, Concat [ Integer "1"; Integer "2" ], Integer "2"))

let join =
  "join" >:: fun _ ->
  let expr = "join('sep', :A, :B)" in
  let result = ImportConf.expression_from_string expr in
  Alcotest.check result_testable ""
    (Ok
       (Join
          ( "sep",
            [
              Path { alias = None; column = 1 };
              Path { alias = None; column = 2 };
            ] )))
    result

let join_empty =
  "join" >:: fun _ ->
  test "join('', :A, :B)"
    (Join
       ( "",
         [
           Path { alias = None; column = 1 }; Path { alias = None; column = 2 };
         ] ))

let upper = "upper" >:: fun _ -> test "upper('')" (Function' (Upper, [ Empty ]))
let trim = "trim" >:: fun _ -> test "trim('')" (Function' (Trim, [ Empty ]))

(** Extract the columns from a window function *)
let fold_values =
  "fold_values" >:: fun _ ->
  let open Path in
  (* The expression we want to test *)
  let expr =
    ImportExpression.T.Window
      ( Previous (Path { alias = None; column = 1 }),
        [ Path { alias = None; column = 2 } ],
        [ Path { alias = None; column = 3 } ] )
  in

  let result =
    ImportExpression.T.fold_values ~init:[] ~f:(fun acc v -> v :: acc) expr
    |> List.rev
  in

  let expected =
    [
      { alias = None; column = 1 };
      { alias = None; column = 2 };
      { alias = None; column = 3 };
    ]
  in

  Alcotest.check
    (Alcotest.list @@ Test_migration.make_test (module Path))
    "" expected result

let bad_quote =
  "bad_quote" >:: fun _ ->
  let expr = "':source.A" in
  let result = ImportConf.expression_from_string expr in

  Alcotest.check result_testable ""
    (Error "Unclosed quote at line 1 : \"':source.A\"") result

let nested_expression =
  "nested_expression" >:: fun _ ->
  test "1 = (1 = 0)"
    (BOperator
       (Equal, Integer "1", Expr (BOperator (Equal, Integer "1", Integer "0"))))

let priority_equality =
  "priority_equality" >:: fun _ ->
  test "1 = 1 = 0"
    (BOperator (Equal, Integer "1", BOperator (Equal, Integer "1", Integer "0")))

let priority_operator_and =
  "priority_equality" >:: fun _ ->
  test "1 and 1 = 0"
    (BOperator (And, Integer "1", BOperator (Equal, Integer "1", Integer "0")))

let priority_operator_or =
  "priority_equality" >:: fun _ ->
  test "1 <> 1 or 0"
    (BOperator (Or, BOperator (Different, Integer "1", Integer "1"), Integer "0"))

let unknown_function =
  "unknown function" >:: fun _ ->
  let expr = "function()" in
  let result = ImportConf.expression_from_string expr in

  Alcotest.check result_testable ""
    (Error "Unknown function or wrong number of arguments for 'function'")
    result

let wrong_arguments =
  "unknown function" >:: fun _ ->
  let expr = "if()" in
  let result = ImportConf.expression_from_string expr in

  Alcotest.check result_testable ""
    (Error "Unknown function or wrong number of arguments for 'if'") result

let test_suit =
  [
    path_column;
    path_table;
    path_subtable;
    parse_dquoted;
    parse_quoted;
    concat;
    concat2;
    litteral;
    empty;
    upper_nvl;
    lower_nvl;
    numeric;
    numeric_neg;
    op_priority;
    op_priority2;
    join;
    upper;
    trim;
    join_empty;
    fold_values;
    bad_quote;
    nested_expression;
    priority_equality;
    priority_operator_and;
    priority_operator_or;
    unknown_function;
    wrong_arguments;
  ]

let tests = "configuration_expression" >::: test_suit