defmodule CLWiFi.AuthRouter do
  use Plug.Router
  require Logger
  alias CLWiFi.Session

  plug :set_session_name
  plug :ensure_session_is_running
  plug :respond_to_request_type
  plug :respond_with_cloudtrax_response



  match(_) do
    ExWeb.Errors.render(conn, 404)
  end

  def set_session_name(%{private: %{development_mode: true}} = conn, _) do
    conn
    |> Plug.Conn.put_private(:connection, CLWiFi.Development.default_session_name())
  end

  def set_session_name(%{query_params: %{"connection" => session_name}} = conn, _) do
    conn
    |> Plug.Conn.put_private(:connection, session_name)
  end

  def set_session_name(%{params: %{"location_id" => location_id, "mac" => mac_address}} = conn, _) do
    session_name = Session.generate_session_name(location_id, mac_address)
    conn
    |> Plug.Conn.put_private(:connection, session_name)
  end

  def ensure_session_is_running(%{private: %{connection: session_name, development_mode: true}} = conn, _opts) do
    case Session.start(session_name) do
      :ok -> conn
      :error ->
        Logger.error "Failed to connect to a session"
        ExWeb.Errors.render(conn, 404)
    end
  end

  def ensure_session_is_running(%{private: %{connection: session_name}, params: %{"type" => "status"}} = conn, _opts) do
    case Session.start(session_name) do
      :ok -> conn
      :error ->
        Logger.error "Failed to connect to a session"
        ExWeb.Errors.render(conn, 404)
    end
  end

  def ensure_session_is_running(%{private: %{connection: session_name}} = conn, _opts) do
    case Session.ensure_running(session_name) do
      :ok -> conn
      :error -> ExWeb.Errors.render(conn, 404)
    end
  end


  @doc """
  Determines that the request is a `status` request
  """
  def respond_to_request_type(%{params: %{"type" => "status"}} = conn, _opts) do
    conn
    |> assign(:cloudtrax_response, :reject)
  end

  @doc """
  Determines that the request is a `accounting` request
  """
  def respond_to_request_type(%{params: %{"type" => "acct"}} = conn, _opts) do
    conn
    |> assign(:cloudtrax_response, :ok)
  end

  @doc """
  Determines that the request is a `login` request
  """
  def respond_to_request_type(%{private: %{connection: session_name}, params: %{"type" => "login"}} = conn, _opts) do
    CLWiFi.Session.connect(session_name)
    conn
    |> assign(:cloudtrax_response, :accept)
  end

  @doc """
  """
  def respond_to_request_type(conn, _opts) do
    conn
    |> assign(:cloudtrax_response, :reject)
  end

  def respond_with_cloudtrax_response(%{params: %{"ra" => ra}, assigns: %{cloudtrax_response: :accept}} = conn, _) do
    conn
    |> respond_with_text(CLWiFi.Cloudtrax.Responses.accept(ra))
  end

  def respond_with_cloudtrax_response(%{params: %{"ra" => ra}, assigns: %{cloudtrax_response: :reject}} = conn, _) do
    conn
    |> respond_with_text(CLWiFi.Cloudtrax.Responses.reject(ra))
  end

  def respond_with_cloudtrax_response(%{params: %{"ra" => ra}, assigns: %{cloudtrax_response: :ok}} = conn, _) do
    conn
    |> respond_with_text(CLWiFi.Cloudtrax.Responses.ok(ra))
  end

  def respond_with_cloudtrax_response(%{private: %{development_mode: true}} = conn, _) do
    ra = "ADCE0D4815B348A3C08B57E34D4B8BB4"
    conn
    |> respond_with_text(CLWiFi.Cloudtrax.Responses.reject(ra))
  end



  defp respond_with_text(conn, text) do
    conn
    |> put_resp_content_type("text/plain")
    |> send_resp(200, text)
    |> halt
  end
end