argos

defmodule Argos.Parallel.Supervisor do
  @moduledoc """
  Supervisor raíz del sistema paralelo.

  Inicia un `DynamicSupervisor`, el `Leader`, el `Monitor` y el `Logger`.
  """

  use Supervisor

  @default_name __MODULE__

  def start_link(opts \\ []) do
    name = Keyword.get(opts, :name, @default_name)
    Supervisor.start_link(__MODULE__, opts, name: name)
  end

  @impl true
  def init(opts) do
    dyn_sup_name = Keyword.get(opts, :dyn_sup_name, Argos.Parallel.DynamicSupervisor)
    leader_name = Keyword.get(opts, :leader_name, Argos.Parallel.Leader)
    monitor_name = Keyword.get(opts, :monitor_name, Argos.Parallel.Monitor)
    logger_enabled = Keyword.get(opts, :logger_enabled, true)

    children = [
      {DynamicSupervisor, strategy: :one_for_one, name: dyn_sup_name},
      {Argos.Parallel.Leader, name: leader_name, dyn_sup_name: dyn_sup_name},
      {Argos.Parallel.Monitor, name: monitor_name, leader: leader_name}
    ]

    children =
      if logger_enabled do
        children ++
          [
            {
              Argos.Parallel.Logger,
              [leader: leader_name, monitor: monitor_name]
            }
          ]
      else
        children
      end

    Supervisor.init(children, strategy: :one_for_one)
  end

  @doc """
  Returns the PID of the dynamic supervisor.
  """
  def dyn_sup(supervisor) do
    case :supervisor.which_children(supervisor) do
      [{_, dyn_sup, _, _}, {_, _leader, _, _}, {_, _monitor, _, _}] -> dyn_sup
      _ -> nil
    end
  end

  @doc """
  Returns the PID of the leader.
  """
  def leader(supervisor) do
    case :supervisor.which_children(supervisor) do
      [{_, _dyn_sup, _, _}, {_, leader, _, _}, {_, _monitor, _, _}] -> leader
      _ -> nil
    end
  end

  @doc """
  Returns the PID of the monitor.
  """
  def monitor(supervisor) do
    case :supervisor.which_children(supervisor) do
      [{_, _dyn_sup, _, _}, {_, _leader, _, _}, {_, monitor, _, _}] -> monitor
      _ -> nil
    end
  end

  def stop(name \\ @default_name)

  def stop(pid) when is_pid(pid) do
    if Process.alive?(pid) do
      try do
        Supervisor.stop(pid)
      rescue
        _ -> :ok
      catch
        _, _ -> :ok
      else
        _ -> :ok
      end
    else
      :ok
    end
  end

  def stop(name) do
    Supervisor.stop(name)
  end
end