defmodule Exkad.Backends.HTTP.Server do

  defmodule Server do

    alias Exkad.Backends.Simple
    use Plug.Router
    import Plug.Conn
    alias Exkad.Node.Descriptor, as: ND
    require Logger

    plug :match
    plug :dispatch

    def json({:ok, res}) do
      json(%{"ok" => res})
    end

    def json({:value, {:ok, key}}) do
      json(%{"value" => %{"ok" => key}})
    end
    

    def json(res) do
      Poison.encode!(res)
    end



    def finish(res, conn, status \\ 200) do
      conn
        |> put_resp_content_type("application/json")
        |> send_resp(status, res)
    end

    def to_desc(conn) do
      d = Enum.into(conn.req_headers, %{})
      %ND{id: d["fromid"], loc: d["fromloc"]}
    end

    get "/ping" do
      %{node: node} = conn.plug_options
      Logger.debug "PING #{node}"
      Simple.ping(node, to_desc(conn)) 
        |> json
        |> finish(conn)
    end

    get "/find/:node_id" do
      %{node: node} = conn.plug_options
      [_, to_find_id] = conn.path_info
      from_desc = to_desc(conn)
      Logger.debug "FIND id #{to_find_id} from #{node}"
      Simple.find(node, to_find_id, from_desc)
        |> json
        |> finish(conn)
    end


    put "/item" do
      %{node: node} = conn.plug_options
      {:ok, body, conn} = read_body(conn)
      Logger.debug "PUT item to #{node}"
      Simple.put(node, body)
        |> json
        |> finish(conn)
    end


    get "/item/:key" do
      %{node: node} = conn.plug_options
      [_, key] = conn.path_info
      Logger.debug "GET #{key} from #{node}"
      Simple.get(node, key)
        |> json
        |> finish(conn)
    end

    put "/item/:ptr/meta" do
      %{node: node} = conn.plug_options
      [_, ptr, _] = conn.path_info
      {:ok, term, conn} = read_body(conn)
      Logger.debug "PUT_META #{term} --> #{ptr} in #{node}"
      Simple.put_meta(node, term, ptr)
        |> json
        |> finish(conn)
    end

    get "/search/:key" do
      %{node: node} = conn.plug_options
      [_, key] = conn.path_info
      Logger.debug "SEARCH for #{key} on #{node}"
      Simple.search(node, key)
        |> json
        |> finish(conn)
    end

    match _ do
      path = Enum.join(conn.path_info, "/")
      Logger.debug "Unknown endpoint #{path}"
      %{"exkad" => "unknown endpoint"}
        |> json
        |> finish(conn)
    end

  end


  import Plug.Conn


  def init(options) do
    Enum.into(options, %{})
  end

  def call(conn, options) do
    Map.put(conn, :plug_options, options) |> Server.call(options)
  end

end