Shogi/Gameboard.ShogiUI.Sockets/Repositories/GameboardRepository.cs

using Gameboard.ShogiUI.Sockets.Repositories.CouchModels;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

namespace Gameboard.ShogiUI.Sockets.Repositories
{
  public interface IGameboardRepository
  {
    Task<bool> CreateBoardState(string sessionName, Models.BoardState boardState, Models.Move? move);
    Task<bool> CreateGuestUser(string userName);
    Task<bool> CreateSession(Models.Session session);
    Task<IList<Models.Session>> ReadSessions();
    Task<bool> IsGuestUser(string userName);
    Task<string> PostJoinCode(string gameName, string userName);
    Task<Models.Session?> ReadSession(string name);
    Task<IList<Models.BoardState>> ReadBoardStates(string name);
  }

  public class GameboardRepository : IGameboardRepository
  {
    private const string ApplicationJson = "application/json";
    private readonly HttpClient client;
    private readonly ILogger<GameboardRepository> logger;

    public GameboardRepository(IHttpClientFactory clientFactory, ILogger<GameboardRepository> logger)
    {
      client = clientFactory.CreateClient("couchdb");
      this.logger = logger;
    }

    public async Task<IList<Models.Session>> ReadSessions()
    {
      var selector = $@"{{ ""{nameof(Session.Type)}"": ""{nameof(Session)}"" }}";
      var query = $@"{{ ""selector"": {selector} }}";
      var content = new StringContent(query, Encoding.UTF8, ApplicationJson);
      var response = await client.PostAsync("_find", content);
      var responseContent = await response.Content.ReadAsStringAsync();
      var result = JsonConvert.DeserializeObject<CouchFindResult<Session>>(responseContent);

      if (result == null)
      {
        logger.LogError("Unable to deserialize couchdb result during {0}.", nameof(this.ReadSessions));
        return Array.Empty<Models.Session>();
      }
      return result.docs
        .Select(_ => _.ToDomainModel())
        .ToList();
    }

    public async Task<Models.Session?> ReadSession(string name)
    {
      var response = await client.GetAsync(name);
      var responseContent = await response.Content.ReadAsStringAsync();
      var couchModel = JsonConvert.DeserializeObject<Session>(responseContent);
      return couchModel.ToDomainModel();
    }

    public async Task<IList<Models.BoardState>> ReadBoardStates(string name)
    {
      var selector = $@"{{ ""{nameof(BoardState.Type)}"": ""{nameof(BoardState)}"", ""{nameof(BoardState.Name)}"": ""{name}"" }}";
      var sort = $@"{{ ""{nameof(BoardState.CreatedDate)}"" : ""desc"" }}";
      var query = $@"{{ ""selector"": {selector}, ""sort"": {sort} }}";
      var content = new StringContent(query, Encoding.UTF8, ApplicationJson);
      var response = await client.PostAsync("_find", content);
      var responseContent = await response.Content.ReadAsStringAsync();
      var result = JsonConvert.DeserializeObject<CouchFindResult<BoardState>>(responseContent);

      if (result == null)
      {
        logger.LogError("Unable to deserialize couchdb result during {0}.", nameof(this.ReadSessions));
        return Array.Empty<Models.BoardState>();
      }
      return result.docs
        .Select(_ => new Models.BoardState(_))
        .ToList();
    }

    //public async Task DeleteGame(string gameName)
    //{
    //  //var uri = $"Session/{gameName}";
    //  //await client.DeleteAsync(Uri.EscapeUriString(uri));
    //}

    public async Task<bool> CreateSession(Models.Session session)
    {
      var couchModel = new Session(session.Name, session);
      var content = new StringContent(JsonConvert.SerializeObject(couchModel), Encoding.UTF8, ApplicationJson);
      var response = await client.PostAsync(string.Empty, content);
      return response.IsSuccessStatusCode;
    }

    public async Task<bool> CreateBoardState(string sessionName, Models.BoardState boardState, Models.Move? move)
    {
      var couchModel = new BoardState(sessionName, boardState, move);
      var content = new StringContent(JsonConvert.SerializeObject(couchModel), Encoding.UTF8, ApplicationJson);
      var response = await client.PostAsync(string.Empty, content);
      return response.IsSuccessStatusCode;
    }

    //public async Task<bool> PutJoinPublicSession(PutJoinPublicSession request)
    //{
    //  var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, MediaType);
    //  var response = await client.PutAsync(JoinSessionRoute, content);
    //  var json = await response.Content.ReadAsStringAsync();
    //  return JsonConvert.DeserializeObject<PutJoinPublicSessionResponse>(json).JoinSucceeded;
    //}

    //public async Task<string> PostJoinPrivateSession(PostJoinPrivateSession request)
    //{
    //  var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, MediaType);
    //  var response = await client.PostAsync(JoinSessionRoute, content);
    //  var json = await response.Content.ReadAsStringAsync();
    //  var deserialized = JsonConvert.DeserializeObject<PostJoinPrivateSessionResponse>(json);
    //  if (deserialized.JoinSucceeded)
    //  {
    //    return deserialized.SessionName;
    //  }
    //  return null;
    //}

    //public async Task<List<Move>> GetMoves(string gameName)
    //{
    //  var uri = $"Session/{gameName}/Moves";
    //  var get = await client.GetAsync(Uri.EscapeUriString(uri));
    //  var json = await get.Content.ReadAsStringAsync();
    //  if (string.IsNullOrWhiteSpace(json))
    //  {
    //    return new List<Move>();
    //  }
    //  var response = JsonConvert.DeserializeObject<GetMovesResponse>(json);
    //  return response.Moves.Select(m => new Move(m)).ToList();
    //}

    //public async Task PostMove(string gameName, PostMove request)
    //{
    //  var uri = $"Session/{gameName}/Move";
    //  var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, MediaType);
    //  await client.PostAsync(Uri.EscapeUriString(uri), content);
    //}

    public async Task<string> PostJoinCode(string gameName, string userName)
    {
      //  var uri = $"JoinCode/{gameName}";
      //  var serialized = JsonConvert.SerializeObject(new PostJoinCode { PlayerName = userName });
      //  var content = new StringContent(serialized, Encoding.UTF8, MediaType);
      //  var json = await (await client.PostAsync(Uri.EscapeUriString(uri), content)).Content.ReadAsStringAsync();
      //  return JsonConvert.DeserializeObject<PostJoinCodeResponse>(json).JoinCode;
      return string.Empty;
    }

    //public async Task<Player> GetPlayer(string playerName)
    //{
    //  var uri = $"Player/{playerName}";
    //  var get = await client.GetAsync(Uri.EscapeUriString(uri));
    //  var content = await get.Content.ReadAsStringAsync();
    //  if (!string.IsNullOrWhiteSpace(content))
    //  {
    //    var response = JsonConvert.DeserializeObject<GetPlayerResponse>(content);
    //    return new Player(response.Player.Name);
    //  }
    //  return null;
    //}

    public async Task<bool> CreateGuestUser(string userName)
    {
      var couchModel = new User(userName, User.LoginPlatform.Guest);
      var content = new StringContent(JsonConvert.SerializeObject(couchModel), Encoding.UTF8, ApplicationJson);
      var response = await client.PostAsync(string.Empty, content);
      return response.IsSuccessStatusCode;
    }

    public async Task<bool> IsGuestUser(string userName)
    {
      var req = new HttpRequestMessage(HttpMethod.Head, new Uri($"{client.BaseAddress}/{User.GetDocumentId(userName)}"));
      var response = await client.SendAsync(req);
      return response.IsSuccessStatusCode;
    }
  }
}