API/TOOHUCardAPI/Controllers/PlayerDataController.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Threading.Tasks;
using AutoMapper;
using AutoMapper.QueryableExtensions;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TOOHUCardAPI.Data;
using TOOHUCardAPI.Data.Models;
using TOOHUCardAPI.Data.Repositories;
using TOOHUCardAPI.Data.Services;
using TOOHUCardAPI.DTO;
using TOOHUCardAPI.DTO.PlayerData;

namespace TOOHUCardAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class PlayerDataController : MethodBasedController<PlayerDataController>
    {
        private readonly ILogger<PlayerDataController> _logger;
        private readonly UserService _userService;
        private readonly IMapper _mapper;
        private readonly StoreService _storeService;

        public PlayerDataController(ILogger<PlayerDataController> logger, UserService userService, IMapper mapper, StoreService storeService)
        {
            _logger = logger;
            _userService = userService;
            _mapper = mapper;
            _storeService = storeService;
        }

        [EndpointHandler("save_pet_custom")]
        private async Task<IActionResult> SavePetData(string body)
        {
            PlayerDataSavePetCustomRequest
                request = JsonConvert.DeserializeObject<PlayerDataSavePetCustomRequest>(body);
            await _userService.SavePetData(request.SteamId, request.PetModel, request.PetEffect);
            return Ok(new OkResponse());
        }

        [EndpointHandler("save_power_max")]
        private async Task<IActionResult> SavePowerMax(string body)
        {
            PlayerDataSavePowerMaxTotalRequest request =
                JsonConvert.DeserializeObject<PlayerDataSavePowerMaxTotalRequest>(body);
            await _storeService.ChangePowerMaxTotal(request.SteamId, request.Op == "add" ? 1 : -1);
            return Ok(new OkResponse());
        }

        [EndpointHandler("save_card_level")]
        private async Task<IActionResult> SaveCardLevel(string body)
        {
            PlayerDataSaveCardLevelRequest request = JsonConvert.DeserializeObject<PlayerDataSaveCardLevelRequest>(body);
            int totalCost = await _storeService.LevelUpCard(request.SteamId, request.CardItemCode, request.LevelIncrease);
            return Ok(new PlayerDataSaveCardLevelResponse
            {
                TotalCost = totalCost
            });
        }

        [EndpointHandler("day_first_win")]
        private async Task<IActionResult> GiveFirstWin(string body)
        {
            PlayerDataFirstWinRequest request = JsonConvert.DeserializeObject<PlayerDataFirstWinRequest>(body);
            var bonusPoints = await _storeService.GiveFirstWinBonus(request.SteamId);

            return Ok(new PlayerDataFirstWinResponse
            {
                BonusPoints = bonusPoints
            });
        }

        [EndpointHandler("save_key_count")]
        private async Task<IActionResult> SaveKeyCount(string body)
        {
            PlayerDataSaveKeyCountRequest request = JsonConvert.DeserializeObject<PlayerDataSaveKeyCountRequest>(body);
            await _storeService.SaveKeyTotal(request.SteamId, request.KeyTotal, request.KeyUseCount);
            return Ok(new OkResponse());
        }

        [EndpointHandler("buy_key")]
        private async Task<IActionResult> BuyMagicKey(string body)
        {
            PlayerDataBuyMagicKeyRequest request = JsonConvert.DeserializeObject<PlayerDataBuyMagicKeyRequest>(body);

            var totalCost = await _storeService.PurchaseMagicKey(request.Count, request.SteamId);
            
            return Ok(new PlayerDataBuyMagicKeyResponse
            {
                TotalCost = totalCost
            });
        }

        [EndpointHandler("save_card_group")]
        private async Task<IActionResult> SaveCardGroup(string body)
        {
            PlayerDataSaveCardGroupRequest request =
                JsonConvert.DeserializeObject<PlayerDataSaveCardGroupRequest>(body);
            await _userService.SaveCardGroup(request.SteamId, request.GroupKey, request.GroupData);
            return Ok(new OkResponse());
        }

        [EndpointHandler("get")]
        private async Task<IActionResult> Get(string body)
        {
            PlayerDataGetRequestObject requestObject = JsonConvert.DeserializeObject<PlayerDataGetRequestObject>(body);
            IEnumerable<User> users = new List<User>();
            foreach (var val in requestObject.Ids.Values)
            {
                users = users.Append(await _userService.LoginUser(val)); // threading errors
            }
            IEnumerable<long> queriedUserSteamIds = requestObject.Ids.Select(i => i.Value);
            IEnumerable<PlayerDataGetResponseObjectPlayer> responsePlayers = users
                .Where(user => queriedUserSteamIds.Contains(user.SteamId))
                .Select(user => user.ToGetResponse(_mapper));
            Dictionary<int, PlayerDataGetResponseObjectPlayer> playersStatic = requestObject.Ids
                .Select(pair =>
                    KeyValuePair.Create(pair.Key, responsePlayers.FirstOrDefault(resp => resp.SteamId == pair.Value)))
                .ToDictionary(kv => kv.Key, kv => kv.Value);
            Dictionary<int, Dictionary<string, object>> dynamicResponses = playersStatic
                    .Select(kv =>
                    {
                        var obj = JsonConvert.DeserializeObject<Dictionary<string, object>>(JsonConvert.SerializeObject(kv.Value));
                        return KeyValuePair.Create(kv.Key, obj);
                    })
                    .ToDictionary(kv => kv.Key, kv => kv.Value);
            foreach (var kv in dynamicResponses)
            {
                var props = kv.Value;
                var user = users.FirstOrDefault(user1 => user1.SteamId == requestObject.Ids[kv.Key]);
                foreach (var cardgroup in user.EncodedCardGroups ?? new List<EncodedCardGroup>())
                {
                    props[$"{cardgroup.GroupKey}"] = cardgroup.EncodedString;
                }
            }
            PlayerDataGetResponseObject response = new PlayerDataGetResponseObject()
            {
                Players = dynamicResponses
            };

            return Ok(response);
        }
        
    }
}