using NLog;
using Server.SQL;
using Server.System;

namespace Server.Manager
{
    public class ItemManager
    {
        private static readonly NLog.ILogger logger = LogManager.GetCurrentClassLogger();

        User user;

        public ItemBox box;

        public ItemManager(User user)
        {
            this.user = user;
            box = new ItemBox(user);
        }

        public void addReward(long reward)
        {
            RewardData rewardData;

            //아이템 획득 처리
            if (reward == 0)
            {
                //따로 처리가 필요함.
            }
            else
            {
                rewardData = Statics.rewardExcel.getRewardData(reward);
                switch (rewardData.reward_item_type)
                {
                    case eRewardItemType.gold:
                        user.gold += rewardData.return_count;
                        break;
                    case eRewardItemType.freecash:
                        user.free_cash += rewardData.return_count;
                        break;
                    case eRewardItemType.paycash:
                        user.pay_cash += rewardData.return_count;
                        break;
                    case eRewardItemType.character:
                        for (int n = 0; n < rewardData.return_count; n++)
                        {
                            DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
                            deckUnitInfo.user_id = user.id;
                            deckUnitInfo.unit_data_id = rewardData.return_item;
                            box.Add(deckUnitInfo);
                        }
                        break;
                    case eRewardItemType.equipment:
                        Random rand = new Random();
                        for (int n = 0; n < rewardData.return_count; n++)
                        {
                            Equipment equipment = new Equipment();
                            equipment.user_id = user.id;
                            equipment.equip_unit = 0;
                            equipment.rand_stats = rand.Next(5);
                            equipment.equipment_data_id = rewardData.return_item;
                            box.Add(equipment);
                        }
                        break;
                    case eRewardItemType.consumable:
                        ConsumableItem consumableItem = new ConsumableItem();
                        consumableItem.user_id = user.id;
                        consumableItem.consumable_item_data_id = rewardData.return_item;
                        consumableItem.count = rewardData.return_count;
                        box.Add(consumableItem);
                        break;
                    case eRewardItemType.etc:
                        EtcItem etcItem = new EtcItem();
                        etcItem.user_id = user.id;
                        etcItem.etc_item_data_id = rewardData.return_item;
                        etcItem.count = rewardData.return_count;
                        box.Add(etcItem);
                        break;
                    default:
                        throw new RuntimeException("Not case", Error.nodata);


                }
            }
        }

        //리워드 아이탬 획득 코드 작성
        //패키지 구매시 패키지를 전부 풀어서 아이탬을 획득하는 코드 작성
    }

    public class ItemBox
    {
        //유닛
        List<DeckUnitInfo> _deckUnitInfo;
        public List<DeckUnitInfo> deckUnitInfo { get { return _deckUnitInfo; } }
        public List<DeckUnitInfo> addDeckUnitInfo;

        //장비
        List<Equipment> _equipment;
        public List<Equipment> equipment { get { return _equipment; } }
        public List<Equipment> addEquipment;
        
        //소모품
        List<ConsumableItem> _consumableItem;
        public List<ConsumableItem> consumableItem { get { return _consumableItem; } }
        public List<ConsumableItem> addConsumableItem;

        //기타
        List<EtcItem> _etcItem;
        public List<EtcItem> etcItem { get { return _etcItem; } }
        public List<EtcItem> addEtcItem;
        public ItemBox(User user)
        {
            _deckUnitInfo = Statics.deckUnitInfoSQL.SelectUid(user.id);
            _equipment = Statics.equipmentrSQL.SelectUid(user.id);
            addDeckUnitInfo = new List<DeckUnitInfo>();
            addEquipment = new List<Equipment>();
        }

        public void SaveSQL()
        {
            if (addDeckUnitInfo.Count != 0)
            {
                Statics.deckUnitInfoSQL.Insert(addDeckUnitInfo);
                Statics.deckUnitInfoSQL.SaveChanges();
                addDeckUnitInfo.Clear();
            }
            if (addEquipment.Count != 0)
            {
                Statics.equipmentrSQL.Insert(addEquipment);
                Statics.equipmentrSQL.SaveChanges();
                addEquipment.Clear();
            }
        }

        public bool Add(DeckUnitInfo item)
        {
            if(_deckUnitInfo.FindIndex(n => n.unit_data_id == item.unit_data_id) != -1)
                return false;
            _deckUnitInfo.Add(item);
            addDeckUnitInfo.Add(item);
            return true;
        }

        public bool Add(List<DeckUnitInfo> items)
        {
            foreach(var item in items)
            {
                if (_deckUnitInfo.FindIndex(n => n.unit_data_id == item.unit_data_id) != -1)
                    return false;
            }
            _deckUnitInfo.AddRange(items);
            addDeckUnitInfo.AddRange(items);
            return true;
        }

        public bool Add(Equipment item)
        {
            _equipment.Add(item);
            addEquipment.Add(item);
            return true;
        }

        public bool Add(List<Equipment> items)
        {
            _equipment.AddRange(items);
            addEquipment.AddRange(items);
            return true;
        }

        public bool Add(ConsumableItem item)
        {
            int index = _consumableItem.FindIndex(n => n.consumable_item_data_id == item.consumable_item_data_id);
            int addIndex = addConsumableItem.FindIndex(n => n.consumable_item_data_id == item.consumable_item_data_id);
            if (index == -1)
            {
                _consumableItem.Add(item);
            }
            else
            {
                _consumableItem[index].count += item.count;
            }
            if (addIndex == -1)
            {
                addConsumableItem.Add(item);
            }
            else
            {
                addConsumableItem[index].count += item.count;
            }
            return true;
        }

        public bool Add(List<ConsumableItem> items)
        {
            foreach(ConsumableItem item in items)
            {
                int index = _consumableItem.FindIndex(n => n.consumable_item_data_id == item.consumable_item_data_id);
                int addIndex = addConsumableItem.FindIndex(n => n.consumable_item_data_id == item.consumable_item_data_id);
                if (index == -1)
                {
                    _consumableItem.Add(item);
                }
                else
                {
                    _consumableItem[index].count += item.count;
                }
                if (addIndex == -1)
                {
                    addConsumableItem.Add(item);
                }
                else
                {
                    addConsumableItem[index].count += item.count;
                }
            }
            return true;
        }

        public bool Add(EtcItem item)
        {
            int index = _etcItem.FindIndex(n => n.etc_item_data_id == item.etc_item_data_id);
            int addIndex = addEtcItem.FindIndex(n => n.etc_item_data_id == item.etc_item_data_id);
            if (index == -1)
            {
                _etcItem.Add(item);
            }
            else
            {
                _etcItem[index].count += item.count;
            }
            if (addIndex == -1)
            {
                addEtcItem.Add(item);
            }
            else
            {
                addEtcItem[index].count += item.count;
            }
            return true;
        }

        public bool Add(List<EtcItem> items)
        {
            foreach (EtcItem item in items)
            {
                int index = _etcItem.FindIndex(n => n.etc_item_data_id == item.etc_item_data_id);
                int addIndex = addEtcItem.FindIndex(n => n.etc_item_data_id == item.etc_item_data_id);
                if (index == -1)
                {
                    _etcItem.Add(item);
                }
                else
                {
                    _etcItem[index].count += item.count;
                }
                if (addIndex == -1)
                {
                    addEtcItem.Add(item);
                }
                else
                {
                    addEtcItem[index].count += item.count;
                }
            }
            return true;
        }
    }

}