Position islands

lib/islands_engine/game.ex

@@ -1,8 +1,11 @@
 defmodule IslandEngine.Game do
-  alias IslandsEngine.{Board, Guesses}
+  alias IslandsEngine.{Board, Coordinate, Guesses, Island}
   alias IslandEngine.Rules
+
   use GenServer
 
+  @players [:player1, :player2]
+
   def start_link(name) when is_binary(name), do: GenServer.start_link(__MODULE__, name, [])
 
   def init(name) do
@@ -13,6 +16,9 @@ defmodule IslandEngine.Game do
 
   def add_player(game, name) when is_binary(name), do: GenServer.call(game, {:add_player, name})
 
+  def position_island(game, player, key, row, col) when player in @players,
+    do: GenServer.call(game, {:position_island, player, key, row, col})
+
   def handle_call({:add_player, name}, _from, state_data) do
     with {:ok, rules} <- Rules.check(state_data.rules, :add_player) do
       state_data
@@ -24,9 +30,45 @@ defmodule IslandEngine.Game do
     end
   end
 
+  def handle_call({:position_island, player, key, row, col}, _from, state_data) do
+    board = player_board(state_data, player)
+    IO.inspect(board)
+
+    with {:ok, rules} <- Rules.check(state_data.rules, :position_island),
+         {:ok, coordinate} <- Coordinate.new(row, col),
+         {:ok, island} <- Island.new(key, coordinate),
+         %{} = board <- Board.position_island(board, key, island) do
+      IO.inspect("Grut")
+
+      state_data
+      |> update_board(player, board)
+      |> update_rules(rules)
+      |> reply_success(:ok)
+    else
+      :error ->
+        {:reply, :error, state_data}
+
+      {:error, :invalid_coordinate} ->
+        {:reply, {:error, :invalid_coordinate}, state_data}
+
+      {:error, :invalid_island_type} ->
+        {:error, {:error, :invalid_island_type}, state_data}
+
+      {:error, :overlapping_island} ->
+        {:error, {:error, :overlapping_island}, state_data}
+
+        IO.inspect("Else Grut")
+    end
+  end
+
   defp update_player2_name(state_data, name), do: put_in(state_data.player2.name, name)
 
   defp update_rules(state_data, rules), do: %{state_data | rules: rules}
 
   defp reply_success(state_data, reply), do: {:reply, reply, state_data}
+
+  defp update_board(state_data, player, board),
+    do: Map.update!(state_data, player, fn player -> %{player | board: board} end)
+
+  defp player_board(state_data, player), do: Map.get(state_data, player).board
 end