Shogi/Gameboard.ShogiUI.Sockets/Controllers/GameController.cs

using Gameboard.ShogiUI.Sockets.Extensions;
using Gameboard.ShogiUI.Sockets.Managers;
using Gameboard.ShogiUI.Sockets.Repositories;
using Gameboard.ShogiUI.Sockets.ServiceModels.Api;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket;
using Gameboard.ShogiUI.Sockets.ServiceModels.Types;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace Gameboard.ShogiUI.Sockets.Controllers
{

  [ApiController]
  [Route("[controller]")]
  [Authorize(Roles = "Shogi")]
  public class GameController : ControllerBase
  {
    private readonly IGameboardManager gameboardManager;
    private readonly IGameboardRepository gameboardRepository;
    private readonly ISocketConnectionManager communicationManager;

    public GameController(
      IGameboardRepository repository,
      IGameboardManager manager,
      ISocketConnectionManager communicationManager)
    {
      gameboardManager = manager;
      gameboardRepository = repository;
      this.communicationManager = communicationManager;
    }

    [HttpPost("JoinCode")]
    public async Task<IActionResult> PostGameInvitation([FromBody] PostGameInvitation request)
    {

      //var isPlayer1 = await gameboardManager.IsPlayer1(request.SessionName, userName);
      //if (isPlayer1)
      //{
      //  var code = await gameboardRepository.PostJoinCode(request.SessionName, userName);
      //  return new CreatedResult("", new PostGameInvitationResponse(code));
      //}
      //else
      //{
      return new UnauthorizedResult();
      //}
    }

    [AllowAnonymous]
    [HttpPost("GuestJoinCode")]
    public async Task<IActionResult> PostGuestGameInvitation([FromBody] PostGuestGameInvitation request)
    {

      //var isGuest = gameboardManager.IsGuest(request.GuestId);
      //var isPlayer1 = gameboardManager.IsPlayer1(request.SessionName, request.GuestId);
      //if (isGuest && await isPlayer1)
      //{
      //  var code = await gameboardRepository.PostJoinCode(request.SessionName, request.GuestId);
      //  return new CreatedResult("", new PostGameInvitationResponse(code));
      //}
      //else
      //{
      return new UnauthorizedResult();
      //}
    }

    [HttpPost("{gameName}/Move")]
    public async Task<IActionResult> PostMove([FromRoute] string gameName, [FromBody] PostMove request)
    {
      var user = await gameboardManager.ReadUser(User);
      var session = await gameboardRepository.ReadSession(gameName);

      if (session == null || user == null || (session.Player1 != user.Name && session.Player2 != user.Name))
      {
        throw new UnauthorizedAccessException("User is not seated at this game.");
      }

      var move = request.Move;
      var moveModel = move.PieceFromCaptured.HasValue
        ? new Models.Move(move.PieceFromCaptured.Value, move.To, move.IsPromotion)
        : new Models.Move(move.From!, move.To, move.IsPromotion);
      var moveSuccess = session.Shogi.Move(moveModel);

      if (moveSuccess)
      {
        var createSuccess = await gameboardRepository.CreateBoardState(session);
        if (!createSuccess)
        {
          throw new ApplicationException("Unable to persist board state.");
        }
        await communicationManager.BroadcastToPlayers(new MoveResponse
        {
          BoardState = session.Shogi.ToServiceModel(),
          Game = session.ToServiceModel(),
          MoveHistory = session.Shogi.MoveHistory.Select(h => h.ToServiceModel()).ToList(),
          PlayerPerspective = user.Name == session.Player1 ? WhichPlayer.Player1 : WhichPlayer.Player2
        }, session.Player1, session.Player2);
        return Ok();
      }
      throw new InvalidOperationException("Illegal move.");
    }
    // TODO: Use JWT tokens for guests so they can authenticate and use API routes, too.
    //[Route("")]
    //public async Task<IActionResult> PostSession([FromBody] PostSession request)
    //{
    //  var model = new Models.Session(request.Name, request.IsPrivate, request.Player1, request.Player2);
    //  var success = await repository.CreateSession(model);
    //  if (success)
    //  {
    //    var message = new ServiceModels.Socket.Messages.CreateGameResponse(ServiceModels.Types.ClientAction.CreateGame)
    //    {
    //      Game = model.ToServiceModel(),
    //      PlayerName =           
    //    }
    //    var task = request.IsPrivate
    //      ? communicationManager.BroadcastToPlayers(response, userName)
    //      : communicationManager.BroadcastToAll(response);
    //    return new CreatedResult("", null);
    //  }
    //  return new ConflictResult();
    //}

    [HttpPost]
    public async Task<IActionResult> PostSession([FromBody] PostSession request)
    {
      var user = await gameboardManager.ReadUser(User);
      var session = new Models.SessionMetadata(request.Name, request.IsPrivate, user!.Name);
      var success = await gameboardRepository.CreateSession(session);

      if (success)
      {
        await communicationManager.BroadcastToAll(new CreateGameResponse
        {
          Game = session.ToServiceModel(),
          PlayerName = user.Name
        });
        return Ok();
      }
      return Conflict();

    }

    /// <summary>
    /// Reads the board session and subscribes the caller to socket events for that session.
    /// </summary>
    [HttpGet("{gameName}")]
    public async Task<IActionResult> GetSession([FromRoute] string gameName)
    {
      var user = await gameboardManager.ReadUser(User);
      var session = await gameboardRepository.ReadSession(gameName);
      if (session == null)
      {
        return NotFound();
      }

      communicationManager.SubscribeToGame(session, user!.Name);
      var response = new GetGameResponse()
      {
        Game = new Models.SessionMetadata(session).ToServiceModel(),
        BoardState = session.Shogi.ToServiceModel(),
        MoveHistory = session.Shogi.MoveHistory.Select(_ => _.ToServiceModel()).ToList(),
        PlayerPerspective = user.Name == session.Player1 ? WhichPlayer.Player1 : WhichPlayer.Player2
      };
      return new JsonResult(response);
    }

    [HttpGet]
    public async Task<IActionResult> GetSessions()
    {
      var sessions = await gameboardRepository.ReadSessionMetadatas();
      return new JsonResult(sessions.Select(s => s.ToServiceModel()).ToList());
    }
  }
}