%% Erlang
Pid = spawn(fun() ->
    receive
        {From, hello} ->
            From ! {self(), hi},
            io:format("收到 hello~n");
        _ ->
            io:format("收到未知消息~n")
    end
end).

%% 发送消息
Pid ! {self(), hello}.

# Elixir（Erlang 之上的现代语言）
pid = spawn(fn ->
  receive do
    {:hello, sender} ->
      send(sender, {:hi, self()})
      IO.puts("收到 hello")
    _ ->
      IO.puts("收到未知消息")
  end
end)

send(pid, {:hello, self()})

%% 发送是异步的 — 立即返回
Pid ! Message.

%% 接收是选择性的 — Pattern Matching
receive
    Pattern1 -> Body1;
    Pattern2 -> Body2;
after
    Timeout -> TimeoutBody
end.

%% 只处理感兴趣的消息，忽略其他
receive
    {reply, Ref, Data} ->
        handle_reply(Ref, Data)
    %% 不匹配 {ping, _} 或其他消息
    %% 它们留在 mailbox 中
after 5000 ->
    timeout
end.

%% 默认调度器数量 = CPU 核心数
erlang:system_info(schedulers).       %% 查看调度器数量
erlang:system_info(schedulers_online). %% 查看在线调度器数量

%% VM 会自动处理 CPU 亲和性、负载均衡

%% 三种重启策略
%% one_for_one: 只重启崩溃的那个子进程
%% one_for_all: 重启所有子进程
%% rest_for_one: 重启崩溃进程及其之后启动的进程

init(_) ->
    {ok, {{one_for_one, 5, 10}, [
        {worker1, {worker1, start_link, []},
         permanent, 5000, worker, [worker1]},
        {worker2, {worker2, start_link, []},
         permanent, 5000, worker, [worker2]}
    ]}}.

# Elixir 的监督者
defmodule MyApp.Supervisor do
  use Supervisor

  def start_link(opts) do
    Supervisor.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @impl true
  def init(_opts) do
    children = [
      {MyApp.Worker1, []},
      {MyApp.Worker2, []},
      {MyApp.Worker3, []}
    ]

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

defmodule Counter do
  use GenServer

  # 客户端 API
  def start_link(initial_value) do
    GenServer.start_link(__MODULE__, initial_value, name: __MODULE__)
  end

  def increment, do: GenServer.cast(__MODULE__, :increment)
  def get_value, do: GenServer.call(__MODULE__, :get_value)

  # 服务端回调
  @impl true
  def init(initial_value), do: {:ok, initial_value}

  @impl true
  def handle_call(:get_value, _from, state) do
    {:reply, state, state}
  end

  @impl true
  def handle_cast(:increment, state) do
    {:noreply, state + 1}
  end
end

# 使用
{:ok, _pid} = Counter.start_link(0)
Counter.increment()
Counter.increment()
Counter.get_value()  # => 2

%% 启动两个节点
%% node1@host> erl -name node1@192.168.1.1 -setcookie mycookie
%% node2@host> erl -name node2@192.168.1.2 -setcookie mycookie

%% 在 node1 上
Pid = spawn('node2@192.168.1.2', fun() ->
    io:format("我在远程节点运行！~n")
end).

%% 消息传递跨节点透明
Pid ! {hello, self()}.

defmodule Chat.Room do
  use GenServer

  def start_link(room_id) do
    GenServer.start_link(__MODULE__, room_id, name: via_tuple(room_id))
  end

  def join(room_id, user_pid), do: GenServer.cast(via_tuple(room_id), {:join, user_pid})
  def send_msg(room_id, user, msg), do: GenServer.cast(via_tuple(room_id), {:msg, user, msg})

  @impl true
  def init(room_id), do: {:ok, %{room_id: room_id, members: MapSet.new()}}

  @impl true
  def handle_cast({:join, user_pid}, state) do
    Process.monitor(user_pid)
    {:noreply, %{state | members: MapSet.put(state.members, user_pid)}}
  end

  @impl true
  def handle_cast({:msg, user, msg}, state) do
    Enum.each(state.members, fn pid ->
      send(pid, {:chat_msg, user, msg})
    end)
    {:noreply, state}
  end

  @impl true
  def handle_info({:DOWN, _, :process, pid, _}, state) do
    {:noreply, %{state | members: MapSet.delete(state.members, pid)}}
  end

  defp via_tuple(room_id), do: {:via, Registry, {Chat.Registry, room_id}}
end