Kitty_Fall_Mytel/Kitty_Fall/Kitty_Fall/Kitty_Fall.Website/Controllers/GameController.cs

using Common.Extension;
using Common.Http.Apis.Request;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

namespace Kitty_Fall.Website.Controllers
{
    public class GameController : Controller
    {
        private const string CompletedGameTransIdSessionKey = "completedGameTransId";
        private static readonly log4net.ILog log = log4net.LogManager.GetLogger(typeof(GameController));
        private readonly IConfiguration _configuration;

        public GameController(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        [HttpPost]
        public async Task<IActionResult> StartSession([FromBody] UserGameLevelResultReq request)
        {
            try
            {
                var completedTransId = HttpContext.Session.GetString(CompletedGameTransIdSessionKey);
                if (!string.IsNullOrWhiteSpace(request.transId)
                    && string.Equals(request.transId, completedTransId, StringComparison.Ordinal))
                {
                    request.transId = Guid.NewGuid().ToString("N");
                }

                var apiResult = await SendGameApiAsync(request, UrlConstant.GameStartSessionUrl);
                if (apiResult.errorCode != "0"
                    && string.Equals(apiResult.data?.reason, "SESSION_CLOSED", StringComparison.OrdinalIgnoreCase))
                {
                    // The browser can still hold the completed run's ID (for example
                    // after iframe navigation/cache). Start a genuinely new run once;
                    // never reuse or reopen the closed API session.
                    request.transId = Guid.NewGuid().ToString("N");
                    apiResult = await SendGameApiAsync(request, UrlConstant.GameStartSessionUrl);
                }

                if (apiResult.errorCode == "0" && apiResult.data != null)
                {
                    var maxLevel = await GetTodayMaxLevelAsync(request);
                    HttpContext.Session.SetComplexData("totalTurn", (long)apiResult.data.totalTurn);

                    return Json(new
                    {
                        success = true,
                        point = apiResult.data.point,
                        data = apiResult.data.data,
                        score = apiResult.data.score,
                        transId = apiResult.data.transId,
                        totalTurn = apiResult.data.totalTurn,
                        max_level = maxLevel
                    });
                }

                return Json(new
                {
                    success = false,
                    reason = apiResult.data?.reason ?? "",
                    message = apiResult.message ?? "Start game failed."
                });
            }
            catch (Exception ex)
            {
                log.Error("StartSession error: ", ex);
                return Json(new { success = false, message = ex.Message });
            }
        }

        [HttpPost]
        public async Task<IActionResult> SaveLevelResult([FromBody] UserGameLevelResultReq request)
        {
            try
            {
                var apiResult = await SendGameApiAsync(request, UrlConstant.GameSaveLevelResultUrl);
                if (apiResult.data != null)
                {
                    if (request.gameOver != 0 && apiResult.errorCode == "0")
                    {
                        HttpContext.Session.SetString(CompletedGameTransIdSessionKey, request.transId ?? "");
                    }

                    return Json(new
                    {
                        point = apiResult.data.point,
                        data = apiResult.data.data,
                        score = apiResult.data.score,
                        transId = apiResult.data.transId,
                        rewardType = apiResult.data.rewardType,
                        rewardValue = apiResult.data.rewardValue,
                        rewardUnit = apiResult.data.rewardUnit,
                        success = apiResult.errorCode == "0"
                    });
                }

                return Json(new
                {
                    point = "0",
                    data = "",
                    // Khong tra lai score cu cua level truoc khi API ghi level loi.
                    score = "0",
                    transId = request.transId ?? "",
                    rewardType = "",
                    rewardValue = 0,
                    rewardUnit = "",
                    success = false,
                    message = apiResult.message ?? "Save level result failed."
                });
            }
            catch (Exception ex)
            {
                log.Error("SaveLevelResult error: ", ex);
                return Json(new { success = false, message = ex.Message });
            }
        }

        [HttpPost]
        public async Task<IActionResult> ExitGame(UserGameLevelResultReq request)
        {
            try
            {
                log.Info($"ExitGame msisdn={request.msisdn}, transId={request.transId}, level={request.level}, score={request.score}, gameType={request.gameType}, gameOver={request.gameOver}");
                request.gameOver = request.gameOver == 0 ? 1 : request.gameOver;
                var apiResult = await SendGameApiAsync(request, UrlConstant.GameSaveLevelResultUrl);
                if (apiResult.errorCode == "0" && apiResult.data != null)
                {
                    HttpContext.Session.SetComplexData("totalTurn", (long)apiResult.data.totalTurn);
                    HttpContext.Session.SetString(CompletedGameTransIdSessionKey, request.transId ?? "");
                }
                var payload = JsonSerializer.Serialize(new
                {
                    type = "EXIT_GAME_RESULT",
                    success = apiResult.errorCode == "0",
                    score = apiResult.data?.score ?? request.score.ToString(),
                    data = apiResult.data?.totalDataMb ?? 0,
                    loyalty = apiResult.data?.totalLoyalty ?? 0,
                    totalTurn = apiResult.data?.totalTurn,
                    level = request.level,
                    message = apiResult.message ?? ""
                });
                var callbackHtml = $"""
                    <!doctype html>
                    <html><head><meta charset="utf-8"></head><body>
                    <script>window.parent.postMessage({payload}, "*");</script>
                    </body></html>
                    """;
                return Content(callbackHtml, "text/html; charset=utf-8");
            }
            catch (Exception ex)
            {
                log.Error("ExitGame error: ", ex);
                return Json(new { success = false, message = ex.Message });
            }
        }

        private async Task<UserGameLevelResultRes> SendGameApiAsync(UserGameLevelResultReq request, string apiPath)
        {
            var msisdn = HttpContext.Session.GetComplexData<string>("msisdn") ?? request.msisdn ?? "";
            var apiToken = HttpContext.Session.GetString("apiToken") ?? request.token ?? "";
            var language = GetCurrentLanguage();
            request.msisdn = msisdn;
            request.token = apiToken;
            request.language = language;

            var baseUrl = GetParameter("url");
            if (string.IsNullOrWhiteSpace(baseUrl) || string.IsNullOrWhiteSpace(apiToken))
            {
                return new UserGameLevelResultRes("{\"errorCode\":1,\"message\":\"Please login again.\",\"status\":false,\"data\":{}}");
            }

            var postTask = DotnetLib.Rest.RestHandler.SendPostWithAuthen(
                log,
                baseUrl + apiPath,
                request,
                apiToken,
                "",
                "",
                language);

            if (postTask == null)
            {
                return new UserGameLevelResultRes("{\"errorCode\":1,\"message\":\"Game API returned empty response.\",\"status\":false,\"data\":{}}");
            }

            var response = await postTask;
            if (response?.data == null)
            {
                return new UserGameLevelResultRes("{\"errorCode\":1,\"message\":\"Game API returned empty response.\",\"status\":false,\"data\":{}}");
            }

            return new UserGameLevelResultRes(response.data);
        }

        private async Task<int> GetTodayMaxLevelAsync(UserGameLevelResultReq request)
        {
            const int defaultLevel = 1;

            try
            {
                var baseUrl = GetParameter("url");
                var apiToken = HttpContext.Session.GetString("apiToken") ?? request.token ?? "";
                var msisdn = HttpContext.Session.GetComplexData<string>("msisdn") ?? request.msisdn ?? "";
                var language = GetCurrentLanguage();

                if (string.IsNullOrWhiteSpace(baseUrl)
                    || string.IsNullOrWhiteSpace(apiToken)
                    || string.IsNullOrWhiteSpace(msisdn)
                    || string.IsNullOrWhiteSpace(request.gameType))
                {
                    return defaultLevel;
                }

                var today = DateTime.Today.ToString("yyyy-MM-dd");
                var historyRequest = new UserGameActivityHistoryReq
                {
                    msisdn = msisdn,
                    language = language,
                    fromDate = today,
                    toDate = today,
                    pageNumber = 1,
                    pageSize = 1000
                };

                var postTask = DotnetLib.Rest.RestHandler.SendPostWithAuthen(
                    log,
                    baseUrl + UrlConstant.GameActivityHistoryUrl,
                    historyRequest,
                    apiToken,
                    "",
                    "",
                    language);

                if (postTask == null)
                    return defaultLevel;

                var response = await postTask;
                if (response?.data == null)
                    return defaultLevel;

                var history = new UserGameActivityHistoryRes(response.data).data;
                if (history?.items == null)
                    return defaultLevel;

                var maxLevel = history.items
                    .Where(item =>
                        string.Equals(item.modeCode, request.gameType, StringComparison.OrdinalIgnoreCase)
                        || string.Equals(item.modeName, request.gameType, StringComparison.OrdinalIgnoreCase))
                    .Select(item => item.levelNo)
                    .DefaultIfEmpty(defaultLevel)
                    .Max();

                return Math.Clamp(maxLevel, defaultLevel, 50);
            }
            catch (Exception ex)
            {
                log.Warn("GetTodayMaxLevel failed; using level 1.", ex);
                return defaultLevel;
            }
        }

        private string GetParameter(string key)
        {
            return _configuration.GetSection(key).Value
                ?? _configuration.GetSection("Url").Value
                ?? "";
        }

        private string GetCurrentLanguage()
        {
            var sessionLang = HttpContext.Session.GetComplexData<string>("culture");
            if (!string.IsNullOrWhiteSpace(sessionLang)) return sessionLang;
            return System.Globalization.CultureInfo.CurrentUICulture.Name.StartsWith("vi", StringComparison.OrdinalIgnoreCase) ? "vi" : "en";
        }
    }
}