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.Server` governs the
  main logic of an instantiated game and broadcasts updates to each registered
  player.
  """
  require Logger

  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 <- Dogfight.IndexAgent.next_id(),
         player_spec <- player_spec(client_socket, player_id),
         {:ok, pid} <- Horde.DynamicSupervisor.start_child(ClusterServiceSupervisor, player_spec) do
      Logger.info("Player #{player_id} connected")
      Dogfight.Game.Server.register_player(pid, 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.State, as: GameState
  alias Dogfight.Game.Action, as: GameAction

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

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

  def handle_info({:tcp, _socket, data}, state) do
    action = GameAction.decode!(data)
    Dogfight.Game.Server.apply_action(self(), action, state.player_id)
    {:noreply, state}
  end

  def handle_info({:tcp_closed, _socket}, state) do
    Logger.info("Player disconnected")
    {: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, GameState.encode(game_state))
  end
end

defmodule Dogfight.Game.Server 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 truth 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})
    GenServer.cast(__MODULE__, {:spawn_new_ship, player_id})
  end

  def apply_action(pid, action, player_index) do
    GenServer.cast(__MODULE__, {:apply_action, pid, action, player_index})
  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}, from, state) do
    new_state =
      Map.update!(state, :players, fn players -> [{:player_id, %{pid: pid}} | players] end)

    {:reply, from, new_state}
  end

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

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

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

  @impl true
  def handle_cast({:apply_action, _pid, action, player_index}, state) do
    game_state = GameState.apply_action(state.game_state, action, player_index)
    updated_state = %{state | game_state: game_state}
    broadcast_game_state(updated_state)
    {:noreply, updated_state}
  end

  defp broadcast_game_state(state) do
    Enum.each(state.players, fn {_pid, player} ->
      send(player.pid, state.game_state)
    end)
  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.Encoding.Helpers, as: Encoding
  alias Dogfight.Game.Action

  @type t :: %__MODULE__{
          players: [ship()],
          active_players: non_neg_integer(),
          player_index: non_neg_integer(),
          powerup: powerup()
        }

  @typep ship :: %{
           coord: vec2(),
           hp: integer(),
           direction: integer(),
           alive: boolean(),
           bullets: [bullet()]
         }

  @typep powerup :: %{
           coord: vec2(),
           kind: :hp_plus_one | :hp_plus_three | :ammo_plus_one | nil
         }

  @typep vec2 :: %{
           x: integer(),
           y: integer()
         }

  @typep bullet :: %{
           coord: vec2(),
           direction: integer(),
           active: boolean()
         }

  defstruct [:players, :active_players, :player_index, :powerup]

  @max_players 5
  @max_bullets 5
  @base_hp 5
  @screen_width 800
  @screen_height 600

  def new do
    %__MODULE__{
      player_index: 0,
      active_players: 0,
      powerup: %{coord: %{x: 0, y: 0}, kind: nil},
      players: Stream.repeatedly(&new_ship/0) |> Enum.take(@max_players)
    }
  end

  defp new_ship do
    %{
      coord: %{
        x: 0,
        y: 0
      },
      hp: 0,
      direction: :idle,
      alive: false,
      bullets: Stream.repeatedly(&new_bullet/0) |> Enum.take(@max_bullets)
    }
  end

  defp new_bullet do
    %{
      active: false,
      coord: %{
        x: 0,
        y: 0
      },
      direction: :idle
    }
  end

  # TODO move to a map instead of the array, keepeing as-is for the first
  # translation pass
  @spec spawn_ship(t(), integer()) :: {:ok, t()} | {:error, :dismissed_ship}
  def spawn_ship(game_state, index) do
    if Enum.at(game_state.players, index).alive do
      {:ok, game_state}
    else
      # TODO fix this monstrosity
      new_state = %{
        game_state
        | active_players: game_state.active_players + 1,
          players:
            Enum.with_index(game_state.players, fn
              player, ^index ->
                %{
                  player
                  | alive: true,
                    hp: @base_hp,
                    coord: %{x: :rand.uniform(@screen_width), y: :rand.uniform(@screen_height)},
                    direction: :up
                }

              other, _i ->
                other
            end)
      }

      {:ok, new_state}
    end
  end

  @spec update(t()) :: t()
  def update(game_state) do
    %{game_state | players: update_ships(game_state.players)}
  end

  defp update_ships(players) do
    Enum.map(players, &update_ship/1)
  end

  defp update_ship(%{alive: false} = ship), do: ship

  defp update_ship(%{alive: true} = ship) do
    bullets = Enum.map(ship.bullets, &update_bullet/1)

    %{
      ship
      | bullets: bullets
    }
  end

  defp update_bullet(%{active: false} = bullet), do: bullet

  defp update_bullet(%{active: true} = bullet) do
    case bullet.direction do
      :up ->
        %{
          bullet
          | coord: %{x: bullet.coord.x, y: bullet.coord.y - 6}
        }

      :down ->
        %{
          bullet
          | coord: %{x: bullet.coord.x, y: bullet.coord.y + 6}
        }

      :left ->
        %{
          bullet
          | coord: %{x: bullet.coord.x - 6, y: bullet.coord.y}
        }

      :right ->
        %{
          bullet
          | coord: %{x: bullet.coord.x + 6, y: bullet.coord.y}
        }

      _ ->
        bullet
    end
  end

  @spec apply_action(t(), Game.Action.t(), non_neg_integer()) :: t()
  def apply_action(game_state, action, player_index) do
    case action do
      direction when direction in [:up, :down, :left, :right] ->
        move_ship(game_state, player_index, direction)

      :shoot ->
        shoot(game_state, player_index)

      _ ->
        game_state
    end
  end

  defp move_ship(game_state, player_index, direction) do
    player_coord = Enum.at(game_state.players, player_index).coord

    player_coord = move_ship_coord(player_coord, direction)

    ships =
      Enum.with_index(game_state.players, fn
        player, ^player_index ->
          %{
            player
            | direction: direction,
              coord: player_coord
          }

        other, _i ->
          other
      end)

    %{
      game_state
      | players: ships
    }
  end

  defp move_ship_coord(%{x: x, y: y}, direction) do
    case direction do
      :up ->
        %{x: x, y: y - 3}

      :down ->
        %{x: x, y: y + 3}

      :left ->
        %{x: x - 3, y: y}

      :right ->
        %{x: x + 3, y: y}
    end
  end

  defp shoot(game_state, player_index) do
    %{
      game_state
      | players:
          Enum.with_index(game_state.players, fn
            player, ^player_index ->
              bullets = update_bullets(player.bullets, player)

              %{player | bullets: bullets}

            other, _i ->
              other
          end)
    }
  end

  defp update_bullets(bullets, player) do
    Enum.map_reduce(bullets, false, fn
      bullet, false when bullet.active == false ->
        {
          %{
           bullet
           | active: true,
             direction: player.direction,
             coord: %{x: player.coord.x, y: player.coord.y}
         }, true}

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