defmodule RlRepo.ClientHandler do
  require Logger
  @moduledoc """
  """

  def process_request(client_socket) do
    Logger.info("Processing client request.")

    client_socket
      |> read_request
      |> create_response()
      |> create_response_header()
      |> write_response(client_socket)

  end

  def read_request(client_socket) do
    Logger.info("Reading request.")
    {:ok, request} = :gen_tcp.recv(client_socket, 0)
    Logger.info("Request recieved.")
    request
  end

  def create_response(request) do
    Logger.info("Building body.")

    # NOTE: Reliability testing.
    if String.match?(request, ~r{GET /error}) do
      raise(request)
    end

    # TODO: Handle routing here.
    a = String.split(request, "\n\r");
    Logger.info a
    [get_line | rest] = a

    b = String.split(get_line, " ");
    [request_type | rest] = b
    [path | rest] = rest
    Logger.info "#{request_type} #{path}"

    # Parse path
    split_path = String.split(path, "/");
    # Ignore the first slash.
    [_ | rest ] = split_path

    split_path_length = length(rest)
    Logger.info split_path_length

    ret = case split_path_length do
      3 ->
        RlRepo.Router.parse_3_segment_path(rest)
          |> RlRepo.Router.route_3(request_type)
      4 ->
        RlRepo.Router.parse_4_segment_path(rest)
          |> RlRepo.Router.route_4(request_type)
    end

  end


  def create_return_code_string(return_code) do
    case return_code do
      200 -> "200 OK"
      404 -> "404 Not Found"
    end
  end

  def create_response_header(body) do
    {return_code, content_type, body} = body

    """
    HTTP/1.1 #{create_return_code_string(return_code)}\r
    Content-Type: #{content_type}\r
    Content-Length: #{byte_size(body)}\r
    \r
    #{body}
    """
  end


  def write_response(response, client_socket) do
    :ok = :gen_tcp.send(client_socket, response)

    # Logger.info("Response:\n\n#{response}")

    :gen_tcp.close(client_socket)
  end
end