chore: resolved a huge merge conflict

knockoutwhistweb/app/controllers/IngameController.scala

@@ -21,101 +21,12 @@ import scala.concurrent.Future
 import scala.util.Try
 import scala.concurrent.ExecutionContext
 @Singleton
-class IngameController @Inject() (
-                                   val cc: ControllerComponents,
-                                   val podManager: PodManager,
-                                   val authAction: AuthAction,
-                                   implicit val ec: ExecutionContext
-                                 ) extends AbstractController(cc) {
+class IngameController @Inject()(
+                                  val controllerComponents: ControllerComponents,
+                                  val authAction: AuthAction,
+                                  val podManager: PodManager
+                                ) extends BaseController {
 
-  // --- Helper function (defined outside match/if for scope) ---
-  def buildSuccessResponse(game: GameLobby, hand: Option[Hand]): JsValue = {
-    // NOTE: Replace the unsafe .get calls here if game state is not guaranteed
-    val currentRound = game.logic.getCurrentRound.get
-    val currentTrick = game.logic.getCurrentTrick.get
-
-    // JSON Building Logic:
-    val trickCardsJson = Json.toJson(
-      currentTrick.cards.map { case (card, player) =>
-        Json.obj("cardId" -> WebUIUtils.cardtoString(card), "player" -> player.name)
-      }
-    )
-    val scoreTableJson = Json.toJson(
-      game.getLogic.getPlayerQueue.get.toList.map { player =>
-        Json.obj(
-          "name" -> player.name,
-          "tricks" -> currentRound.tricklist.count(_.winner.contains(player))
-        )
-      }
-    )
-
-    val stringHand = hand.map { h =>
-      val cardStrings = h.cards.map(WebUIUtils.cardtoString(_))
-      Json.toJson(cardStrings).as[JsArray]
-    }.getOrElse(Json.arr())
-
-    val firstCardId = currentTrick.firstCard.map(WebUIUtils.cardtoString).getOrElse("BLANK")
-    val nextPlayer = game.getLogic.getPlayerQueue.get.duplicate().nextPlayer().name
-    Json.obj(
-      "status" -> "cardPlayed",
-      "handData" -> stringHand,
-      "currentPlayerName" -> game.logic.getCurrentPlayer.get.name,
-      "trumpSuit" -> currentRound.trumpSuit.toString,
-      "trickCards" -> trickCardsJson,
-      "scoreTable" -> scoreTableJson,
-      "firstCardId" -> firstCardId,
-      "nextPlayer" -> nextPlayer
-    )
-  }
-
-  def handleEvent(event: PollingEvents, game: GameLobby, user: User): Result = {
-    event match {
-      case CardPlayed =>
-        val player = game.getPlayerByUser(user)
-        val hand = player.currentHand()
-        val jsonResponse = buildSuccessResponse(game, hand)
-        Ok(jsonResponse)
-      case GameStarted =>
-        val jsonResponse = Json.obj(
-          "status" -> "gameStart",
-          "redirectUrl" -> routes.IngameController.game(game.id).url
-        )
-        Ok(jsonResponse)
-    }
-  }
-  // --- Main Polling Action ---
-  def polling(gameId: String): Action[AnyContent] = authAction.async { implicit request: AuthenticatedRequest[AnyContent] =>
-
-    val playerId = request.user.id
-
-    // 1. Safely look up the game
-    podManager.getGame(gameId) match {
-      case Some(game) =>
-
-        // 2. Short-Poll Check (Check for missed events)
-        if (game.getPollingState.nonEmpty) {
-          val event = game.getPollingState.dequeue()
-
-          Future.successful(handleEvent(event, game, request.user))
-        } else {
-
-          val eventPromise = game.registerWaiter(playerId)
-
-          eventPromise.future.map { event =>
-            game.removeWaiter(playerId)
-            handleEvent(event, game, request.user)
-          }.recover {
-            case _: Throwable =>
-              game.removeWaiter(playerId)
-              NoContent
-          }
-        }
-
-      case None =>
-        // Game not found
-        Future.successful(NotFound("Game not found."))
-    }
-  }
   def game(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
     val game = podManager.getGame(gameId)
     game match {
@@ -156,70 +67,30 @@ class IngameController @Inject() (
       }
     }
     if (result.isSuccess) {
-      Ok(Json.obj(
-        "status" -> "success",
-        "redirectUrl" -> routes.IngameController.game(gameId).url
-      ))
+      Redirect(routes.IngameController.game(gameId))
     } else {
       val throwable = result.failed.get
       throwable match {
         case _: NotInThisGameException =>
-          BadRequest(Json.obj(
-            "status" -> "failure",
-            "errorMessage" -> throwable.getMessage
-          ))
+          BadRequest(throwable.getMessage)
         case _: NotHostException =>
-          Forbidden(Json.obj(
-            "status" -> "failure",
-            "errorMessage" -> throwable.getMessage
-          ))
+          Forbidden(throwable.getMessage)
         case _: NotEnoughPlayersException =>
-          BadRequest(Json.obj(
-            "status" -> "failure",
-            "errorMessage" -> throwable.getMessage
-          ))
+          BadRequest(throwable.getMessage)
         case _ =>
-          InternalServerError(Json.obj(
-            "status" -> "failure",
-            "errorMessage" -> throwable.getMessage
-          ))
+          InternalServerError(throwable.getMessage)
       }
     }
   }
-  def kickPlayer(gameId: String, playerToKick: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+  def kickPlayer(gameId: String, playerToKick: UUID): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
     val game = podManager.getGame(gameId)
-    val playerToKickUUID = UUID.fromString(playerToKick)
-    val result = Try {
-      game.get.leaveGame(playerToKickUUID)
-    }
-    if(result.isSuccess) {
-      Ok(Json.obj(
-        "status" -> "success",
-        "redirectUrl" -> routes.IngameController.game(gameId).url
-      ))
-    } else {
-      InternalServerError(Json.obj(
-        "status" -> "failure",
-        "errorMessage" -> "Something went wrong."
-      ))
-    }
+    game.get.leaveGame(playerToKick)
+    Redirect(routes.IngameController.game(gameId))
   }
   def leaveGame(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
     val game = podManager.getGame(gameId)
-    val result = Try {
-      game.get.leaveGame(request.user.id)
-    }
-    if (result.isSuccess) {
-      Ok(Json.obj(
-        "status" -> "success",
-        "redirectUrl" -> routes.MainMenuController.mainMenu().url
-      ))
-    } else {
-      InternalServerError(Json.obj(
-        "status" -> "failure",
-        "errorMessage" -> "Something went wrong."
-      ))
-    }
+    game.get.leaveGame(request.user.id)
+    Redirect(routes.MainMenuController.mainMenu())
   }
   def joinGame(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
     val game = podManager.getGame(gameId)
@@ -251,10 +122,7 @@ class IngameController @Inject() (
     val game = podManager.getGame(gameId)
     game match {
       case Some(g) =>
-        val jsonBody = request.body.asJson
-        val cardIdOpt: Option[String] = jsonBody.flatMap { jsValue =>
-          (jsValue \ "cardID").asOpt[String]
-        }
+        val cardIdOpt = request.body.asFormUrlEncoded.flatMap(_.get("cardId").flatMap(_.headOption))
         cardIdOpt match {
           case Some(cardId) =>
             var optSession: Option[UserSession] = None
@@ -266,51 +134,27 @@ class IngameController @Inject() (
             }
             optSession.foreach(_.lock.unlock())
             if (result.isSuccess) {
-              Ok(Json.obj(
-                "status" -> "success",
-                "redirectUrl" -> routes.IngameController.game(gameId).url
-              ))
+              NoContent
             } else {
               val throwable = result.failed.get
               throwable match {
                 case _: CantPlayCardException =>
-                  BadRequest(Json.obj(
-                    "status" -> "failure",
-                    "errorMessage" -> throwable.getMessage
-                  ))
+                  BadRequest(throwable.getMessage)
                 case _: NotInThisGameException =>
-                  BadRequest(Json.obj(
-                    "status" -> "failure",
-                    "errorMessage" -> throwable.getMessage
-                  ))
+                  BadRequest(throwable.getMessage)
                 case _: IllegalArgumentException =>
-                  BadRequest(Json.obj(
-                    "status" -> "failure",
-                    "errorMessage" -> throwable.getMessage
-                  ))
+                  BadRequest(throwable.getMessage)
                 case _: IllegalStateException =>
-                  BadRequest(Json.obj(
-                    "status" -> "failure",
-                    "errorMessage" -> throwable.getMessage
-                  ))
+                  BadRequest(throwable.getMessage)
                 case _ =>
-                  InternalServerError(Json.obj(
-                    "status" -> "failure",
-                    "errorMessage" -> throwable.getMessage
-                  ))
+                  InternalServerError(throwable.getMessage)
               }
             }
           case None =>
-            BadRequest(Json.obj(
-              "status" -> "failure",
-              "errorMessage" -> "cardId Parameter is missing"
-            ))
+            BadRequest("cardId parameter is missing")
         }
       case None =>
-        NotFound(Json.obj(
-          "status" -> "failure",
-          "errorMessage" -> "Game not found"
-        ))
+        NotFound("Game not found")
     }
   }
   }
@@ -409,7 +253,7 @@ class IngameController @Inject() (
               val session = g.getUserSession(request.user.id)
               optSession = Some(session)
               session.lock.lock()
-              g.selectTie(g.getUserSession(request.user.id), tie.toInt)
+              g.selectTie(g.getUserSession(request.user.id), tie.toInt - 1)
             }
             optSession.foreach(_.lock.unlock())
             if (result.isSuccess) {