using Asp.Versioning;
using MetaAssets;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using StackExchange.Redis;
using UGQDataAccess.Repository;
using UGQDataAccess.Service;
using ServerCommon.UGQ.Models;
using System.Globalization;
using MongoDB.Driver.Linq;
using UGQApiServer.Converter;
using UGQDataAccess;
using ServerCommon.UGQ;
using UGQDatabase.Models;
using Amazon.Runtime.Internal;
using System.Security.Principal;
using Amazon.S3.Model;
using Microsoft.Extensions.Caching.Distributed;
using ServerCommon.BusinessLogDomain;
using ServerCommon;


namespace UGQApiServer.Controllers
{
    [ApiController]
    [ApiVersion("1.0")]
    [ApiExplorerSettings(GroupName = "ingame")]
    [Route("api/v{version:apiVersion}/[controller]")]
    [UGQInGameApi]
    public class InGameController : ControllerBase
    {
        InGameService _inGameService;
        IConnectionMultiplexer _redis;

        public InGameController(InGameService inGameService, IConnectionMultiplexer redis)
        {
            _inGameService = inGameService;
            _redis = redis;
        }

        /// <summary>
        /// userGuid의 UGQ 계정 정보 얻기
        /// </summary>
        [HttpGet]
        [Route("account/{userGuid}")]
        public async Task<IResult> getAccount(string userGuid)
        {
            (ServerErrorCode errorCode, var accountEntity) = await _inGameService.getAccount(userGuid);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            if (accountEntity == null)
                return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));

            return Results.Ok(new UgqAccount
            {
                GradeType = accountEntity.GradeType,
                CreatorPoint = accountEntity.CreatorPoint,
            });
        }

        /// <summary>
        /// 직접 작성한 퀘스트를 수락해서 완료까지 진행해보기 위해서 Test 상태인 퀘스트 리스트
        /// </summary>
        [HttpGet]
        [Route("user-quests-in-test-state/{userGuid}")]
        public async Task<IResult> getUserQuestsInTestState(string userGuid)
        {
            var result = await _inGameService.getUserQuests(userGuid, [QuestContentState.Test]);

            LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
            return Results.Ok(result.Select(x => x.ToProtoUgqQuestInTestState(langEnum, ImageUrlType.BannerImg)).ToList());
        }

        /// <summary>
        /// userGuid가 작성해서 Live 상태로 보낸 퀘스트 리스트
        /// </summary>
        [HttpGet]
        [Route("quest-board/{userGuid}")]
        public async Task<IResult> getUserQuestBoard(string userGuid, [FromQuery] UgqQuestBoardRequest request)
        {
            int pageSize = Math.Clamp(request.PageSize, 1, UGQConstants.MAX_INPUT_PAGE_SIZE);
            var result = await _inGameService.getQuestBoard(userGuid, request, pageSize);

            LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
            return Results.Ok(result.ToProto(langEnum, ImageUrlType.BannerImg));
        }

        /// <summary>
        /// 전체 Live 상태인 퀘스트 리스트
        /// </summary>
        [HttpGet]
        [Route("quest-board")]
        public async Task<IResult> getQuestBoard([FromQuery] UgqQuestBoardRequest request)
        {
            int pageSize = Math.Clamp(request.PageSize, 1, UGQConstants.MAX_INPUT_PAGE_SIZE);
            var result = await _inGameService.getQuestBoard(null, request, pageSize);

            LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
            return Results.Ok(result.ToProto(langEnum, ImageUrlType.BannerImg));
        }

        /// <summary>
        /// userGuid가 북마크한 Live 상태 퀘스트 리스트
        /// </summary>
        [HttpGet]
        [Route("bookmark-quest-board/{userGuid}")]
        public async Task<IResult> getBookmarkQuestBoard(string userGuid, [FromQuery] UgqQuestBoardRequest request)
        {
            int pageSize = Math.Clamp(request.PageSize, 1, UGQConstants.MAX_INPUT_PAGE_SIZE);
            var result = await _inGameService.getBookmarkQuests(userGuid, request, pageSize);

            LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
            return Results.Ok(result.ToProto(langEnum, ImageUrlType.BannerImg));
        }

        /// <summary>
        /// 퀘스트 스포트라이트
        /// </summary>
        [HttpGet]
        [Route("quest-board-spotlight")]
        public async Task<IResult> getQuestBoardSpotlight()
        {
            var result = await _inGameService.getQuestBoardSpotlight();

            LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
            return Results.Ok(result.ToProto(langEnum, ImageUrlType.TitleImg));
        }

        /// <summary>
        /// 퀘스트 자세한 정보
        /// </summary>
        [HttpGet]
        [Route("quest-board-detail/{userGuid}")]
        public async Task<IResult> getQuestBoardDetail(string userGuid, [FromQuery] UgqQuestIdRevisionRequest request)
        {
            var result = await _inGameService.getQuestBoardDetail(userGuid, request.QuestId, request.Revision);
            if (result == null)
                return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));

            LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
            return Results.Ok(result.ToProto(langEnum, ImageUrlType.BannerImg));
        }

        /// <summary>
        /// Test 상태인 퀘스트를 정상적으로 완료시켰을 때 호출해서 Standby 상태로 변경
        /// </summary>
        [HttpPost]
        [Route("set-test-completed/{userGuid}")]
        public async Task<IResult> setTestCompleted(string userGuid, [FromQuery] long questId, [FromQuery] long revision)
        {
            // 여기에서만 Test -> Standby 가능
            (var errorCode, var updated) = await _inGameService.changeQuestStateForInGame(userGuid,
                   questId, revision, [QuestContentState.Test], QuestContentState.Standby);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// Test 상태인 퀘스트를 포기했을 때 호출해서 Editable 상태로 변경
        /// </summary>
        [HttpPost]
        [Route("set-test-aborted/{userGuid}")]
        public async Task<IResult> setTestAborted(string userGuid, [FromQuery] long questId, [FromQuery] long revision)
        {
            // 여기에서만 Test -> Editable 가능
            (var errorCode, var updated) = await _inGameService.changeQuestStateForInGame(userGuid,
                   questId, revision, [QuestContentState.Test], QuestContentState.Editable);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 수락했을 때 호출
        /// </summary>
        [HttpPost]
        [Route("set-quest-accepted/{userGuid}")]
        public async Task<IResult> setQuestAccepted(string userGuid, UgqQuestAcceptedRequest request)
        {
            var errorCode = await _inGameService.setQuestAccepted(userGuid, request);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 완료했을 때 호출
        /// </summary>
        [HttpPost]
        [Route("set-quest-completed/{userGuid}")]
        public async Task<IResult> setQuestCompleted(string userGuid, UgqQuestCompletedRequest request)
        {
            var errorCode = await _inGameService.setQuestCompleted(userGuid, request);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 포기했을 때 호출
        /// </summary>
        [HttpPost]
        [Route("set-quest-aborted/{userGuid}")]
        public async Task<IResult> setQuestAbort(string userGuid, UgqQuestAbortedRequest request)
        {
            var errorCode = await _inGameService.setQuestAborted(userGuid, request);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 북마크
        /// </summary>
        [HttpPost]
        [Route("bookmark")]
        public async Task<IResult> bookmark(UgqBookmarkRequest request)
        {
            var errorCode = await _inGameService.bookmark(request.QuestId, request.UserGuid);
            if(errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 북마크 취소
        /// </summary>
        [HttpPost]
        [Route("unbookmark")]
        public async Task<IResult> unbookmark(UgqUnbookmarkRequest request)
        {
            var errorCode = await _inGameService.unbookmark(request.QuestId, request.UserGuid);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 좋아요
        /// </summary>
        [HttpPost]
        [Route("like")]
        public async Task<IResult> like(UgqLikeRequest request)
        {
            var errorCode = await _inGameService.like(request.QuestId, request.Revision, request.UserGuid);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 좋아요 취소
        /// </summary>
        [HttpPost]
        [Route("unlike")]
        public async Task<IResult> unlike(UgqUnlikeRequest request)
        {
            var errorCode = await _inGameService.unlike(request.QuestId, request.Revision, request.UserGuid);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// 퀘스트를 신고
        /// </summary>
        [HttpPost]
        [Route("report")]
        public async Task<IResult> report(UgqReportRequest request)
        {
            var errorCode = await _inGameService.report(request.UserGuid, request.QuestId, request.Revision, request.Contents);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            return Results.Ok();
        }

        /// <summary>
        /// Test 상태인 UGQ QuestScript 정보 얻기 (직접 작성한 퀘스트만 획득 가능)
        /// </summary>
        [HttpGet]
        [Route("test-game-quest-data/{userGuid}")]
        public async Task<IResult> getTestGameQuestData(string userGuid, [FromQuery] long questId, [FromQuery] long revision)
        {
            (ServerErrorCode errorCode, var gameQuestDataEntity) = await _inGameService.getTestGameQuestData(userGuid, questId, revision);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            if (gameQuestDataEntity == null)
                return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));

            return Results.Ok(gameQuestDataEntity);
        }

        /// <summary>
        /// Live 상태인 UGQ QuestScript 정보 얻기
        /// </summary>
        [HttpGet]
        [Route("game-quest-data")]
        public async Task<IResult> getGameQuestData([FromQuery] long questId, [FromQuery] long revision)
        {
            (ServerErrorCode errorCode, var gameQuestDataEntity) = await _inGameService.getGameQuestData(questId, revision, QuestContentState.Live);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            if (gameQuestDataEntity == null)
                return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));

            return Results.Ok(gameQuestDataEntity);
        }

        /// <summary>
        /// QuestScript 데이터 중 일부만 얻기
        /// </summary>
        [HttpGet]
        [Route("game-quest-data-simple")]
        public async Task<IResult> getGameQuestDataSimple([FromQuery] long questId, [FromQuery] long revision, [FromQuery] QuestContentState state)
        {
            (ServerErrorCode errorCode, var gameQuestDataEntity) = await _inGameService.getGameQuestData(questId, revision, state);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            if (gameQuestDataEntity == null)
                return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));

            return Results.Ok(gameQuestDataEntity.ToSimpleDTO());
        }

        /// <summary>
        /// 최신 리비전의 QuestScript 정보 얻기
        /// </summary>
        [HttpGet]
        [Route("latest-revision-game-quest-data")]
        public async Task<IResult> getLatestRevisionGameQuestData([FromQuery] long questId)
        {
            (ServerErrorCode errorCode, var gameQuestDataEntity) = await _inGameService.getLatestRevisionGameQuestData(questId);
            if (errorCode != ServerErrorCode.Success)
                return Results.BadRequest(ApiResponseFactory.error(errorCode));

            if (gameQuestDataEntity == null)
                return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));

            return Results.Ok(gameQuestDataEntity);
        }

        /// <summary>
        /// UGQ 로그인 상태를 레디스에서 삭제
        /// </summary>
        [HttpPost]
        [Route("clear-login/{userGuid}")]
        public async Task<IResult> clearLogin(string userGuid)
        {
            // ugq 로그인 상태를 삭제 시킨다.
            await _redis.GetDatabase().KeyDeleteAsync($"ugq_login:{userGuid}");
            return Results.Ok();
        }
    }
}