tai

defmodule Tai.Advisor do
  @moduledoc """
  A behavior for implementing a server that receives events such as market quotes.

  It can be used to receive one or more quote streams to record data and create, update or cancel orders.
  """

  defmodule State do
    @type group_id :: Tai.AdvisorGroup.id()
    @type id :: atom
    @type product :: Tai.Venues.Product.t()
    @type config :: struct | map
    @type run_store :: map
    @type t :: %State{
            group_id: group_id,
            advisor_id: id,
            products: [product],
            config: config,
            store: run_store,
            trades: list
          }

    @enforce_keys ~w[advisor_id config group_id products store trades]a
    defstruct ~w[advisor_id config group_id market_quotes products store trades]a
  end

  alias Tai.Markets.Quote

  @type group_id :: Tai.AdvisorGroup.id()
  @type id :: State.id()
  @type advisor_name :: atom
  @type event :: term
  @type run_store :: State.run_store()
  @type state :: State.t()
  @type advisor_spec :: Tai.Advisors.Spec.t()
  @type terminate_reason :: :normal | :shutdown | {:shutdown, term} | term

  @callback after_start(state) :: {:ok, run_store}
  @callback on_terminate(terminate_reason, state) :: term
  @callback handle_event(event, state) :: {:ok, run_store}

  @spec process_name(group_id, id) :: advisor_name
  def process_name(group_id, advisor_id), do: :"advisor_#{group_id}_#{advisor_id}"

  @spec child_spec(advisor_spec) :: Supervisor.child_spec()
  def child_spec(advisor_spec) do
    run_store = advisor_spec.run_store || %{}
    trades = advisor_spec.trades || []
    name = process_name(advisor_spec.group_id, advisor_spec.advisor_id)

    start_opts = [
      group_id: advisor_spec.group_id,
      advisor_id: advisor_spec.advisor_id,
      products: advisor_spec.products,
      config: advisor_spec.config,
      store: run_store,
      trades: trades
    ]

    %{
      id: name,
      start: {advisor_spec.mod, :start_link, [start_opts]},
      restart: advisor_spec.restart,
      shutdown: advisor_spec.shutdown,
      type: :worker
    }
  end

  defmacro __using__(_) do
    quote location: :keep do
      use GenServer

      @behaviour Tai.Advisor

      def start_link(
            group_id: group_id,
            advisor_id: advisor_id,
            products: products,
            config: config,
            store: store,
            trades: trades
          ) do
        name = Tai.Advisor.process_name(group_id, advisor_id)
        market_quotes = %Tai.Advisors.MarketQuotes{data: %{}}

        state = %State{
          group_id: group_id,
          advisor_id: advisor_id,
          products: products,
          market_quotes: market_quotes,
          config: config,
          store: store,
          trades: trades
        }

        GenServer.start_link(__MODULE__, state, name: name)
      end

      @impl true
      def init(state) do
        Process.flag(:trap_exit, true)
        {:ok, state, {:continue, :started}}
      end

      @impl true
      def terminate(reason, state) do
        on_terminate(reason, state)
      end

      @impl true
      def handle_info({:market_quote_store, :after_put, %Quote{} = event}, state) do
        key = {event.venue_id, event.product_symbol}
        new_data = Map.put(state.market_quotes.data, key, event)
        new_market_quotes = Map.put(state.market_quotes, :data, new_data)
        new_state = Map.put(state, :market_quotes, new_market_quotes)

        {
          :noreply,
          new_state,
          {:continue, {:execute_event, event}}
        }
      end

      @impl true
      def handle_continue(:started, state) do
        {:ok, new_run_store} = after_start(state)
        new_state = Map.put(state, :store, new_run_store)

        state.products
        |> Enum.each(&Tai.SystemBus.subscribe({:market_quote_store, {&1.venue_id, &1.symbol}}))

        {:noreply, new_state}
      end

      @impl true
      def handle_continue({:execute_event, event}, state) do
        new_state =
          try do
            with {:ok, new_store} <- handle_event(event, state) do
              Map.put(state, :store, new_store)
            else
              unhandled ->
                %Tai.Events.AdvisorHandleEventInvalidReturn{
                  advisor_id: state.advisor_id,
                  group_id: state.group_id,
                  event: event,
                  return_value: unhandled
                }
                |> TaiEvents.warn()

                state
            end
          rescue
            e ->
              %Tai.Events.AdvisorHandleEventError{
                advisor_id: state.advisor_id,
                group_id: state.group_id,
                event: event,
                error: e,
                stacktrace: __STACKTRACE__
              }
              |> TaiEvents.warn()

              state
          end

        {:noreply, new_state}
      end

      @impl true
      def after_start(state), do: {:ok, state.store}

      @impl true
      def on_terminate(_, _), do: :ok

      @impl true
      def handle_event(_, state), do: {:ok, state.store}

      defoverridable after_start: 1, on_terminate: 2, handle_event: 2
    end
  end
end