using MongoDB.Driver;
using UGQDatabase.Models;
using UGQDataAccess.Repository;
using UGQDataAccess.Repository.Models;
using ServerCommon.UGQ;
using ServerCommon.UGQ.Models;
using System.Text.Json;
using Amazon.DynamoDBv2.Model;
using ServerCommon.BusinessLogDomain;
using ServerCommon;
using MetaAssets;

namespace UGQDataAccess.Service;


public class InGameService
{
    readonly QuestContentRepository _questContentRepository;
    readonly QuestDialogRepository _questDialogRepository;
    readonly LikeRepository _likeRepository;
    readonly BookmarkRepository _bookmarkRepository;
    readonly NpcNameRepository _npcNameRepository;
    readonly GameQuestDataRepository _gameQuestDataRepository;
    readonly ReportRepository _reportRepository;
    readonly AccountRepository _accountRepository;
    readonly QuestAcceptedRepository _questAccceptedRepository;
    readonly QuestCompletedRepository _questCompletedRepository;
    readonly QuestAbortedRepository _questAbortedRepository;
    readonly CreatorPointHistoryRepository _creatorPointHistoryRepository;

    readonly AccountService _accountService;

    public InGameService(
        AccountService accountService,
        QuestContentRepository questContentRepository,
        QuestDialogRepository questDialogRepository,
        LikeRepository likeRepository,
        BookmarkRepository bookmarkRepository,
        NpcNameRepository npcNameRepository,
        GameQuestDataRepository gameQuestDataRepository,
        ReportRepository reportRepository,
        AccountRepository accountRepository,
        QuestAcceptedRepository accceptedRepository,
        QuestCompletedRepository completedRepository,
        QuestAbortedRepository questAbortedRepository,
        CreatorPointHistoryRepository creatorPointHistoryRepository)
    {
        _accountService = accountService;
        _questContentRepository = questContentRepository;
        _questDialogRepository = questDialogRepository;
        _likeRepository = likeRepository;
        _bookmarkRepository = bookmarkRepository;
        _npcNameRepository = npcNameRepository;
        _gameQuestDataRepository = gameQuestDataRepository;
        _reportRepository = reportRepository;
        _accountRepository = accountRepository;

        _questAccceptedRepository = accceptedRepository;
        _questCompletedRepository = completedRepository;
        _questAbortedRepository = questAbortedRepository;

        _creatorPointHistoryRepository = creatorPointHistoryRepository;
    }

    public async Task<(ServerErrorCode, AccountEntity?)> getAccount(string userGuid)
    {
        AccountEntity? entity = await _accountRepository.get(userGuid);
        if (entity == null)
            return (ServerErrorCode.UgqNullEntity, null);

        return (ServerErrorCode.Success, entity);
    }

    public async Task<List<QuestContentEntity>> getUserQuests(string userGuid, IEnumerable<QuestContentState> states)
    {
        return await _questContentRepository.getUserQuests(userGuid, states);
    }

    public async Task<QuestBoardQueryResult> getQuestBoard(string? userGuid, UgqQuestBoardRequest request, int pageSize)
    {
        return await _questContentRepository.getQuestBoard(userGuid, request, pageSize);
    }

    public async Task<QuestBoardQueryResult> getBookmarkQuests(string userGuid, UgqQuestBoardRequest request, int pageSize)
    {
        return await _questContentRepository.getBookmarkQuests(userGuid, request, pageSize);
    }

    public async Task<QuestBoardSportlightQueryResult> getQuestBoardSpotlight()
    {
        return await _questContentRepository.getQuestBoardSpotlight();
    }

    public async Task<QuestBoardDetailItemResult?> getQuestBoardDetail(string userGuid, long questId, long revision)
    {
        return await _questContentRepository.getQuestBoardDetail(userGuid, questId, revision);
    }

    public async Task<ServerErrorCode> bookmark(long questId, string userGuid)
    {
        var entity = await _bookmarkRepository.get(questId, userGuid);
        if (entity != null)
            return ServerErrorCode.UgqAlreadyBookmarked;

        return await _bookmarkRepository.insert(questId, userGuid);
    }

    public async Task<ServerErrorCode> unbookmark(long questId, string userGuid)
    {
        var entity = await _bookmarkRepository.get(questId, userGuid);
        if (entity == null)
            return ServerErrorCode.UgqNotBookmarked;

        return await _bookmarkRepository.delete(questId, userGuid);
    }

    public async Task<ServerErrorCode> like(long questId, long revision, string userGuid)
    {
        var entity = await _likeRepository.get(questId, userGuid);
        if (entity != null)
            return ServerErrorCode.UgqAlreadyLiked;

        return await _likeRepository.insert(questId, revision, userGuid);
    }

    public async Task<ServerErrorCode> unlike(long questId, long revision, string userGuid)
    {
        var entity = await _likeRepository.get(questId, userGuid);
        if (entity == null)
            return ServerErrorCode.UgqNotLiked;

        return await _likeRepository.delete(questId, revision, userGuid);
    }

    public async Task<ServerErrorCode> report(string userGuid, long questId, long revision, string contents)
    {
        var entity = await _reportRepository.get(questId, revision, userGuid);
        if (entity != null)
            return ServerErrorCode.UgqAlreadyReported;

        await _reportRepository.insert(questId, revision, userGuid, contents);
        return ServerErrorCode.Success;
    }

    public async Task<ServerErrorCode> setQuestAccepted(string userGuid, UgqQuestAcceptedRequest request)
    {
        var gameQuestData = await _gameQuestDataRepository.get(request.QuestId, request.Revision, QuestContentState.Live);
        if (gameQuestData == null)
            return ServerErrorCode.UgqNullEntity;

        string author = gameQuestData.UserGuid;

        await _questAccceptedRepository.insert(request.QuestId, request.Revision, author, request.Reason, userGuid);
        return ServerErrorCode.Success;
    }

    public async Task<ServerErrorCode> setQuestCompleted(string userGuid, UgqQuestCompletedRequest request)
    {
        var gameQuestData = await _gameQuestDataRepository.get(request.QuestId, request.Revision, QuestContentState.Live);
        if (gameQuestData == null)
            return ServerErrorCode.UgqNullEntity;

        string author = gameQuestData.UserGuid;

        await _questCompletedRepository.insert(request.QuestId, request.Revision, author, userGuid);

        double cost = 0.0f;
        switch (gameQuestData.GradeType)
        {
            case UgqGradeType.Amature: cost = MetaHelper.GameConfigMeta.UgqUsageFeeAmateur / 2.0f; break;
            case UgqGradeType.RisingStar: cost = MetaHelper.GameConfigMeta.UgqUsageFeeRisingStar / 10.0f; break;
            case UgqGradeType.Master1: cost = MetaHelper.GameConfigMeta.UgqUsageFeeMaster1 / 2.0f; break;
            case UgqGradeType.Master2: cost = MetaHelper.GameConfigMeta.UgqUsageFeeMaster2 / 2.0f; break;
            case UgqGradeType.Master3: cost = MetaHelper.GameConfigMeta.UgqUsageFeeMaster3 / 2.0f; break;
            default:
                return ServerErrorCode.UgqCurrencyError;
        }        
/*
        long completeCount = await _questCompletedRepository.getCount(author);
        if(completeCount >= MetaHelper.GameConfigMeta.UGQPromoteConditionRisingstar)
        {
            await _accountService.promoteAccountGrade(author, UgqGradeType.Amature, UgqGradeType.RisingStar);
        }
*/

        return await _accountService.addCreatorPoint(author, request.QuestId, request.Revision, cost, UgqCreatorPointReason.QuestCompleted);
       
    }

    public async Task<ServerErrorCode> setQuestAborted(string userGuid, UgqQuestAbortedRequest request)
    {
        var gameQuestData = await _gameQuestDataRepository.get(request.QuestId, request.Revision, QuestContentState.Live);
        if (gameQuestData == null)
            return ServerErrorCode.UgqNullEntity;

        string author = gameQuestData.UserGuid;

        await _questAbortedRepository.insert(request.QuestId, request.Revision, author, request.Reason, userGuid);
        return ServerErrorCode.Success;
    }

    public async Task<(ServerErrorCode, QuestContentEntity?)> changeQuestStateForInGame(string userGuid,
        long questId, long revision,
        IEnumerable<QuestContentState> before, QuestContentState after)
    {
        var content = await _questContentRepository.getByQuestIdRevision(questId, revision);
        if (content == null)
            return (ServerErrorCode.UgqNullEntity, null);

        var errorCode = ServerErrorCode.Success;
        QuestContentEntity? updated = null;
        switch (after)
        {
            case QuestContentState.Standby:
                updated = await _questContentRepository.updateState(content.Id,
                    content.QuestId, content.Revision, before, after);
                break;
            case QuestContentState.Editable:
                updated = await _questContentRepository.updateState(content.Id,
                    content.QuestId, content.Revision, before, after);

                // ÀÌÀü Test µ¥ÀÌÅÍ´Â »èÁ¦.
                await _gameQuestDataRepository.delete(content.QuestId, content.Revision, QuestContentState.Test);
                break;
            default:
                errorCode = ServerErrorCode.UgqStateChangeError;
                break;
        }

        if (updated == null)
            return (ServerErrorCode.UgqStateChangeError, null);

        return (errorCode, updated);
    }

    public async Task<(ServerErrorCode, GameQuestDataEntity?)> getTestGameQuestData(string userGuid, long questId, long revision)
    {
        GameQuestDataEntity? entity = await _gameQuestDataRepository.get(questId, revision, QuestContentState.Test);
        if (entity == null)
            return (ServerErrorCode.UgqNullEntity, null);

        // ³»°¡ ÀÛ¼ºÇÑ Äù½ºÆ® Áß Test »óÅÂÀÎ °Í¸¸ °¡´É
        if (entity.UserGuid != userGuid)
            return (ServerErrorCode.UgqNotOwnQuest, null);

        return (ServerErrorCode.Success, entity);
    }

    public async Task<(ServerErrorCode, GameQuestDataEntity?)> getGameQuestData(long questId, long revision, QuestContentState state)
    {
        GameQuestDataEntity? entity = await _gameQuestDataRepository.get(questId, revision, state);
        if(entity == null)
            return (ServerErrorCode.UgqNullEntity, null);

        return (ServerErrorCode.Success, entity);
    }

    public async Task<(ServerErrorCode, GameQuestDataEntity?)> getLatestRevisionGameQuestData(long questId)
    {
        GameQuestDataEntity? entity = await _gameQuestDataRepository.getLatestRevision(questId);
        if (entity == null)
            return (ServerErrorCode.UgqNullEntity, null);

        return (ServerErrorCode.Success, entity);
    }

    public async Task setAuthor()
    {
        {
            var list = await _questAbortedRepository.getAll();
            foreach (var item in list)
            {
                var gameQuestData = await _gameQuestDataRepository.get(item.QuestId, item.Revision, QuestContentState.Live);
                if (gameQuestData == null)
                    continue;

                string author = gameQuestData.UserGuid;
                await _questAbortedRepository.setAuthor(item.Id, author);
            }
        }

        {
            var list = await _questAccceptedRepository.getAll();
            foreach (var item in list)
            {
                var gameQuestData = await _gameQuestDataRepository.get(item.QuestId, item.Revision, QuestContentState.Live);
                if (gameQuestData == null)
                    continue;

                string author = gameQuestData.UserGuid;
                await _questAccceptedRepository.setAuthor(item.Id, author);
            }
        }

        {
            var list = await _questCompletedRepository.getAll();
            foreach (var item in list)
            {
                var gameQuestData = await _gameQuestDataRepository.get(item.QuestId, item.Revision, QuestContentState.Live);
                if (gameQuestData == null)
                    continue;

                string author = gameQuestData.UserGuid;
                await _questCompletedRepository.setAuthor(item.Id, author);
            }
        }



    }

}