//using Amazon.DynamoDBv2.DocumentModel;
//using CommandLine;
//using Google.Protobuf.WellKnownTypes;
//using Nettention.Proud;

//using ServerCommon;
//using ServerCommon.BusinessLogDomain;
//using ServerCore; using ServerBase;
//using System.Collections.Concurrent;
//using System.Data;
//using System.Diagnostics.CodeAnalysis;
//using System.Linq;
//using static ClientToGameRes.Types;
//using static ServerCommon.UserActorLog;



//namespace GameServer
//{
//    public class Inventory
//    {
//        InventoryEntity ItemList = new();
//        ConcurrentDictionary<string, ItemEntity> Items = new();

//        /// <summary>
//        /// accountGuid
//        /// </summary>
//        string Owner = string.Empty;

//        public int[] MaxSlot = { 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };

//        public Inventory() { }

//        public void SetOwner(string owner)
//        {
//            Owner = owner;
//        }

//        public async Task<InventoryEntity> getInventoryEntityAfterReadDocument(Document inventoryDocument)
//        {
//            if (!ItemList.ReadFrom(inventoryDocument))
//            {
//                Log.getLogger().error("Inventory read error");
//                return null;
//            }

//            return ItemList;
//        }

//        public async Task<bool> LoadDB(string accountGuid)
//        {
//            Clear();

//            var inventoryDocument = await GameServerApp.Instance.MainDB.GetInventory(accountGuid);
//            if (inventoryDocument == null)
//            {
//                Log.getLogger().error("document is null");
//                return false;
//            }

//            if (!ItemList.ReadFrom(inventoryDocument))
//            {
//                Log.getLogger().error("Inventory read error");
//                return false;
//            }

//            List<string> itemGuids = new();

//            foreach (var itemtap in ItemList.Attr.InventoryTaps)
//            {
//                itemGuids.AddRange(itemtap.ToList());
//            }

//            var itemEntityList = await GameServerApp.Instance.MainDB.GetItemEntityList(itemGuids);
//            if (itemEntityList == null)
//            {
//                Log.getLogger().error("itemList is null");
//                return false;
//            }

//            foreach (var itemEntity in itemEntityList)
//            {
//                if (itemEntity.Attr.Count <= 0)
//                {
//                    ServerLog.Fatal($"{accountGuid} Check Item{itemEntity.Attr.ItemGuid} Delete Logic !!!!!");

//                    foreach (var inventoryTap in ItemList.Attr.InventoryTaps)
//                    {
//                        if (!inventoryTap.Contains(itemEntity.PK_Guid))
//                            continue;

//                        inventoryTap.Remove(itemEntity.PK_Guid);
//                    }
//                }
//                else
//                {
//                    if (!Items.TryAdd(itemEntity.PK_Guid, itemEntity))
//                    {
//                        Log.getLogger().error($"ItemEntity itemGuid : {itemEntity.PK_Guid} - add fail");
//                        return false;
//                    }
//                }

                
//            }

//            Owner = accountGuid;

//            return true;
//        }

//        public void UpdateItemDBToMemory(List<ItemEntity> newitems)
//        {
//            foreach(var item in newitems)
//            {
//                if(item.Attr.Count == 0 || Owner != item.Attr.Owner)
//                {
//                    if(Items.TryRemove(item.PK_Guid, out var itemEntity) == false)
//                    {
//                        Log.getLogger().error($"TryRemove failed. pk : {item.PK_Guid}");
//                        continue;
//                    }
//                }
//                else
//                {
//                    Items[item.PK_Guid] = item;
//                }
//            }
//        }

//        public void UpdateInventoryDBToMemory(Document document)
//        {
//            ItemList.ReadFrom(document);
//        }

//        public async Task<bool> ClearDB()
//        {
//            List<Document> documents = new();

//            var inventoryDocument = MainDB.DocumentForDelete(EEntityType.Inventory, ItemList.PK_Guid, ItemList.SK_Empty);
//            documents.Add(inventoryDocument);

//            foreach (var item in Items.Values)
//            {
//                var itemDocument = MainDB.DocumentForDelete(EEntityType.Item, item.PK_Guid, item.SK_Guid);
//                documents.Add(itemDocument);
//            }

//            if (!await GameServerApp.Instance.MainDB.DeleteDocuments(documents))
//            {
//                Log.getLogger().error("Fail DeleteDocuments");
//                return false;
//            }

//            return true;
//        }

//        public void Clear()
//        {
//            ItemList.Clear();          
//            Items.Clear();
//        }

//        public global::Inventory MakePacketInventoryData()
//        {
//            global::Inventory inventory = new();

//            inventory.EtcItem.AddRange(MakePacketItemList(0));
//            inventory.CostumeItem.AddRange(MakePacketItemList(1));
//            inventory.InteriorItem.AddRange(MakePacketItemList(2));
//            inventory.BeautyItem.AddRange(MakePacketItemList(3));
//            inventory.TattooItem.AddRange(MakePacketItemList(4));
//            inventory.EtcItemNft.AddRange(MakePacketItemList(5));
//            inventory.CostumeItemNft.AddRange(MakePacketItemList(6));
//            inventory.InteriorItemNft.AddRange(MakePacketItemList(7));
//            inventory.BeautyItemNft.AddRange(MakePacketItemList(8));
//            inventory.TattooItemNft.AddRange(MakePacketItemList(9));

//            return inventory;
//        }

//        List<Item> MakePacketItemList(int inventoryTapNumber)
//        {
//            List<Item> itemList = new();

//            foreach (var itemGuid in ItemList.Attr.InventoryTaps[inventoryTapNumber])
//            {
//                if (!Items.TryGetValue(itemGuid, out var item))
//                    continue;

//                itemList.Add(item.ConvetToItem());
//            }

//            return itemList;
//        }

//        public void SendInfo(HostID hostId)
//        {

//        }

//        public bool HasItem(string itemGuid)
//        {
//            return Items.ContainsKey(itemGuid);
//        }

//        public bool HasItem(int itemId)
//        {
//            foreach(var item in Items.Values)
//            {
//                if (item.Attr.ItemId == itemId)
//                    return true;
//            }

//            return false;
//        }

//        public bool GetItem(string itemGuid, [MaybeNullWhen(false)] out ItemEntity item)
//        {
//            return Items.TryGetValue(itemGuid, out item);
//        }

//        public List<ItemEntity> GetItem(int itemId)
//        {
//            return Items.Values.Where(x => x.Attr.ItemId == itemId).ToList();
//        }

//        public static int GetInventoryTapNumber(int itemId)
//        {
//            int tapNumber = 0;
//            if (!TableData.Instance._ItemTable.TryGetValue(itemId, out var itemData))
//                return -1;

//            if (itemData.TypeLarge == EItemLargeType.CLOTH)
//            {
//                tapNumber += 1;
//            }
//            else if (itemData.TypeLarge == EItemLargeType.PROP)
//            {
//                tapNumber += 2;
//            }
//            else if (itemData.TypeLarge == EItemLargeType.BEAUTY)
//            {
//                tapNumber += 3;
//            }
//            else if (itemData.TypeLarge == EItemLargeType.TATTOO)
//            {
//                tapNumber += 4;
//            }

//            if (itemData.IsNFT)
//                tapNumber += 5;

//            return tapNumber;
//        }
//        private bool _ChangeAttribute(string itemGuid, int slot, out int changeAttributeId)
//        {
//            changeAttributeId = -1;

//            if (!Items.TryGetValue(itemGuid, out var item))
//            {
//                Log.getLogger().error($"Not Exist itemGuid({itemGuid})");
//                return false;
//            }

//            if(slot <= 0 || slot > item.Attr.AttributeIds.Count)
//            {
//                Log.getLogger().error($"Invalid Slot : {slot}");
//                return false;
//            }

//            if (!TableData.Instance._ItemTable.TryGetValue(item.Attr.ItemId, out var itemData))
//            {
//                Log.getLogger().error($"Not Exist itemId({item.Attr.ItemId})");
//                return false;
//            }
            
//            if (!TableData.Instance._AttributeRandomGroupDataTable.TryGetValue(itemData.AttributeRandomGroupID, out var randomGroupList))
//            {
//                Log.getLogger().error($"Not Exist AttributeRandomGroupID({itemData.AttributeRandomGroupID})");
//                return false;
//            }

//            int TotalWeight = randomGroupList.TotalWeight;
//            var attrivuteIds = item.Attr.AttributeIds;

//            foreach (var attributeData in randomGroupList.attributeRandomGroupDatas)
//            {
//                for (int i = 0; i < attrivuteIds.Count; ++i)
//                {
//                    if (attributeData.Key == attrivuteIds[i])
//                    {
//                        TotalWeight -= attributeData.Weight;
//                        break;
//                    }
//                }
//            }

//            int Count = 0;
//            int randomNumber = ServerUtil.rnd.Next(0, TotalWeight);

//            foreach (var attributeData in randomGroupList.attributeRandomGroupDatas)
//            {
//                bool breakCheck = false;
//                for (int i = 0; i < attrivuteIds.Count; ++i)
//                {
//                    if (attributeData.Key == attrivuteIds[i])
//                    {
//                        breakCheck = true;
//                        break;
//                    }
//                }

//                if (breakCheck == true)
//                {
//                    continue;
//                }

//                Count += attributeData.Weight;

//                if (Count > randomNumber)
//                {
//                    changeAttributeId = attributeData.Key;
//                    return true;
//                }
//            }

//            return false;
//        }


//        private bool MakeAttribute(ItemData itemdata, out List<int> selectedAttributeIds)
//        {
//            selectedAttributeIds = new();

//            if (!TableData.Instance._AttributeDefinitionDataTable.TryGetValue(itemdata.DefaultAttribute, out var AttributeData))
//            {
//                Log.getLogger().error($"Not Exist DefaultAttribute({itemdata.DefaultAttribute})");
//                return false;
//            }

//            selectedAttributeIds.Add(AttributeData.ID);

//            if (!TableData.Instance._ItemLevelEnchantDataTable.TryGetValue(1, out var itemLevelEnchantData))
//            {
//                Log.getLogger().error($"Not Exist Level(1)");
//                return false;
//            }

//            if(itemLevelEnchantData.enchantDataList.TryGetValue(itemdata.Rarity, out var enchantData) == false)
//            {
//                Log.getLogger().error($"Not Exist Rarity({itemdata.Rarity})");
//                return false;
//            }

//            if (!TableData.Instance._AttributeRandomGroupDataTable.TryGetValue(itemdata.AttributeRandomGroupID, out var randomGroupList))
//            {
//                Log.getLogger().error($"Not Exist AttributeRandomGroupID({itemdata.AttributeRandomGroupID})");
//                return false;
//            }

//            int TotalWeight = randomGroupList.TotalWeight;
//            List<int> randomAttributeIds = new();

//            var AttributeDefinitionData = TableData.Instance._AttributeDefinitionDataTable;

//            while (randomAttributeIds.Count < enchantData.AttributeValues.Count - 1)
//            {
//                if(TotalWeight == 0)
//                {
//                    return false;
//                }

//                int Count = 0;
//                int randomNumber = ServerUtil.rnd.Next(0, TotalWeight);

//                foreach (var attributeData in randomGroupList.attributeRandomGroupDatas)
//                {
//                    if (!AttributeDefinitionData.TryGetValue(attributeData.Attribute, out var randomAttributeData))
//                    {
//                        Log.getLogger().error($"Not Exist AttributeRandomGroupID({itemdata.AttributeRandomGroupID})");
//                        return false;
//                    }

//                    bool breakCheck = false;
//                    foreach(var selectAttribute in randomAttributeIds)
//                    {
//                        if (randomAttributeData.ID == selectAttribute)
//                        {
//                            breakCheck = true;
//                            break;
//                        }
//                    }

//                    if (breakCheck == true)
//                    {
//                        continue;
//                    }

//                    Count += attributeData.Weight;

//                    if(Count > randomNumber)
//                    {
//                        randomAttributeIds.Add(randomAttributeData.ID);
//                        TotalWeight -= attributeData.Weight;
//                        break;
//                    }
//                }
//            }
//            selectedAttributeIds.AddRange(randomAttributeIds);
//            return true;
//        }

//        bool CreateItem(int itemId, int count, [MaybeNullWhen(false)] out List<ItemEntity> createdItemList)
//        {
//            createdItemList = new();
            
//            if (!TableData.Instance._ItemTable.TryGetValue(itemId, out var itemData))
//            {
//                Log.getLogger().error($"Not Exist itemId({itemId})");
//                return false;
//            }

//            if (count <= 0)
//            {
//                Log.getLogger().error($"Invalid Parameter count({count})");
//                return false;
//            }
            
//            var remainCount = count;
//            while (remainCount > 0)
//            {
//                int createCount;
//                if (remainCount >= itemData.StackMaxCount)
//                {
//                    createCount = itemData.StackMaxCount;
//                    remainCount -= itemData.StackMaxCount;
//                }
//                else
//                {
//                    createCount = remainCount;
//                    remainCount = 0;
//                }

//                List<int> attributeIds = new();
//                int level = 0;
//                if (itemData.TypeLarge == EItemLargeType.TATTOO)
//                {
//                    level = 1;
//                    if (MakeAttribute(itemData, out attributeIds) == false)
//                    {
//                        Log.getLogger().error($"Invalid Parameter id({itemData.ItemId})");
//                        return false;
//                    }
//                }

//                ItemEntity item = new(itemId, createCount, level, attributeIds);
//                createdItemList.Add(item);
//            }

//            return true;
//        }

//        bool _isPossibleToAddItem(int InventoryCount, out ServerErrorCode errorCode)
//        {
//            errorCode = ServerErrorCode.Success;

//            if (TableData.Instance._GameConfigDataTable.TryGetValue("MaxItemCategorySlotNum", out var MaxCategorySlot) == false)
//            {
//                Log.getLogger().error($"Not Found MaxItemCategorySlotNum.");
//                errorCode = ServerErrorCode.NotFoundTable;
//                return false;
//            }

//            if (int.TryParse(MaxCategorySlot, out var Max_CategorySlot) == false)
//            {
//                Log.getLogger().error($"MaxItemCategorySlotNum convert failed.");
//                errorCode = ServerErrorCode.TableError;
//                return false;
//            }

//            if (Max_CategorySlot < 1 + InventoryCount)
//            {
//                Log.getLogger().error($"Create Item Failed. Inventory over.");
//                errorCode = ServerErrorCode.InventoryFull;
//                return false;
//            }

//            return true;
//        }

//        bool _AddItem(ItemEntity item, InventoryEntity updateInventoryEntity, out ServerErrorCode errorCode, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            itemlogData = default;

//            if (TableData.Instance._ItemTable.TryGetValue(item.Attr.ItemId, out var itemMetaData) == false)
//            {
//                Log.getLogger().error($"Not Exist itemId({item.Attr.ItemId})");
//                errorCode = ServerErrorCode.NotFoundTable;
//                return false;
//            }

//            var tapNumber = GetInventoryTapNumber(item.Attr.ItemId);
//            if (tapNumber == -1)
//            {
//                Log.getLogger().error($"Can't find InventoryTapNumber");
//                errorCode = ServerErrorCode.TableError;
//                return false;
//            }

//            if (_isPossibleToAddItem(updateInventoryEntity.Attr.InventoryTaps[tapNumber].Count, out errorCode) == false)
//                return false;

//            if (!updateInventoryEntity.Attr.InventoryTaps[tapNumber].Add(item.Attr.ItemGuid))
//                return false;

//            item.Attr.Owner = Owner;
//            itemlogData = ItemBusinessLogHelper.toItemLogInfo(item, itemMetaData, CountDeltaType.New, 0, 0, new());

//            return true;
//        }

//        public bool AddItem(ItemEntity item, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out ItemEntity updateItems, 
//            out ServerErrorCode errorCode, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            updateItems = default;
//            itemlogData = default;

//            if (Items.ContainsKey(item.Attr.ItemGuid))
//            {
//                Log.getLogger().error($"Already Exist itemGuid({item.Attr.ItemGuid})");
//                errorCode = ServerErrorCode.NotFoundItem;
//                return false;
//            }

//            if (!_AddItem(item, updateInventoryEntity, out errorCode, out itemlogData))
//            {
//                Log.getLogger().error($"Add Fail itemGuid({item.Attr.ItemGuid})");
//                return false;
//            }

//            updateItems = item;
//            return true;
//        }

//        public bool AddItem(int itemId, int count, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out List<ItemEntity> updateItems, 
//            out ServerErrorCode errorCode, out List<ItemLogData> itemlogDatas)
//        {
//            updateItems = default;
//            itemlogDatas = new();

//            if (!TableData.Instance._ItemTable.TryGetValue(itemId, out var itemMetaData))
//            {
//                Log.getLogger().error($"Not Exist itemId({itemId})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (count <= 0)
//            {
//                Log.getLogger().error($"Invalid Parameter count({count})");
//                errorCode = ServerErrorCode.InvalidArgument;
//                return false;
//            }
            
//            var itemList = Items.Values.Where(x => x.Attr.ItemId == itemId).ToList();
//            var itemCount = itemList.Sum(x => x.Attr.Count);

//            List<ItemEntity> newitemList = itemList.ConvertAll(o => new ItemEntity(o.DocumentForUpdate()));
//            if (itemCount + count > itemMetaData.MaxCount)
//            {
//                Log.getLogger().error($"Item MaxCount Over");
//                errorCode = ServerErrorCode.NoMoreAddItem;
//                return false;
//            }

//            List<ItemEntity> addedItemAndCountList = new();
//            var remainCount = count;
//            newitemList.OrderByDescending(x => x.Attr.Count);

//            foreach (var item in newitemList)
//            {
//                if (remainCount <= 0)
//                    break;

//                if (item.Attr.Count >= itemMetaData.StackMaxCount)
//                    continue;
                
//                var addCount = 0;
//                if (item.Attr.Count + remainCount > itemMetaData.StackMaxCount)
//                    addCount = itemMetaData.StackMaxCount - item.Attr.Count;
//                else
//                    addCount = remainCount;
//                item.Attr.Count += addCount;
//                item.Attr.UpdateTime = Timestamp.FromDateTime(DateTime.UtcNow);

//                addedItemAndCountList.Add(item);
//                remainCount -= addCount;

//                itemlogDatas.Add(ItemBusinessLogHelper.toItemLogInfo(item, itemMetaData, CountDeltaType.Acquire, addCount, 0, new()));
//            }
            
//            if (remainCount > 0)
//            {
//                if(!CreateItem(itemId, remainCount, out var createdItemList))
//                {
//                    Log.getLogger().error($"Create Fail itemId({itemId})");
//                    errorCode = ServerErrorCode.CreateItemFail;
//                    return false;
//                }

//                foreach (var createdItem in createdItemList)
//                {
//                    if (!_AddItem(createdItem, updateInventoryEntity, out errorCode, out var itemlogData))
//                    {
//                        Log.getLogger().error($"Add Fail itemGuid({createdItem.Attr.ItemGuid})");
//                        return false;
//                    }                    

//                    if(itemlogData != null) itemlogDatas.Add(itemlogData);
//                    addedItemAndCountList.Add((createdItem));
//                }
//            }

//            updateItems = addedItemAndCountList;
//            errorCode = ServerErrorCode.Success;
//            return true;
//        }

//        bool _DeleteItem(ItemEntity item, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            itemlogData = default;

//            if (TableData.Instance._ItemTable.TryGetValue(item.Attr.ItemId, out var itemMetaData) == false)
//            {
//                Log.getLogger().error($"Not Exist itemId({item.Attr.ItemId})");
//                return false;
//            }

//            foreach (var inventoryTap in updateInventoryEntity.Attr.InventoryTaps)
//            {
//                if (!inventoryTap.Contains(item.PK_Guid))
//                    continue;

//                if (!inventoryTap.Remove(item.PK_Guid))
//                    return false;

//                int deltaCount = item.Attr.Count * -1;
//                item.Attr.Count = 0;
//                item.Attr.UpdateTime = Timestamp.FromDateTime(DateTime.UtcNow);

//                itemlogData = ItemBusinessLogHelper.toItemLogInfo(item, itemMetaData, CountDeltaType.Delete, deltaCount, 0, new());

//                return true;
//            }

//            return false;
//        }

//        public bool SellItem(string itemGuid, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out ItemEntity updateItems, 
//            out ServerErrorCode errorCode, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            updateItems = default;
//            itemlogData = default;

//            if (!Items.TryGetValue(itemGuid, out var item))
//            {
//                Log.getLogger().error($"Not Exist itemGuid({itemGuid})");
//                errorCode = ServerErrorCode.NotFoundItem;
//                return false;
//            }

//            ItemEntity newItem = new(item.DocumentForUpdate());
//            if (!_SellItem(newItem, updateInventoryEntity, out itemlogData))
//            {
//                Log.getLogger().error($"Delete Fail itemGuid({itemGuid})");
//                errorCode = ServerErrorCode.DeleteItemFail;
//                return false;
//            }

//            updateItems = newItem;

//            errorCode = ServerErrorCode.Success;
//            return true;
//        }

//        bool _SellItem(ItemEntity item, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            itemlogData = default;

//            if (TableData.Instance._ItemTable.TryGetValue(item.Attr.ItemId, out var itemMetaData) == false)
//            {
//                Log.getLogger().error($"Not Exist itemId({item.Attr.ItemId})");
//                return false;
//            }

//            foreach (var inventoryTap in updateInventoryEntity.Attr.InventoryTaps)
//            {
//                if (!inventoryTap.Contains(item.PK_Guid))
//                    continue;

//                if (!inventoryTap.Remove(item.PK_Guid))
//                    return false;

//                item.Attr.Owner = "";
//                item.Attr.UpdateTime = Timestamp.FromDateTime(DateTime.UtcNow);

//                itemlogData = ItemBusinessLogHelper.toItemLogInfo(item, itemMetaData, CountDeltaType.Delete, item.Attr.Count * -1, 0, new());

//                return true;
//            }

//            return false;
//        }

//        public bool DeleteItem(string itemGuid, int count, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out ItemEntity updateItems, 
//            out ServerErrorCode errorCode, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            updateItems = default;
//            itemlogData = default;

//            if (!Items.TryGetValue(itemGuid, out var item))
//            {
//                Log.getLogger().error($"Not Exist itemGuid({itemGuid})");
//                errorCode = ServerErrorCode.NotFoundItem;
//                return false;
//            }

//            if (TableData.Instance._ItemTable.TryGetValue(item.Attr.ItemId, out var itemMetaData) == false)
//            {
//                Log.getLogger().error($"Not Exist itemId({item.Attr.ItemId})");
//                errorCode = ServerErrorCode.NotFoundTable;
//                return false;
//            }

//            if (count <= 0)
//            {
//                Log.getLogger().error($"Invalid Parameter count({count})");
//                errorCode = ServerErrorCode.InvalidArgument;
//                return false;
//            }

//            ItemEntity newItem = new(item.DocumentForUpdate());
            
//            if (newItem.Attr.Count < count)
//            {
//                Log.getLogger().error($"Not Enough ItemCount");
//                errorCode = ServerErrorCode.NotEnoughItem;
//                return false;
//            }
//            else if (newItem.Attr.Count > count)
//            {
//                newItem.Attr.Count -= count;
//                newItem.Attr.UpdateTime = Timestamp.FromDateTime(DateTime.UtcNow);
//                itemlogData = ItemBusinessLogHelper.toItemLogInfo(item, itemMetaData, CountDeltaType.Consume, count * -1, 0, new());
//            }
//            else // deleteItem.Attr.Count == count
//            {
//                if (!_DeleteItem(newItem, updateInventoryEntity, out itemlogData))
//                {
//                    Log.getLogger().error($"Delete Fail itemGuid({itemGuid})");
//                    errorCode = ServerErrorCode.DeleteItemFail;
//                    return false;
//                }
//            }

//            updateItems = newItem;

//            errorCode = ServerErrorCode.Success;
//            return true;
//        }

//        public bool DeleteItem(int itemId, int count, InventoryEntity updateInventoryEntity, [MaybeNullWhen(false)] out List<ItemEntity> updateItems, 
//            out ServerErrorCode errorCode, [MaybeNullWhen(false)] out ItemLogData itemlogData)
//        {
//            updateItems = default;
//            itemlogData = default;

//            if (TableData.Instance._ItemTable.TryGetValue(itemId, out var itemMetaData) == false)
//            {
//                Log.getLogger().error($"Not Exist itemId({itemId})");
//                errorCode = ServerErrorCode.NotFoundTable;
//                return false;
//            }

//            if (count <= 0)
//            {
//                Log.getLogger().error($"Invalid Parameter count({count})");
//                errorCode = ServerErrorCode.InvalidArgument;
//                return false;
//            }

//            var itemList = Items.Values.Where(x => x.Attr.ItemId == itemId).ToList();
//            var itemCount = itemList.Sum(x => x.Attr.Count);

//            List<ItemEntity> newitemList = itemList.ConvertAll(o => new ItemEntity(o.DocumentForUpdate()));

//            if (itemCount < count)
//            {
//                Log.getLogger().error($"Not Enough ItemCount");
//                errorCode = ServerErrorCode.NotEnoughItem;
//                return false;
//            }

//            List<ItemEntity> deletedItemAndCountList = new();
//            var remainCount = count;
//            newitemList.OrderBy(x => x.Attr.Count);
            
//            foreach (var item in newitemList)
//            {
//                if (remainCount <= 0)
//                    break;

//                if (item.Attr.Count > remainCount)
//                {
//                    item.Attr.Count -= remainCount;
//                    item.Attr.UpdateTime = Timestamp.FromDateTime(DateTime.UtcNow);

//                    deletedItemAndCountList.Add(item);
//                    itemlogData = ItemBusinessLogHelper.toItemLogInfo(item, itemMetaData, CountDeltaType.Consume, remainCount * -1, 0, new());
//                    remainCount = 0;
//                }
//                else // item.Attr.Count <= remainCount
//                {
//                    var deleteCount = item.Attr.Count;
//                    if (!_DeleteItem(item, updateInventoryEntity, out itemlogData))
//                    {
//                        Log.getLogger().error($"Delete Fail itemGuid({item.Attr.ItemGuid})");
//                        errorCode = ServerErrorCode.DeleteItemFail;
//                        return false;
//                    }

//                    deletedItemAndCountList.Add(item);
//                    remainCount -= deleteCount;
//                }
//            }

//            updateItems = deletedItemAndCountList;

//            errorCode = ServerErrorCode.Success;
//            return true;
//        }

//        public async Task<bool> SaveInventory()
//        {
//            List<Document> documents = new();

//            var inventoryDocument = ItemList.DocumentForUpdate();
//            documents.Add(inventoryDocument);

//            foreach (var item in Items.Values)
//            {
//                var itemDocument = item.DocumentForUpdate();
//                documents.Add(itemDocument);
//            }

//            if (!await GameServerApp.Instance.MainDB.UpdateDocuments(documents))
//            {
//                Log.getLogger().error("Fail UpdateDocuments");
//                return false;
//            }    

//            return true;
//        }

//        public void CopyInventoryEntityForTransaction(out InventoryEntity newInventoryEntity)
//        {
//            newInventoryEntity = new(ItemList.DocumentForUpdate());
//        }

//        public bool LevelUpItem(string itemGuid, InventoryEntity updateInventoryEntity, bool isRegisterTattoo, [MaybeNullWhen(false)] out List<ItemEntity> updateItems, out ServerErrorCode errorCode, 
//            out bool isEnchantSuccess, out List<AttributeInfo>? changeAttributeList, [MaybeNullWhen(false)] out List<ItemLogData> itemlogDatas)
//        {
//            updateItems = default;
//            changeAttributeList = default;
//            isEnchantSuccess = false;
//            itemlogDatas = new();

//            if (Items.TryGetValue(itemGuid, out var itemInfo) == false)
//            {
//                Log.getLogger().error($"Not Exist itemGuid({itemGuid})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (!TableData.Instance._ItemTable.TryGetValue(itemInfo.Attr.ItemId, out var itemMetaData))
//            {
//                Log.getLogger().error($"Not Exist itemId({itemInfo.Attr.ItemId})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (!TableData.Instance._ItemLevelEnchantDataTable.TryGetValue(itemInfo.Attr.Level, out var newEnchantData))
//            {
//                Log.getLogger().error($"Not Exist EnchantDataTable Level({itemInfo.Attr.Level})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (newEnchantData.enchantDataList.TryGetValue(itemMetaData.Rarity, out var newEnchantInfo) == false)
//            {
//                Log.getLogger().error($"Not Exist Rarity({itemMetaData.Rarity})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            var curr_enchant_level = itemInfo.Attr.Level - 1;
//            if (!TableData.Instance._ItemLevelEnchantDataTable.TryGetValue(curr_enchant_level, out var enchantData))
//            {
//                if(curr_enchant_level != 0)
//                {
//                    Log.getLogger().error($"Not Exist EnchantDataTable Level({curr_enchant_level})");
//                    errorCode = ServerErrorCode.NotFoundItemTableId;
//                    return false;
//                }
//            }

//            ItemLevelEnchantData.EnchantData enchantInfo = null;
//            if (    null != enchantData
//                && enchantData.enchantDataList.TryGetValue(itemMetaData.Rarity, out enchantInfo) == false)
//            {
//                Log.getLogger().error($"Not Exist Rarity({itemMetaData.Rarity})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            updateItems = new List<ItemEntity>();

//            if (DeleteItem(newEnchantInfo.ConsumeItemID, newEnchantInfo.ConsumeItemCount, updateInventoryEntity, out var deletedItem, out errorCode, out var itemlogData) == false)
//            {
//                Log.getLogger().error($"Not Enough Item Item(ID : {newEnchantInfo.ConsumeItemID} NeedCount : {newEnchantInfo.ConsumeItemCount})");
//                return false;
//            }
//            itemlogDatas.Add(itemlogData);

//            updateItems.AddRange(deletedItem);

//            ItemEntity updateItem = new(itemInfo.DocumentForUpdate());

//            if (newEnchantInfo.Probability >= ServerUtil.rnd.Next(0, 10000) == true)
//            {
//                updateItem.Attr.Level += 1;
//                updateItems.Add(updateItem);
//                isEnchantSuccess = true;

//                if(isRegisterTattoo == true)
//                {
//                    changeAttributeList = new();

//                    for (int attributeSlot = 0; attributeSlot < itemInfo.Attr.AttributeIds.Count; ++attributeSlot)
//                    {
//                        int attributeId = itemInfo.Attr.AttributeIds[attributeSlot];
//                        int applyAttribute = newEnchantInfo.AttributeValues[attributeSlot] - (enchantInfo != null ? enchantInfo.AttributeValues[attributeSlot] : 0);
//                        changeAttributeList.Add(new AttributeInfo() { Attributeid = attributeId, Value = applyAttribute});
//                    }
//                }
//                itemlogDatas.Add(ItemBusinessLogHelper.toItemLogInfo(itemInfo, itemMetaData, CountDeltaType.Update, 0, 1, new()));
//            }

//            errorCode = ServerErrorCode.Success;
//            return true;
//        }

//        public bool ChangeAttribute(string itemGuid, int slot, InventoryEntity updateInventoryEntity, bool isRegisterTattoo, [MaybeNullWhen(false)] out List<ItemEntity> updateItems,
//             out ServerErrorCode errorCode, [MaybeNullWhen(false)] out List<AttributeInfo> changeAttriuteList, [MaybeNullWhen(false)] out List<ItemLogData> itemlogDatas)
//        {
//            updateItems = default;
//            changeAttriuteList = default;
//            itemlogDatas = new();

//            if (slot < 0 ||  slot > Constant.MAX_TATTOO_SLOT)
//            {
//                Log.getLogger().error($"Out Of Range(0~{Constant.MAX_TATTOO_SLOT - 1}). TattooSlot:{slot}");
//                errorCode = ServerErrorCode.InvalidAttributeSlot;
//                return false;
//            }

//            if (Items.TryGetValue(itemGuid, out var itemInfo) == false)
//            {
//                Log.getLogger().error($"Not Exist itemGuid({itemGuid})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (!TableData.Instance._ItemTable.TryGetValue(itemInfo.Attr.ItemId, out var itemMetaData))
//            {
//                Log.getLogger().error($"Not Exist itemId({itemInfo.Attr.ItemId})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (!TableData.Instance._AttributeEnchantDataTable.TryGetValue(itemMetaData.Rarity, out var AttributeEnchantInfo))
//            {
//                Log.getLogger().error($"Not Exist itemId({itemInfo.Attr.ItemId})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (!TableData.Instance._ItemLevelEnchantDataTable.TryGetValue(itemInfo.Attr.Level, out var itemLevelEnchantData))
//            {
//                Log.getLogger().error($"Not Exist Level({itemInfo.Attr.Level})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            if (itemLevelEnchantData.enchantDataList.TryGetValue(itemMetaData.Rarity, out var enchantData) == false)
//            {
//                Log.getLogger().error($"Not Exist Rarity({itemMetaData.Rarity})");
//                errorCode = ServerErrorCode.NotFoundItemTableId;
//                return false;
//            }

//            updateItems = new List<ItemEntity>();
//            if (DeleteItem(
//                AttributeEnchantInfo.ItemID,
//                AttributeEnchantInfo.ItemCount,
//                updateInventoryEntity,
//                out var deletedItem,
//                out errorCode, out var itemlogData) == false)
//            {
//                Log.getLogger().error($"Not Enough Item Item(ID : {AttributeEnchantInfo.ItemID} NeedCount : {AttributeEnchantInfo.ItemCount})");
//                return false;
//            }
//            itemlogDatas.Add(itemlogData);
//            updateItems.AddRange(deletedItem);

//            changeAttriuteList = new();

//            ItemEntity updateItem = new(itemInfo.DocumentForUpdate());
//            List<int> oldAttributeIds = itemInfo.Attr.AttributeIds;
//            if (slot == 0)
//            {
//                if(MakeAttribute(itemMetaData, out var selectedAttributeIds) == false)
//                {
//                    Log.getLogger().error($"Invalid Parameter id({itemMetaData.ItemId})");
//                    errorCode = ServerErrorCode.NotFoundItemTableId;
//                    return false;
//                }

//                if(isRegisterTattoo == true)
//                {
//                    for (int attributeSlot = 0; attributeSlot < updateItem.Attr.AttributeIds.Count; ++attributeSlot)
//                    {
//                        int attributeId = updateItem.Attr.AttributeIds[attributeSlot];
//                        changeAttriuteList.Add(new AttributeInfo(){ Attributeid = attributeId, Value = enchantData.AttributeValues[attributeSlot] * -1 });
//                    }

//                    for (int attributeSlot = 0; attributeSlot < updateItem.Attr.AttributeIds.Count; ++attributeSlot)
//                    {
//                        int attributeId = selectedAttributeIds[attributeSlot];
//                        changeAttriuteList.Add(new AttributeInfo() { Attributeid = attributeId, Value = enchantData.AttributeValues[attributeSlot]});
//                    }
//                }

//                updateItem.Attr.AttributeIds = selectedAttributeIds;
//            }
//            else
//            {
//                if(_ChangeAttribute(itemGuid, slot, out var changeAttributeId) == false)
//                {
//                    Log.getLogger().error($"_ChangeAttribute failed.");
//                    errorCode = ServerErrorCode.NotFoundItemTableId;
//                    return false;
//                }

//                if (isRegisterTattoo == true)
//                {
//                    int attributeId = updateItem.Attr.AttributeIds[slot];
//                    changeAttriuteList.Add(new AttributeInfo() { Attributeid = attributeId, Value = enchantData.AttributeValues[slot] * -1 });
//                    changeAttriuteList.Add(new AttributeInfo() { Attributeid = attributeId, Value = enchantData.AttributeValues[slot]});
//                }

//                updateItem.Attr.AttributeIds[slot] = changeAttributeId;
//            }

//            updateItems.Add(updateItem);
//            itemlogDatas.Add(ItemBusinessLogHelper.toItemLogInfo(updateItem, itemMetaData, CountDeltaType.Update, 0, 0, oldAttributeIds));

//            errorCode = ServerErrorCode.Success;
//            return true;
//        }
//    }
//}