using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;


using Amazon.DynamoDBv2.Model;
using Org.BouncyCastle.Tls.Crypto.Impl.BC;


using ServerCore; using ServerBase;
using ServerCommon;
using UGQDatabase.Models;
using MetaAssets;


using META_ID = System.UInt32;


namespace GameServer
{
    internal static class PlayerHelper
    {
        public static GameActor toGameActor(this Player player)
        {
            var user_create_or_load_action = player.getEntityAction<UserCreateOrLoadAction>();
            ArgumentNullException.ThrowIfNull(user_create_or_load_action);

            var player_action = player.getEntityAction<PlayerAction>();
            ArgumentNullException.ThrowIfNull(player_action);

            var inventory_action = player.getEntityAction<InventoryActionBase>();
            ArgumentNullException.ThrowIfNull(inventory_action);

            var cloth_info = inventory_action.toClothInven4Client();
            NullReferenceCheckHelper.throwIfNull(cloth_info, () => $"cloth_info is null !!!");

            var location_action = player.getEntityAction<LocationAction>();
            ArgumentNullException.ThrowIfNull(location_action);

            var pos = location_action.getCurrentPos();

            var buff_attribute = player.getOriginEntityAttribute<BuffAttribute>(); 
            ArgumentNullException.ThrowIfNull(buff_attribute);

            var account_attribute = player.getOriginEntityAttribute<AccountAttribute>();
            ArgumentNullException.ThrowIfNull(account_attribute);

            var user_attribute = player.getEntityAttribute<UserAttribute>();
            ArgumentNullException.ThrowIfNull(user_attribute);

            var item_tool_action = player.getEntityAction<ItemToolAction>();
            ArgumentNullException.ThrowIfNull(item_tool_action);

            GameActor game_actor = new();

            game_actor.ActorGuid = player.getUserGuid();
            game_actor.Name = player.getAccountId();


            var selected_character = player_action.getSelectedCharacter();
            if (null != selected_character)
            {
                var character_attribute = selected_character.getEntityAttribute<CharacterAttribute>();
                ArgumentNullException.ThrowIfNull(character_attribute, $"character_attribute is null !!!");

                game_actor.EntityStateInfo = character_attribute.StateInfo;
                game_actor.AvatarInfo = selected_character.getOriginAppearanceProfile().toCharacterAppearanceProfile4Client();
            }
            else
            {
                game_actor.AvatarInfo = user_create_or_load_action.toSelectedCharacterAppearanceProfile4Client();
            }

            game_actor.ClothInfo = cloth_info.toClothInfoOfAnotherUser();
            game_actor.Pos = pos;
            game_actor.TattooInfoList.AddRange(inventory_action.toTattooInven4Client());
            game_actor.BuffInfo = new();
            game_actor.BuffInfo.Buff.AddRange(buff_attribute.toBuffData4Client());
            game_actor.Usergroup = account_attribute.AuthAdminLevelType.ToString();
            game_actor.Operator = (int)account_attribute.AuthAdminLevelType;
            game_actor.DisplayName = player.getUserNickname();
            game_actor.OccupiedAnchorGuid = user_attribute.OccupiedAnchorGuid;
            game_actor.EquipInfo = item_tool_action.toToolAction4Client();
            game_actor.State = (int)user_attribute.PlayerState;
            game_actor.HostId = (int)player.getHostId();

            return game_actor;
        }

        public static async Task<Result> checkRequirement(this Player player, int requirementMetaId)
        {
            var result = new Result();
            var err_msg = string.Empty;

            if (requirementMetaId == 0)
                return result;

            if (!MetaData.Instance._RequirementMetaTable.TryGetValue(requirementMetaId, out var requirement_meta_data))
            {
                err_msg = $"Failed to TryGetValue() !!! : requirementMetaId:{requirementMetaId}";
                result.setFail(ServerErrorCode.RequirementMetaDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            foreach (var requireAttribute in requirement_meta_data.Attributes)
            {
                if (EnumHelper.tryParse<AttributeType>(requireAttribute.Type, out var attribute_enum) == false)
                {
                    err_msg = $"Enum Pase Failed. AttributeType : {requireAttribute.Type}";
                    result.setFail(ServerErrorCode.BuffInvalidAttributeType, err_msg);
                    Log.getLogger().error(err_msg);

                    return result;
                }

                var ability_action = player.getEntityAction<AbilityAction>();
                ArgumentNullException.ThrowIfNull(ability_action);

                var attribute_value = ability_action.getAbility(attribute_enum);
                if (attribute_value < requireAttribute.Value)
                {
                    err_msg = $"Not Requirement Attribute Value:{requireAttribute.Value} : current:{attribute_value}";
                    result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                    Log.getLogger().error(err_msg);

                    return result;
                }
            }

            foreach (var requireItem in requirement_meta_data.Items)
            {
                var inventory_action = player.getEntityAction<InventoryActionBase>();
                ArgumentNullException.ThrowIfNull(inventory_action);

                switch (requireItem.Type)
                {
                    case MetaAssets.ERequirementItemType.OWNS:
                        {
                            var item_count = inventory_action.getBagInven().getItemStackCountAllByMetaId((uint)requireItem.ID);
                            if (item_count < requireItem.Value)
                            {
                                err_msg = $"Not Requirement Item Owns ItemMetaId:{requireItem.ID} : value:{requireItem.Value} : currnet:{item_count}";
                                result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                                Log.getLogger().error(err_msg);

                                return result;
                            }
                        }
                        break;

                    case MetaAssets.ERequirementItemType.EQUIP:
                        {
                            if (!MetaData.Instance._ItemTable.TryGetValue(requireItem.ID, out var item_meta_data))
                            {
                                err_msg = $"Failed to TryGetValue() !!! : itemMetaId:{requireItem.ID}";
                                result.setFail(ServerErrorCode.ItemMetaDataNotFound, err_msg);
                                Log.getLogger().error(result.toBasicString());

                                return result;
                            }

                            if (item_meta_data.TypeLarge == EItemLargeType.TOOL)
                            {
                                var item_tool_action = player.getEntityAction<ItemToolAction>();
                                ArgumentNullException.ThrowIfNull(inventory_action);

                                var current_tool_item_meta_Id = item_tool_action.getCurrentToolItemMetaId();
                                if (current_tool_item_meta_Id != requireItem.ID)
                                {
                                    err_msg = $"Not Requirement Item Equip ItemMetaId:{requireItem.ID} : currnet:{current_tool_item_meta_Id}";
                                    result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                                    Log.getLogger().error(err_msg);

                                    return result;
                                }

                                break;
                            }

                            var item_small_type = item_meta_data.TypeSmall;

                            var inven_rule = GameServerApp.getServerLogic().findRule<InventoryRule>();
                            if (null == inven_rule)
                            {
                                err_msg = $"Not found InventoryRule !!!";
                                result.setFail(ServerErrorCode.InventoryRuleNotFound, err_msg);
                                Log.getLogger().error(result.toBasicString());

                                return result;
                            }

                            var equip_rule_bases = inven_rule.getEquipRuleBasesByItemLargeType(item_meta_data.TypeLarge);
                            if (null == equip_rule_bases)
                            {
                                err_msg = $"Not found EquipRuleBase !!! : ItemMetaId:{requireItem.ID}";
                                Log.getLogger().warn(err_msg);

                                continue;
                            }

                            foreach (var equip_rule in equip_rule_bases)
                            {
                                if (!inventory_action.getEquipInvens().TryGetValue(equip_rule.InvenEquipType, out var equip_inven_base))
                                {
                                    err_msg = $"Not found EquipInven !!! : invenEquipType:{equip_rule.InvenEquipType}";
                                    result.setFail(ServerErrorCode.EquipInvenNotFound, err_msg);
                                    Log.getLogger().error(result.toBasicString());

                                    return result;
                                }

                                var inven_accessor = equip_inven_base as IWithInventoryAccessor;
                                ArgumentNullException.ThrowIfNull(inven_accessor, $"inven_accessor is null !!! - {player.toBasicString()}");

                                bool is_equiped = false;
                                foreach (var item_base in inven_accessor.getHasItemBases())
                                {
                                    var item = item_base as Item;
                                    ArgumentNullException.ThrowIfNull(item, $"item is null !!! - {player.toBasicString}");

                                    var item_attribute = item.getOriginEntityAttribute<ItemAttributeBase>();
                                    ArgumentNullException.ThrowIfNull(item_attribute, $"item_attribute is null !!! - {player.toBasicString}");

                                    if (item_attribute.ItemMetaId == requireItem.ID)
                                    {
                                        is_equiped = true;
                                        break;
                                    }
                                }

                                if (false == is_equiped)
                                {
                                    err_msg = $"Not found require Item  !!! : ItemMetaId:{requireItem.ID} - InvenEquipType:{equip_rule.InvenEquipType}, {player.toBasicString()}";
                                    result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                                    Log.getLogger().error(err_msg);

                                    return result;
                                }
                            }
                        }
                        break;

                    case MetaAssets.ERequirementItemType.USE:
                        {
                            if (!MetaData.Instance._ItemTable.TryGetValue(requireItem.ID, out var item_meta_data))
                            {
                                err_msg = $"Failed to TryGetValue() !!! : itemMetaId:{requireItem.ID}";
                                result.setFail(ServerErrorCode.ItemMetaDataNotFound, err_msg);
                                Log.getLogger().error(result.toBasicString());

                                return result;
                            }

                            (result, var deleted_items) = await inventory_action.tryDeleteItemByMetaId((META_ID)requireItem.ID, (ushort)requireItem.Value);
                            if (result.isFail())
                            {
                                err_msg = $"Failed to tryDeleteItemByMeta() !!! : {result.toBasicString()} - {player.toBasicString()}";
                                Log.getLogger().error(err_msg);
                                return result;
                            }
                        }
                        break;

                    default:
                        {
                            err_msg = $"Requirement Item Type Error !!! : type:{requireItem.Type}";
                            result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                            Log.getLogger().error(err_msg);

                            return result;
                        }
                }
            }

            foreach (var requireQuest in requirement_meta_data.Quests)
            {
                var quest_id = requireQuest.Value;

                switch (requireQuest.Type)
                {
                    case MetaAssets.ERequirementQuestType.ING:
                        {
                            var quest_action = player.getEntityAction<QuestAction>();
                            ArgumentNullException.ThrowIfNull(quest_action);

                            (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
                            if (result.isFail()) return result;
                            var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
                            NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
                            
                            if (!quest_action.checkHasQuest(quest_base_info.QuestType, quest_id))
                            {
                                err_msg = $"Not Requirement Quest Ing Value:{requireQuest.Value}";
                                result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                                Log.getLogger().error(err_msg);

                                return result;
                            }
                        }
                        break;

                    case MetaAssets.ERequirementQuestType.COMPLETED:
                        {
                            var end_quest_action = player.getEntityAction<EndQuestAction>();
                            ArgumentNullException.ThrowIfNull(end_quest_action);

                            if (!end_quest_action.hasEndQuest(requireQuest.Value))
                            {
                                err_msg = $"Not Requirement Quest Complete Value:{requireQuest.Value}";
                                result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                                Log.getLogger().error(err_msg);

                                return result;
                            }
                        }
                        break;

                    default:
                        {
                            err_msg = $"Not Require Attribute Value !!! : type:{requireQuest.Type}";
                            result.setFail(ServerErrorCode.NotRequireAttributeValue, err_msg);
                            Log.getLogger().error(err_msg);

                            return result;
                        }
                }
            }

            return result;
        }

        public static Result checkInstanceAccess(this Player player, int instanceMetaId)
        {
            var result = new Result();
            var err_msg = string.Empty;

            if (!MetaData.Instance._IndunTable.TryGetValue(instanceMetaId, out var instance_meta_data))
            {
                err_msg = $"Failed to MetaData.TryGetValue() !!! : instanceMetaId:{instanceMetaId} - {player.toBasicString()}";
                result.setFail(ServerErrorCode.InstanceMetaDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            switch (instance_meta_data.AccessType)
            {
                case MetaAssets.AccessType.Public:
                    break;
                case MetaAssets.AccessType.Item:
                    {
                        var inventory_action = player.getEntityAction<InventoryActionBase>();
                        ArgumentNullException.ThrowIfNull(inventory_action, $"inventory_action is null !!! - {player.toBasicString()}");

                        // todo(sangyeob.kim) : 추후에 아이템 수량 변경 등이 필요한 경우 meta_data 에 AccessCount 항목이 필요함
                        var item_count = inventory_action.getItemStackCountAllByMetaId((uint)instance_meta_data.AccessId);
                        if (item_count < 1)
                        {
                            err_msg = $"Not Enough Instance Access Item !!! itemMetaId:{instance_meta_data.AccessId} - {player.toBasicString()}";
                            result.setFail(ServerErrorCode.NotExistInstanceTicket, err_msg);
                            // result.setFail(ServerErrorCode.InstanceAccessItemNotEnough, err_msg);    // Todo(myounghwi) : 추후 에러코드 적용(클라와 이야기 필요)
                            Log.getLogger().error(err_msg);

                            return result;
                        }
                    }
                    break;
                case MetaAssets.AccessType.Season:
                    {
                        var season_action = player.getEntityAction<SeasonPassAction>();
                        ArgumentNullException.ThrowIfNull(season_action, $"season_action is null !!! - {player.toBasicString()}");

                        if (season_action.isActivatedSeasonPass() == false)
                        {
                            err_msg = $"Not Season Period !!! - {player.toBasicString()}";
                            result.setFail(ServerErrorCode.SeasonPassNotAblePeriod, err_msg);
                            Log.getLogger().error(err_msg);
                            return result;
                        }

                        //AccessId가 0이면 시즌중이면 모두가 들어갈 수 있음. 1이면 시즌패스 구매자만 들어갈 수 있음.
                        if (instance_meta_data.AccessId == 0)
                            break;

                        var is_charged_season = season_action.isChargedSeasonPass();
                        if (false == is_charged_season)
                        {
                            err_msg = $"Not Charged SeasonPass Item !!! - {player.toBasicString()}";
                            result.setFail(ServerErrorCode.NotExistInstanceTicket, err_msg);
                            // result.setFail(ServerErrorCode.InstanceAccessSeasonPassNotCharged, err_msg); // Todo(myounghwi) : 추후 에러코드 적용(클라와 이야기 필요)
                            Log.getLogger().error(result.toBasicString());

                            return result;
                        }
                    }
                    break;
                case MetaAssets.AccessType.Belong:
                    break;
                default:
                    {
                        err_msg = $"AccessType Invalid !!! : type:{instance_meta_data.AccessType}, instanceMetaId:{instance_meta_data.Id} - {player.toBasicString()}";
                        result.setFail(ServerErrorCode.InstanceAccessTypeInvalid, err_msg);
                        Log.getLogger().error(err_msg);

                        return result;
                    }
            }

            return result;
        }

        public static async Task<Result> changeInstanceRoomIdAtLoginCache(this Player player, string instanceRoomId)
        {
            var result = new Result();
            var err_msg = string.Empty;

            var game_login_action = player.getEntityAction<GameLoginAction>();
            ArgumentNullException.ThrowIfNull(game_login_action);

            var login_cache_request = game_login_action.getLoginCacheRequest();
            ArgumentNullException.ThrowIfNull(login_cache_request);
            var login_cache = login_cache_request.getLoginCache();
            ArgumentNullException.ThrowIfNull(login_cache);

            login_cache.InstanceRoomId = instanceRoomId;

            result = await login_cache_request.upsertLogin();
            if (result.isFail())
            {
                err_msg = $"Failed to upsertLogin() !!! : {result.toBasicString()} - {player.toBasicString()}";
                Log.getLogger().error(err_msg);

                return result;
            }

            return result;
        }
    }
}