Init 1

defmodule Dogfight.Server do
  @moduledoc """

  Main entry point of the server, accepts connecting clients and defer their
  ownership to the game server. Each connected client is handled by a
  `GenServer`, the `Dogfight.Player`. The `Dogfight.Game.EventHandler` governs
  the main logic of an instantiated game and broadcasts updates to each
  registered player.

  """
  require Logger

  alias Dogfight.Game.Event, as: GameEvent
  alias Dogfight.ClusterServiceSupervisor

  def listen(port) do
    # The options below mean:
    #
    # 1. `:binary` - receives data as binaries (instead of lists)
    # 2. `packet: :raw` - receives data as it comes (stream of binary over the wire)
    # 3. `active: true` - non blocking on `:gen_tcp.recv/2`, doesn't wait for data to be available
    # 4. `reuseaddr: true` - allows us to reuse the address if the listener crashes
    #
    {:ok, socket} =
      :gen_tcp.listen(port, [:binary, packet: :raw, active: true, reuseaddr: true])

    Logger.info("Accepting connections on port #{port}")
    accept_loop(socket)
  end

  defp accept_loop(socket) do
    with {:ok, client_socket} <- :gen_tcp.accept(socket),
         player_id <- UUID.uuid4(),
         player_spec <- player_spec(client_socket, player_id),
         {:ok, pid} <- Horde.DynamicSupervisor.start_child(ClusterServiceSupervisor, player_spec),
         :ok <- :gen_tcp.send(client_socket, player_id) do
      Dogfight.Game.EventHandler.apply_event(pid, GameEvent.player_connection(player_id))
      :gen_tcp.controlling_process(client_socket, pid)
    else
      error -> Logger.error("Failed to accept connection, reason: #{inspect(error)}")
    end

    accept_loop(socket)
  end

  defp player_spec(socket, player_id) do
    %{
      id: Dogfight.Player,
      start: {Dogfight.Player, :start_link, [player_id, socket]},
      type: :worker,
      restart: :transient
    }
  end
end

defmodule Dogfight.Player do
  @moduledoc """
  This module represents a player in the Dogfight game. It handles the player's
  connection, actions, and communication with the game server.
  """

  require Logger
  use GenServer

  alias Dogfight.Game.Codecs.BinaryCodec
  alias Dogfight.Game.Event, as: GameEvent

  def start_link(player_id, socket) do
    GenServer.start_link(__MODULE__, {player_id, socket})
  end

  def init({player_id, socket}) do
    Logger.info("Player #{player_id} connected, registering to game server")
    {:ok, %{player_id: player_id, socket: socket}}
  end

  def handle_info({:tcp, _socket, data}, state) do
    with {:ok, event} <- BinaryCodec.decode_event(data) do
      Dogfight.Game.EventHandler.apply_event(self(), event)
    else
      {:ok, :codec_error} -> Logger.error("Decode failed, unknown event")
    end

    {:noreply, state}
  end

  def handle_info({:tcp_closed, _socket}, state) do
    Logger.info("Player #{state.player_id} disconnected")

    Dogfight.Game.EventHandler.apply_event(
      self(),
      GameEvent.player_disconnection(state.player_id)
    )

    {:noreply, state}
  end

  def handle_info({:tcp_error, _socket, reason}, state) do
    Logger.error("Player transmission error #{inspect(reason)}")
    {:noreply, state}
  end

  def handle_info({:update, game_state}, state) do
    send_game_update(state.socket, game_state)
    {:noreply, state}
  end

  defp send_game_update(socket, game_state) do
    :gen_tcp.send(socket, BinaryCodec.encode(game_state))
  end
end

defmodule Dogfight.Game.Event do
  @moduledoc """
  This structure represents any game event to be applied to a game state to
  transition to a new state
  """

  alias Dogfight.Game.State

  @type t ::
          {:player_connection, State.player_id()}
          | {:player_disconnection, State.player_id()}
          | {:move, {State.player_id(), State.direction()}}
          | {:shoot, State.player_id()}
          | {:pickup_power_up, State.player_id()}
          | {:spawn_power_up, State.power_up_kind()}
          | {:start_game}
          | {:end_game}

  def player_connection(player_id), do: {:player_connection, player_id}
  def player_disconnection(player_id), do: {:player_disconnection, player_id}
  def move(player_id, direction), do: {:move, {player_id, direction}}
  def shoot(player_id), do: {:shoot, player_id}
end

defmodule Dogfight.Game.EventHandler do
  @moduledoc """
  Represents a game server for the Dogfight game. It handles the game state and
  player actions. It is intended as the main source of thruth for each instantiated game,
  broadcasting the game state to each connected player every `@tick` milliseconds.
  """
  require Logger
  use GenServer

  alias Dogfight.Game.State, as: GameState

  @tick_rate_ms 50

  def start_link(_) do
    GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
  end

  @impl true
  def init(_) do
    game_state = GameState.new()
    schedule_tick()
    {:ok, %{players: %{}, game_state: game_state}}
  end

  def register_player(pid, player_id) do
    GenServer.call(__MODULE__, {:register_player, pid, player_id})
    GenServer.cast(__MODULE__, {:add_player, player_id})
  end

  def apply_event(pid, event) do
    case event do
      {:player_connection, player_id} ->
        GenServer.call(__MODULE__, {:register_player, pid, player_id})
        GenServer.cast(__MODULE__, {:add_player, player_id})

      {:player_disconnection, player_id} ->
        GenServer.call(__MODULE__, {:unregister_player, player_id})
        GenServer.cast(__MODULE__, {:drop_player, player_id})

      event ->
        GenServer.cast(__MODULE__, {:apply_event, pid, event})
    end
  end

  defp schedule_tick() do
    Process.send_after(self(), :tick, @tick_rate_ms)
  end

  @impl true
  def handle_info(:tick, state) do
    new_game_state = GameState.update(state.game_state)
    updated_state = %{state | game_state: new_game_state}
    broadcast_game_state(updated_state)
    schedule_tick()
    {:noreply, updated_state}
  end

  @impl true
  def handle_call({:register_player, pid, player_id}, from, state) do
    new_state =
      Map.update!(state, :players, fn players ->
        Map.put(players, player_id, pid)
      end)

    {:reply, from, new_state}
  end

  @impl true
  def handle_call({:unregister_player, player_id}, from, state) do
    new_state =
      Map.update!(state, :players, fn players ->
        Map.delete(players, player_id)
      end)

    {:reply, from, new_state}
  end

  @impl true
  def handle_cast({:add_player, player_id}, state) do
    game_state =
      case GameState.add_player(state.game_state, player_id) do
        {:ok, game_state} ->
          broadcast_game_state(%{state | game_state: game_state})
          game_state

        {:error, error} ->
          Logger.error("Failed spawining spaceship, reason: #{inspect(error)}")
          state.game_state
      end

    {:noreply, %{state | game_state: game_state}}
  end

  @impl true
  def handle_cast({:drop_player, player_id}, state) do
    {:noreply, %{state | game_state: GameState.drop_player(state.game_state, player_id)}}
  end

  @impl true
  def handle_cast({:apply_event, _pid, event}, state) do
    updated_state =
      with {:ok, game_state} <- GameState.apply_event(state.game_state, event) do
        updated_state = %{state | game_state: game_state}
        broadcast_game_state(updated_state)
        updated_state
      else
        e ->
          Logger.error("Failed to apply event, reason: #{inspect(e)}")
          state
      end

    {:noreply, updated_state}
  end

  defp broadcast_game_state(state) do
    Enum.each(Map.values(state.players), fn pid ->
      send(pid, {:update, state.game_state})
    end)
  end
end

defmodule Dogfight.Game.Spaceship do
  @moduledoc """
  Spaceship behaviour
  """

  alias Dogfight.Game.State

  @type t :: any()

  @callback move(t(), State.direction()) :: t()
  @callback shoot(t()) :: t()
  @callback update_bullets(t()) :: t()
end

defmodule Dogfight.Game.DefaultSpaceship do
  @moduledoc """
  DefaultSpaceship module, represents the main entity of each player, a default
  spaceship without any particular trait, with a base speed of 3 units and base HP
  of 5.
  """

  defmodule Bullet do
    @moduledoc """
    Bullet inner module, represents a bullet of the spaceship entity
    """

    @type t :: %__MODULE__{
            position: Vec2.t(),
            direction: State.direction(),
            active?: boolean(),
            boundaries: %{width: non_neg_integer(), height: non_neg_integer()}
          }

    defstruct [:position, :direction, :active?, :boundaries]

    alias Dogfight.Game.State
    alias Dogfight.Game.Vec2

    @bullet_base_speed 6

    def new(width, height) do
      %__MODULE__{
        position: %Vec2{x: 0, y: 0},
        direction: State.idle(),
        active?: false,
        boundaries: %{width: width, height: height}
      }
    end

    def update(%{active?: false} = bullet), do: bullet

    def update(bullet) do
      position = bullet.position

      bullet =
        case bullet.direction do
          :up ->
            %{bullet | position: Vec2.add_y(position, -@bullet_base_speed)}

          :down ->
            %{bullet | position: Vec2.add_y(position, @bullet_base_speed)}

          :left ->
            %{bullet | position: Vec2.add_x(position, -@bullet_base_speed)}

          :right ->
            %{bullet | position: Vec2.add_x(position, @bullet_base_speed)}

          _ ->
            bullet
        end

      boundaries_check(bullet)
    end

    defp boundaries_check(%{position: %{x: x}, boundaries: %{width: width}} = bullet)
         when x < 0 or x >= width,
         do: %{bullet | active?: false}

    defp boundaries_check(%{position: %{y: y}, boundaries: %{height: height}} = bullet)
         when y < 0 or y >= height,
         do: %{bullet | active?: false}

    defp boundaries_check(bullet), do: bullet
  end

  @behaviour Dogfight.Game.Spaceship

  alias Dogfight.Game.State
  alias Dogfight.Game.Bullet
  alias Dogfight.Game.Vec2

  @type t :: %__MODULE__{
          position: Vec2.t(),
          hp: non_neg_integer(),
          direction: State.direction(),
          alive?: boolean(),
          bullets: [Bullet.t(), ...]
        }

  defstruct [:position, :hp, :direction, :alive?, :bullets]

  @base_hp 5
  @base_bullet_count 5
  @base_spaceship_speed 3

  def spawn(width, height) do
    %__MODULE__{
      position: Vec2.random(width, height),
      direction: State.idle(),
      hp: @base_hp,
      alive?: true,
      bullets:
        Stream.repeatedly(fn -> __MODULE__.Bullet.new(width, height) end)
        |> Enum.take(@base_bullet_count)
    }
  end

  @impl true
  def move(spaceship, direction) do
    position = spaceship.position

    updated_position =
      case direction do
        :up -> Vec2.add_y(position, -@base_spaceship_speed)
        :down -> Vec2.add_y(position, @base_spaceship_speed)
        :left -> Vec2.add_x(position, -@base_spaceship_speed)
        :right -> Vec2.add_x(position, @base_spaceship_speed)
        :idle -> position
      end

    %{spaceship | direction: direction, position: updated_position}
  end

  @impl true
  def shoot(spaceship) do
    bullets =
      spaceship.bullets
      |> Enum.map_reduce(false, fn
        bullet, false when bullet.active? == false ->
          {
            %{
             bullet
             | active?: true,
               direction: spaceship.direction,
               position: spaceship.position
           }, true}

        bullet, updated ->
          {bullet, updated}
      end)
      |> elem(0)

    %{
      spaceship
      | bullets: bullets
    }
  end

  @impl true
  def update_bullets(%{alive?: false} = spaceship), do: spaceship

  @impl true
  def update_bullets(spaceship) do
    %{spaceship | bullets: Enum.map(spaceship.bullets, &__MODULE__.Bullet.update/1)}
  end
end

defmodule Dogfight.Game.State do
  @moduledoc """
  Game state management, Ships and bullet logics, including collision.
  Represents the source of truth for each connecting player, and its updated
  based on the input of each one of the connected active players
  """

  alias Dogfight.Game.Event
  alias Dogfight.Game.Spaceship
  alias Dogfight.Game.DefaultSpaceship
  alias Dogfight.Game.Vec2

  @type player_id :: String.t()

  @type power_up_kind :: :hp_plus_one | :hp_plus_three | :ammo_plus_one | nil

  @type power_up :: %{
          position: Vec2.t(),
          kind: power_up_kind()
        }

  @type direction :: :idle | :up | :down | :left | :right

  @typep status :: :in_progress | :closed | nil

  @type t :: %__MODULE__{
          players: %{player_id() => Spaceship.t()},
          power_ups: [power_up()],
          status: status()
        }

  defstruct [:players, :power_ups, :status]

  @screen_width 800
  @screen_height 600

  def new do
    %__MODULE__{
      power_ups: [],
      status: :closed,
      players: %{}
    }
  end

  @spec add_player(t(), player_id()) :: {:ok, t()} | {:error, :dismissed_ship}
  def add_player(game_state, player_id) do
    case Map.get(game_state.players, player_id) do
      nil ->
        players =
          Map.put(
            game_state.players,
            player_id,
            DefaultSpaceship.spawn(@screen_width, @screen_height)
          )

        {:ok, %{game_state | players: players}}

      %{alive?: true} ->
        {:ok, game_state}

      _spaceship ->
        {:error, :dismissed_ship}
    end
  end

  @spec drop_player(t(), player_id()) :: t()
  def drop_player(game_state, player_id) do
    Map.update!(game_state, :players, fn players ->
      Map.delete(players, player_id)
    end)
  end

  @spec update(t()) :: t()
  def update(game_state) do
    %{
      game_state
      | players:
          Map.new(game_state.players, fn {player_id, spaceship} ->
            {player_id, DefaultSpaceship.update_bullets(spaceship)}
          end)
    }
  end

  defp fetch_spaceship(players_map, player_id) do
    case Map.fetch(players_map, player_id) do
      :error -> {:error, :dismissed_ship}
      %{alive?: false} -> {:error, :dismissed_ship}
      {:ok, _spaceship} = ok -> ok
    end
  end

  @spec apply_event(t(), Event.t()) :: {:ok, t()} | {:error, :dismissed_ship}
  def apply_event(game_state, {:move, {player_id, direction}}) do
    with {:ok, spaceship} <- fetch_spaceship(game_state.players, player_id) do
      {:ok,
       %{
         game_state
         | players:
             Map.put(game_state.players, player_id, DefaultSpaceship.move(spaceship, direction))
       }}
    end
  end

  def apply_event(game_state, {:shoot, player_id}) do
    with {:ok, spaceship} <- fetch_spaceship(game_state.players, player_id) do
      {:ok,
       %{
         game_state
         | players: Map.put(game_state.players, player_id, DefaultSpaceship.shoot(spaceship))
       }}
    end
  end

  def apply_event(game_state, {:spawn_power_up, power_up_kind}) do
    power_up = %{position: Vec2.random(@screen_width, @screen_height), kind: power_up_kind}

    {:ok,
     %{
       game_state
       | power_ups: [power_up | game_state.power_ups]
     }}
  end

  def apply_event(_game_state, _event), do: raise("Not implemented")

  def idle, do: :idle
  def move_up, do: :up
  def move_down, do: :down
  def move_left, do: :left
  def move_right, do: :right
  def shoot, do: :shoot
end

defmodule Dogfight.Application do
  @moduledoc """
  Documentation for `Dogfight`.
  Server component for the Dogfight battle arena game, developed to have
  some fun with game dev and soft-real time distributed systems.
  """

  use Application

  def start(_type, _args) do
    port = String.to_integer(System.get_env("DOGFIGHT_TCP_PORT") || "6699")

    children = [
      {Cluster.Supervisor, [topologies(), [name: Dogfight.ClusterSupervisor]]},
      {
        Horde.Registry,
        name: Dogfight.ClusterRegistry, keys: :unique, members: :auto
      },
      {
        Horde.DynamicSupervisor,
        name: Dogfight.ClusterServiceSupervisor, strategy: :one_for_one, members: :auto
      },
      Dogfight.Game.EventHandler,
      Supervisor.child_spec({Task, fn -> Dogfight.Server.listen(port) end}, restart: :permanent)
    ]

    opts = [strategy: :one_for_one, name: Dogfight.Supervisor]
    Supervisor.start_link(children, opts)
  end

  # Can also read this from conf files, but to keep it simple just hardcode it for now.
  # It is also possible to use different strategies for autodiscovery.
  # Following strategy works best for docker setup we using for this app.
  defp topologies do
    [
      game_state_nodes: [
        strategy: Cluster.Strategy.Epmd,
        config: [
          hosts: [:"app@n1.dev", :"app@n2.dev", :"app@n3.dev"]
        ]
      ]
    ]
  end
end