defmodule SplitClient.Boundary.DataSourceStub do
  # Stub for a Datasource for testing scenarios. One will
  # be created for each test to keep an isolated store
  # of split information
  @moduledoc false
  use GenServer

  alias SplitClient.Boundary.DataSource.SplitStub
  alias SplitClient.DataSourceYAML

  @behaviour SplitClient.Boundary.DataSourceBehaviour

  def start_link(_opts \\ []) do
    GenServer.start_link(__MODULE__, [])
  end

  @spec create_splits(pid :: pid(), splits :: list(map())) :: :ok
  def create_splits(pid, splits, opts \\ []) do
    splits = SplitStub.from_list(splits)
    GenServer.call(pid, {:create_splits, splits, opts})
  end

  @impl true
  def get_treatment(key, split_name, opts \\ []) do
    name = server_name(opts)

    treatment =
      if name do
        GenServer.call(name, {:get_treatment, key, split_name})
      else
        {:ok, treatment} = DataSourceYAML.get_treatment(key, split_name, opts)
        treatment
      end

    {:ok, treatment}
  end

  @impl true
  def get_treatments(key, split_names, opts \\ []) do
    name = server_name(opts)

    treatments =
      if name do
        GenServer.call(name, {:get_treatments, key, split_names})
      else
        {:ok, treatments} = DataSourceYAML.get_treatments(key, split_names, opts)
        treatments
      end

    {:ok, treatments}
  end

  @impl true
  def get_all_treatments(keys, opts \\ []) do
    name = server_name(opts)

    treatments =
      if name do
        GenServer.call(name, {:get_all_treatments, keys})
      else
        {:ok, treatments} = DataSourceYAML.get_all_treatments(keys, opts)
        treatments
      end

    {:ok, treatments}
  end

  defp server_name(opts) do
    Keyword.get(opts, :data_source_pid)
  end

  @impl true
  def init(splits \\ []) do
    {:ok, splits}
  end

  @impl true
  def handle_call({:create_splits, splits, opts}, _from, _state) do
    default_splits = DataSourceYAML.read_split_file(opts)
    splits = SplitStub.merge_splits(default_splits, splits)
    {:reply, :ok, splits}
  end

  @impl true
  def handle_call({:get_treatment, key, split_name}, _from, splits) do
    treatment = SplitStub.find_treatment(splits, key, split_name)
    {:reply, treatment, splits}
  end

  @impl true
  def handle_call({:get_treatments, key, split_names}, _from, splits) do
    treatments = SplitStub.find_treatments(splits, key, split_names)
    {:reply, treatments, splits}
  end

  @impl true
  def handle_call({:get_all_treatments, keys}, _from, splits) do
    treatments = SplitStub.find_all_treatments(splits, keys)
    {:reply, treatments, splits}
  end
end