module type TRANSPORT = sig
  include Configuration.CONFIGURABLE

  type t
  type connection

  val create : configuration -> t
  val listen : t -> unit
  val accept : t -> connection
  val input : connection -> in_channel
  val output : connection -> out_channel
end

module TCP : TRANSPORT = struct
  type configuration = {address_family: Unix.socket_domain; sockaddr: Unix.sockaddr}
  type t = Unix.file_descr
  type connection = Unix.file_descr

  module Error = struct
    open Condition

    (* TODO: more structure *)
    let parse_error msg = condition "parse-error" msg empty
  end

  let sockaddr_of_fields = function
    | `Inet (addr, port) ->
        Ok
          { address_family= Unix.PF_INET;
            sockaddr= Unix.ADDR_INET (Unix.inet_addr_of_string addr, port) }
    | `Unix path -> Ok {address_family= Unix.PF_UNIX; sockaddr= Unix.ADDR_UNIX path}

  let parse sexp =
    let open Sexplib.Sexp in
    let errorf fmt = Printf.ksprintf (fun s -> Error s) fmt in
    let rec go addr port path = function
      | [] -> (
        match addr, port, path with
        | Some a, Some p, None -> sockaddr_of_fields (`Inet (a, p))
        | None, None, Some s -> sockaddr_of_fields (`Unix s)
        | None, None, None -> errorf "transport/tcp: no address fields"
        | _ -> errorf "transport/tcp: use (address + port) or (path), not both" )
      | List [Atom "address"; Atom a] :: rest -> go (Some a) port path rest
      | List [Atom "port"; Atom p] :: rest -> (
        match int_of_string_opt p with
        | Some n -> go addr (Some n) path rest
        | None -> errorf "transport/tcp: invalid port: %s" p )
      | List [Atom "path"; Atom p] :: rest -> go addr port (Some p) rest
      | bad :: _ -> errorf "transport/tcp: unexpected: %s" (to_string bad)
    in
    match sexp with
    | List children -> go None None None children |> Result.map_error Error.parse_error
    | _ -> Error (Error.parse_error "transport/tcp: expected a list of fields")

  let string_of_sockaddr = function
    | Unix.ADDR_INET (host, port) -> Printf.sprintf "%s:%d" (Unix.string_of_inet_addr host) port
    | Unix.ADDR_UNIX path -> path

  let create {address_family; sockaddr} =
    let socket = Unix.socket address_family Unix.SOCK_STREAM 0 in
    Unix.setsockopt socket Unix.SO_REUSEADDR true;
    Unix.bind socket sockaddr;
    socket

  let listen fd =
    Unix.listen fd 5;
    Printf.printf "Listening on %s\n%!" (string_of_sockaddr (Unix.getsockname fd))

  let accept fd =
    let conn, _ = Unix.accept fd in
    conn

  let input = Unix.in_channel_of_descr
  let output = Unix.out_channel_of_descr
end