(*---------------------------------------------------------------------------
  Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.
  SPDX-License-Identifier: ISC
 ---------------------------------------------------------------------------*)

(** Tests for Http_version module *)

module Http_version = Requests.Http_version

(** {1 to_string Tests} *)

let test_to_string_http10 () =
  let s = Http_version.to_string Http_version.Http_1_0 in
  Alcotest.(check string) "HTTP/1.0" "HTTP/1.0" s

let test_to_string_http11 () =
  let s = Http_version.to_string Http_version.Http_1_1 in
  Alcotest.(check string) "HTTP/1.1" "HTTP/1.1" s

let test_to_string_http_2 () =
  let s = Http_version.to_string Http_version.Http_2 in
  Alcotest.(check string) "HTTP/2" "HTTP/2" s

(** {1 equal Tests} *)

let test_equal_same () =
  Alcotest.(check bool)
    "equal same" true
    (Http_version.equal Http_version.Http_1_1 Http_version.Http_1_1)

let test_equal_different () =
  Alcotest.(check bool)
    "equal different" false
    (Http_version.equal Http_version.Http_1_1 Http_version.Http_2)

let test_equal_http_versions () =
  Alcotest.(check bool)
    "1.0 != 1.1" false
    (Http_version.equal Http_version.Http_1_0 Http_version.Http_1_1)

(** {1 compare Tests} *)

let test_compare_order () =
  Alcotest.(check bool)
    "1.0 < 1.1" true
    (Http_version.compare Http_version.Http_1_0 Http_version.Http_1_1 < 0);
  Alcotest.(check bool)
    "1.1 < 2" true
    (Http_version.compare Http_version.Http_1_1 Http_version.Http_2 < 0);
  Alcotest.(check bool)
    "2 > 1.0" true
    (Http_version.compare Http_version.Http_2 Http_version.Http_1_0 > 0)

(** {1 supports_multiplexing Tests} *)

let test_multiplexing_http2 () =
  Alcotest.(check bool)
    "HTTP/2 supports multiplexing" true
    (Http_version.supports_multiplexing Http_version.Http_2)

let test_multiplexing_http11 () =
  Alcotest.(check bool)
    "HTTP/1.1 no multiplexing" false
    (Http_version.supports_multiplexing Http_version.Http_1_1)

let test_multiplexing_http10 () =
  Alcotest.(check bool)
    "HTTP/1.0 no multiplexing" false
    (Http_version.supports_multiplexing Http_version.Http_1_0)

(** {1 supports_header_compression Tests} *)

let test_header_compression_http2 () =
  Alcotest.(check bool)
    "HTTP/2 supports header compression" true
    (Http_version.supports_header_compression Http_version.Http_2)

let test_header_compression_http11 () =
  Alcotest.(check bool)
    "HTTP/1.1 no header compression" false
    (Http_version.supports_header_compression Http_version.Http_1_1)

let test_header_compression_http10 () =
  Alcotest.(check bool)
    "HTTP/1.0 no header compression" false
    (Http_version.supports_header_compression Http_version.Http_1_0)

(** {1 supports_server_push Tests} *)

let test_server_push_http2 () =
  Alcotest.(check bool)
    "HTTP/2 supports server push" true
    (Http_version.supports_server_push Http_version.Http_2)

let test_server_push_http11 () =
  Alcotest.(check bool)
    "HTTP/1.1 no server push" false
    (Http_version.supports_server_push Http_version.Http_1_1)

(** {1 ALPN Tests} *)

let test_alpn_of_version_h2 () =
  let alpn = Http_version.alpn_of_version Http_version.Http_2 in
  Alcotest.(check (option string)) "HTTP/2 ALPN" (Some "h2") alpn

let test_alpn_of_version_http11 () =
  let alpn = Http_version.alpn_of_version Http_version.Http_1_1 in
  Alcotest.(check (option string)) "HTTP/1.1 ALPN" (Some "http/1.1") alpn

let test_alpn_of_version_http10 () =
  let alpn = Http_version.alpn_of_version Http_version.Http_1_0 in
  Alcotest.(check (option string)) "HTTP/1.0 no ALPN" None alpn

let test_version_of_alpn_h2 () =
  let v = Http_version.version_of_alpn "h2" in
  match v with
  | Some Http_version.Http_2 -> Alcotest.(check pass) "h2 -> Http_2" () ()
  | _ -> Alcotest.fail "Expected Some Http_2"

let test_version_of_alpn_http11 () =
  let v = Http_version.version_of_alpn "http/1.1" in
  match v with
  | Some Http_version.Http_1_1 ->
      Alcotest.(check pass) "http/1.1 -> Http_1_1" () ()
  | _ -> Alcotest.fail "Expected Some Http_1_1"

let test_version_of_alpn_unknown () =
  let v = Http_version.version_of_alpn "unknown" in
  Alcotest.(check bool) "unknown ALPN" true (Option.is_none v)

let test_alpn_protocols_preferred () =
  let protocols =
    Http_version.alpn_protocols
      ~preferred:[ Http_version.Http_2; Http_version.Http_1_1 ]
  in
  Alcotest.(check (list string))
    "preferred order" [ "h2"; "http/1.1" ] protocols

let test_alpn_protocols_single () =
  let protocols =
    Http_version.alpn_protocols ~preferred:[ Http_version.Http_1_1 ]
  in
  Alcotest.(check (list string)) "single" [ "http/1.1" ] protocols

let test_alpn_filters_http10 () =
  let protocols =
    Http_version.alpn_protocols
      ~preferred:
        [ Http_version.Http_2; Http_version.Http_1_1; Http_version.Http_1_0 ]
  in
  Alcotest.(check (list string)) "filters 1.0" [ "h2"; "http/1.1" ] protocols

(** {1 ALPN Constants Tests} *)

let test_alpn_h2_constant () =
  Alcotest.(check string) "alpn_h2" "h2" Http_version.alpn_h2

let test_alpn_http11_constant () =
  Alcotest.(check string) "alpn_http_1_1" "http/1.1" Http_version.alpn_http_1_1

(** {1 Test Suite} *)

let suite =
  ( "http_version",
    [
      Alcotest.test_case "HTTP/1.0" `Quick test_to_string_http10;
      Alcotest.test_case "HTTP/1.1" `Quick test_to_string_http11;
      Alcotest.test_case "HTTP/2" `Quick test_to_string_http_2;
      Alcotest.test_case "same" `Quick test_equal_same;
      Alcotest.test_case "different" `Quick test_equal_different;
      Alcotest.test_case "1.0 vs 1.1" `Quick test_equal_http_versions;
      Alcotest.test_case "ordering" `Quick test_compare_order;
      Alcotest.test_case "HTTP/2" `Quick test_multiplexing_http2;
      Alcotest.test_case "HTTP/1.1" `Quick test_multiplexing_http11;
      Alcotest.test_case "HTTP/1.0" `Quick test_multiplexing_http10;
      Alcotest.test_case "HTTP/2" `Quick test_header_compression_http2;
      Alcotest.test_case "HTTP/1.1" `Quick test_header_compression_http11;
      Alcotest.test_case "HTTP/1.0" `Quick test_header_compression_http10;
      Alcotest.test_case "HTTP/2" `Quick test_server_push_http2;
      Alcotest.test_case "HTTP/1.1" `Quick test_server_push_http11;
      Alcotest.test_case "HTTP/2 -> h2" `Quick test_alpn_of_version_h2;
      Alcotest.test_case "HTTP/1.1 -> http/1.1" `Quick
        test_alpn_of_version_http11;
      Alcotest.test_case "HTTP/1.0 -> None" `Quick test_alpn_of_version_http10;
      Alcotest.test_case "h2 -> HTTP/2" `Quick test_version_of_alpn_h2;
      Alcotest.test_case "http/1.1 -> HTTP/1.1" `Quick
        test_version_of_alpn_http11;
      Alcotest.test_case "unknown -> None" `Quick test_version_of_alpn_unknown;
      Alcotest.test_case "preferred order" `Quick test_alpn_protocols_preferred;
      Alcotest.test_case "single" `Quick test_alpn_protocols_single;
      Alcotest.test_case "filters HTTP/1.0" `Quick test_alpn_filters_http10;
      Alcotest.test_case "h2" `Quick test_alpn_h2_constant;
      Alcotest.test_case "http/1.1" `Quick test_alpn_http11_constant;
    ] )