(* Test runner for json_pointer *)

let read_file path =
  let ic = open_in path in
  let n = in_channel_length ic in
  let s = really_input_string ic n in
  close_in ic;
  s

let parse_json s =
  match Jsont_bytesrw.decode_string Jsont.json s with
  | Ok json -> json
  | Error e -> failwith e

let json_to_string json =
  match Jsont_bytesrw.encode_string Jsont.json json with
  | Ok s -> s
  | Error e -> failwith e

(* Helper to get indices from any pointer *)
let indices_of_any (Json_pointer.Any p) = Json_pointer.indices p

(* Helper to convert to string from any pointer *)
let to_string_of_any (Json_pointer.Any p) = Json_pointer.to_string p

(* Helper to check if pointer is append *)
let is_append_any (Json_pointer.Any p : Json_pointer.any) =
  not (Json_pointer.is_nav (Json_pointer.Any p))

(* Test: parse pointer and print indices *)
let test_parse pointer_str =
  try
    let result = Json_pointer.of_string pointer_str in
    let indices = indices_of_any result in
    let index_strs = List.map (fun idx ->
      match idx with
      | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
      | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
    ) indices in
    let suffix = if is_append_any result then ", /-" else "" in
    Printf.printf "OK: [%s%s]\n" (String.concat ", " index_strs) suffix
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: roundtrip pointer string *)
let test_roundtrip pointer_str =
  try
    let result = Json_pointer.of_string pointer_str in
    let s = to_string_of_any result in
    if s = pointer_str then
      Printf.printf "OK: %s\n" s
    else
      Printf.printf "MISMATCH: input=%s output=%s\n" pointer_str s
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: evaluate pointer against JSON *)
let test_eval json_path pointer_str =
  try
    let json = parse_json (read_file json_path) in
    let p = Json_pointer.of_string_nav pointer_str in
    let result = Json_pointer.get p json in
    Printf.printf "OK: %s\n" (json_to_string result)
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: escape token *)
let test_escape token =
  let escaped = Json_pointer.Token.escape token in
  Printf.printf "%s\n" escaped

(* Test: unescape token *)
let test_unescape token =
  try
    let unescaped = Json_pointer.Token.unescape token in
    Printf.printf "OK: %s\n" unescaped
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: URI fragment roundtrip *)
let test_uri_fragment pointer_str =
  try
    let result = Json_pointer.of_string pointer_str in
    let (Json_pointer.Any p) = result in
    let frag = Json_pointer.to_uri_fragment p in
    let result2 = Json_pointer.of_uri_fragment frag in
    let s2 = to_string_of_any result2 in
    if s2 = pointer_str then
      Printf.printf "OK: %s -> %s\n" pointer_str frag
    else
      Printf.printf "MISMATCH: %s -> %s -> %s\n" pointer_str frag s2
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: add operation *)
let test_add json_str pointer_str value_str =
  try
    let json = parse_json json_str in
    let value = parse_json value_str in
    let p = Json_pointer.of_string pointer_str in
    let result = Json_pointer.add p json ~value in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: remove operation *)
let test_remove json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let result = Json_pointer.remove p json in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: replace operation *)
let test_replace json_str pointer_str value_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let value = parse_json value_str in
    let result = Json_pointer.replace p json ~value in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: move operation *)
let test_move json_str from_str path_str =
  try
    let json = parse_json json_str in
    let from = Json_pointer.of_string_nav from_str in
    let path = Json_pointer.of_string path_str in
    let result = Json_pointer.move ~from ~path json in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: copy operation *)
let test_copy json_str from_str path_str =
  try
    let json = parse_json json_str in
    let from = Json_pointer.of_string_nav from_str in
    let path = Json_pointer.of_string path_str in
    let result = Json_pointer.copy ~from ~path json in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: test operation *)
let test_test json_str pointer_str expected_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let expected = parse_json expected_str in
    let result = Json_pointer.test p json ~expected in
    Printf.printf "%b\n" result
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: has operation (checks if pointer exists) *)
let test_has json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let result = Json_pointer.find p json in
    Printf.printf "%b\n" (Option.is_some result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

let () =
  match Array.to_list Sys.argv with
  | _ :: "parse" :: pointer :: _ ->
    test_parse pointer
  | _ :: "roundtrip" :: pointer :: _ ->
    test_roundtrip pointer
  | _ :: "eval" :: json_path :: pointer :: _ ->
    test_eval json_path pointer
  | _ :: "escape" :: token :: _ ->
    test_escape token
  | _ :: "unescape" :: token :: _ ->
    test_unescape token
  | _ :: "uri-fragment" :: pointer :: _ ->
    test_uri_fragment pointer
  | _ :: "add" :: json :: pointer :: value :: _ ->
    test_add json pointer value
  | _ :: "remove" :: json :: pointer :: _ ->
    test_remove json pointer
  | _ :: "replace" :: json :: pointer :: value :: _ ->
    test_replace json pointer value
  | _ :: "move" :: json :: from :: path :: _ ->
    test_move json from path
  | _ :: "copy" :: json :: from :: path :: _ ->
    test_copy json from path
  | _ :: "test" :: json :: pointer :: expected :: _ ->
    test_test json pointer expected
  | _ :: "has" :: json :: pointer :: _ ->
    test_has json pointer
  | _ ->
    Printf.printf "Usage:\n";
    Printf.printf "  test_pointer parse <pointer>\n";
    Printf.printf "  test_pointer roundtrip <pointer>\n";
    Printf.printf "  test_pointer eval <json-file> <pointer>\n";
    Printf.printf "  test_pointer escape <token>\n";
    Printf.printf "  test_pointer unescape <token>\n";
    Printf.printf "  test_pointer uri-fragment <pointer>\n";
    Printf.printf "  test_pointer add <json> <pointer> <value>\n";
    Printf.printf "  test_pointer remove <json> <pointer>\n";
    Printf.printf "  test_pointer replace <json> <pointer> <value>\n";
    Printf.printf "  test_pointer move <json> <from> <path>\n";
    Printf.printf "  test_pointer copy <json> <from> <path>\n";
    Printf.printf "  test_pointer test <json> <pointer> <expected>\n";
    Printf.printf "  test_pointer has <json> <pointer>\n";
    exit 1