Elixir OTP에서 순수함수로 상태머신 구현하기

defmodule Payments.FSM do
  @type status :: :idle | :authorizing | :authorized | :failed

  @type state :: %{
          status: status,
          order_id: String.t() | nil,
          amount: non_neg_integer() | nil,
          auth_id: String.t() | nil,
          error: term() | nil
        }

  @type event ::
          {:start, String.t(), non_neg_integer()}
          | {:gateway_ok, String.t()}
          | {:gateway_fail, term()}
          | :timeout

  @type effect ::
          {:call_gateway, String.t(), non_neg_integer()}
          | {:set_timer, non_neg_integer(), :timeout}
          | {:emit_metric, String.t(), map()}

  @spec new() :: state
  def new do
    %{status: :idle, order_id: nil, amount: nil, auth_id: nil, error: nil}
  end

  @spec transition(state, event) ::
          {:ok, state, [effect]} | {:error, term(), state, [effect]}
  def transition(state, event)

  def transition(%{status: :idle} = state, {:start, order_id, amount}) do
    new_state = %{state | status: :authorizing, order_id: order_id, amount: amount}

    effects = [
      {:emit_metric, "payment_start", %{order_id: order_id}},
      {:call_gateway, order_id, amount},
      {:set_timer, 5_000, :timeout}
    ]

    {:ok, new_state, effects}
  end

  def transition(%{status: :authorizing} = state, {:gateway_ok, auth_id}) do
    new_state = %{state | status: :authorized, auth_id: auth_id, error: nil}

    effects = [
      {:emit_metric, "payment_authorized", %{order_id: state.order_id}}
    ]

    {:ok, new_state, effects}
  end

  def transition(%{status: :authorizing} = state, {:gateway_fail, reason}) do
    new_state = %{state | status: :failed, error: reason}

    effects = [
      {:emit_metric, "payment_failed", %{order_id: state.order_id, reason: inspect(reason)}}
    ]

    {:error, reason, new_state, effects}
  end

  def transition(%{status: :authorizing} = state, :timeout) do
    reason = :gateway_timeout
    new_state = %{state | status: :failed, error: reason}

    effects = [
      {:emit_metric, "payment_timeout", %{order_id: state.order_id}}
    ]

    {:error, reason, new_state, effects}
  end

  # 그 외 조합은 “무시” 혹은 “에러”를 명시적으로 선택
  def transition(state, event) do
    {:error, {:invalid_transition, state.status, event}, state, []}
  end
end

defmodule Payments.Server do
  use GenServer

  alias Payments.FSM

  def start_link(opts) do
    GenServer.start_link(__MODULE__, :ok, opts)
  end

  # Public API
  def start_payment(pid, order_id, amount) do
    GenServer.call(pid, {:start, order_id, amount})
  end

  # GenServer callbacks
  @impl true
  def init(:ok) do
    {:ok, %{fsm: FSM.new(), timers: %{}}}
  end

  @impl true
  def handle_call({:start, order_id, amount}, _from, s) do
    {reply, s2} = apply_event(s, {:start, order_id, amount})
    {:reply, reply, s2}
  end

  @impl true
  def handle_info(:timeout, s) do
    {_reply, s2} = apply_event(s, :timeout)
    {:noreply, s2}
  end

  # 외부 시스템 결과를 메시지로 받는다고 가정
  @impl true
  def handle_info({:gateway_ok, auth_id}, s) do
    {_reply, s2} = apply_event(s, {:gateway_ok, auth_id})
    {:noreply, s2}
  end

  @impl true
  def handle_info({:gateway_fail, reason}, s) do
    {_reply, s2} = apply_event(s, {:gateway_fail, reason})
    {:noreply, s2}
  end

  defp apply_event(%{fsm: fsm} = s, event) do
    case FSM.transition(fsm, event) do
      {:ok, new_fsm, effects} ->
        s2 = %{s | fsm: new_fsm}
        s3 = run_effects(s2, effects)
        {:ok, s3}

      {:error, reason, new_fsm, effects} ->
        s2 = %{s | fsm: new_fsm}
        s3 = run_effects(s2, effects)
        {{:error, reason}, s3}
    end
  end

  defp run_effects(s, effects) do
    Enum.reduce(effects, s, fn effect, acc -> run_effect(acc, effect) end)
  end

  defp run_effect(s, {:set_timer, ms, :timeout}) do
    ref = Process.send_after(self(), :timeout, ms)
    put_in(s, [:timers, :timeout], ref)
  end

  defp run_effect(s, {:call_gateway, order_id, amount}) do
    # 실제로는 Task, Finch, Req 등을 사용
    # 여기서는 예시로 비동기 메시지로 결과가 온다고 가정
    _ = Task.start(fn ->
      # ... 결제 게이트웨이 호출 ...
      send(self(), {:gateway_ok, "AUTH-#{order_id}"})
    end)

    s
  end

  defp run_effect(s, {:emit_metric, name, tags}) do
    _ = {name, tags}  # StatsD/Telemetry 연동 지점
    s
  end
end

defmodule Payments.FSMTest do
  use ExUnit.Case, async: true

  alias Payments.FSM

  test "idle -> authorizing on start" do
    s0 = FSM.new()

    assert {:ok, s1, effects} = FSM.transition(s0, {:start, "O-1", 10_000})
    assert s1.status == :authorizing
    assert s1.order_id == "O-1"

    assert {:call_gateway, "O-1", 10_000} in effects
    assert {:set_timer, 5_000, :timeout} in effects
  end

  test "authorizing -> authorized on gateway_ok" do
    s0 = FSM.new()
    {:ok, s1, _} = FSM.transition(s0, {:start, "O-2", 5_000})

    assert {:ok, s2, _} = FSM.transition(s1, {:gateway_ok, "AUTH-123"})
    assert s2.status == :authorized
    assert s2.auth_id == "AUTH-123"
  end

  test "invalid transition is rejected" do
    s0 = FSM.new()

    assert {:error, {:invalid_transition, :idle, :timeout}, ^s0, []} =
             FSM.transition(s0, :timeout)
  end
end

defmodule Payments.State do
  defstruct status: :idle,
            order_id: nil,
            amount: nil,
            auth_id: nil,
            error: nil
end