defmodule Extreme.System.AggregatePidFacade do
  use     GenServer
  require Logger
  alias   Extreme.System.{EventStore, AggregateSup}
  alias   Extreme.System.AggregateRegistry, as: Registry

  def name(aggregate_mod), do: "#{aggregate_mod}.PidFacade" |> String.to_atom

  ## Client API

  def start_link(prefix, aggregate_mod), 
    do: GenServer.start_link(__MODULE__, {prefix, aggregate_mod}, name: name(aggregate_mod))

  def get_pid(server, key),
    do: GenServer.call(server, {:get_pid, key})

  def spawn_new(server, key),
    do: GenServer.call(server, {:spawn_new, key})

  def exit_process(server, key, reason),
    do: GenServer.cast(server, {:exit_process, key, reason})


  def init({prefix, aggregate_mod}) do
    state = %{
      event_store:   EventStore.name(prefix),
      registry:      Registry.name(aggregate_mod),
      aggregate_sup: AggregateSup.name(aggregate_mod),
      aggregate_mod: aggregate_mod
    }
    {:ok, state}
  end

  def handle_call({:spawn_new, key}, _from, state) do
    {:ok, pid} = AggregateSup.start_child state.aggregate_sup
    response = case Registry.register(state.registry, key, pid) do
      :ok   -> {:ok, pid}
      other -> other
    end
    {:reply, response, state}
  end

  def handle_call({:get_pid, key}, _from, state),
    do: {:reply, _get_pid(key, state), state}


  def handle_cast({:exit_process, key, reason}, state) do
    case Registry.get(state.registry, key) do
      {:ok, pid} -> Process.exit pid, reason
      _          -> :ok
    end
    {:noreply, state}
  end


  defp _get_pid(key, state) do
    case Registry.get(state.registry, key) do
      :error     -> _get_from_es(state.event_store, state.aggregate_sup, state.registry, state.aggregate_mod, key)
      {:ok, pid} -> {:ok, pid}
    end
  end

  defp _get_from_es(event_store, aggregate_sup, registry, aggregate_mod, key) do
    case EventStore.has?(event_store, aggregate_mod, key) do
      true ->
        events = EventStore.stream_events event_store, {aggregate_mod, key}
        Logger.debug "Applying events for existing aggregate #{key}"
        {:ok, pid} = AggregateSup.start_child aggregate_sup
        :ok        = aggregate_mod.apply pid, events
        :ok        = Registry.register registry, key, pid
        {:ok, pid}
      false ->
        Logger.warn "No events found for carrier lane: #{key}"
        {:error, :not_found}
    end
  end
end