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

namespace Server.Manager
{
    public class ItemManager
    {
        User user;

        public ItemBox box;

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

        public void addReward(long reward)
        {
            RewardData rewardData;

            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:
                    DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
                    deckUnitInfo.user_id = user.id;
                    deckUnitInfo.unit_data_id = rewardData.return_item;
                    if (!box.Add(deckUnitInfo))
                        user.free_cash += 2500;
                    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(4);
                        equipment.equipment_data_id = rewardData.return_item;
                        if(!box.Add(equipment))
                            throw new RuntimeException("Unknown Error [box.Add(equipment)]", Error.RuntimeException);
                    }
                    break;
                case eRewardItemType.consumable:
                    ConsumableItemData consumableItemData = Statics.consumableItemExcel.getConsumableItemData(rewardData.return_item);
                    switch (consumableItemData.item_type)
                    {
                        case eItemType.exp:
                        case eItemType.package:
                            ConsumableItem consumableItem = new ConsumableItem();
                            consumableItem.user_id = user.id;
                            consumableItem.consumable_item_data_id = rewardData.return_item;
                            consumableItem.count = rewardData.return_count;
                            if(!box.Add(consumableItem))
                                throw new RuntimeException("Unknown Error [box.Add(consumableItem)]", Error.RuntimeException);
                            break;
                        case eItemType.random:
                            randomItem(consumableItemData.reward, rewardData.return_count);
                            break;
                    }

                    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;
                    if (!box.Add(etcItem))
                        throw new RuntimeException("Unknown Error [box.Add(etcItem)]", Error.RuntimeException);
                    break;
                default:
                    throw new RuntimeException("Not case", Error.NoData);
            }
        }

        public void addUnit(int unitDataId)
        {
            DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
            deckUnitInfo.user_id = user.id;
            deckUnitInfo.unit_data_id = unitDataId;
            if (!box.Add(deckUnitInfo))
                user.free_cash += 2500;
        }

        public void randomItem(int group, int count)
        {
            List<RandomRewardData> randomRewardDatas = Statics.randomRewardExcel.getRandomRewardDataGroup(group);

            int maxProb = 0;
            List<int> zero = new List<int>();
            List<int> ints = new List<int>();

            //확정보상부터 지급
            for (int n = 0; n < randomRewardDatas.Count; n++)
            {
                if (randomRewardDatas[n].prob == -1)
                {
                    //보상지급
                    switch (randomRewardDatas[n].reward_item_type)
                    {
                        case eRewardItemType.gold:
                            user.gold += (randomRewardDatas[n].return_count * count);
                            break;
                        case eRewardItemType.freecash:
                            user.free_cash += (randomRewardDatas[n].return_count * count);
                            break;
                        case eRewardItemType.paycash:
                            user.pay_cash += (randomRewardDatas[n].return_count * count);
                            break;
                        case eRewardItemType.character:
                            DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
                            deckUnitInfo.user_id = user.id;
                            deckUnitInfo.unit_data_id = randomRewardDatas[n].reward;
                            if (!box.Add(deckUnitInfo))
                                user.free_cash += 2500;
                            break;
                        case eRewardItemType.equipment:
                            Random rand = new Random();
                            int reward_count = (randomRewardDatas[n].return_count * count);
                            for (int m = 0; m < reward_count; m++)
                            {
                                Equipment equipment = new Equipment();
                                equipment.user_id = user.id;
                                equipment.equip_unit = 0;
                                equipment.rand_stats = rand.Next(4);
                                equipment.equipment_data_id = randomRewardDatas[n].reward;
                                if (!box.Add(equipment))
                                    throw new RuntimeException("Unknown Error [box.Add(equipment)]", Error.RuntimeException);
                            }
                            break;
                        case eRewardItemType.consumable:
                            //패키지에서 나온 아이탬은 절대 가챠를 돌리지 않고 아이템 형태로 인벤 지급
                            ConsumableItem consumableItem = new ConsumableItem();
                            consumableItem.user_id = user.id;
                            consumableItem.consumable_item_data_id = randomRewardDatas[n].reward;
                            consumableItem.count = (randomRewardDatas[n].return_count * count);
                            if (!box.Add(consumableItem))
                                throw new RuntimeException("Unknown Error [box.Add(consumableItem)]", Error.RuntimeException);
                            break;
                        case eRewardItemType.etc:
                            EtcItem etcItem = new EtcItem();
                            etcItem.user_id = user.id;
                            etcItem.etc_item_data_id = randomRewardDatas[n].reward;
                            etcItem.count = (randomRewardDatas[n].return_count * count);
                            if (!box.Add(etcItem))
                                throw new RuntimeException("Unknown Error [box.Add(etcItem)]", Error.RuntimeException);
                            break;
                        default:
                            throw new RuntimeException("Not case", Error.NoData);
                    }
                    //지급된 보상은 가챠에서 제외
                    randomRewardDatas.RemoveAt(n);
                    n--;
                }
                else if (randomRewardDatas[n].prob == 0)
                {
                    zero.Add(n);
                }
                else
                {
                    maxProb += randomRewardDatas[n].prob;
                    for(int m = 0; m < randomRewardDatas[n].prob; m++)
                    {
                        ints.Add(n);
                    }
                }
            }

            //모든것이 확정보상일경우를 대비
            if(randomRewardDatas.Count != 0)
            {
                Random rand = new Random();
                if (maxProb == 0)
                {
                    maxProb = randomRewardDatas.Count;
                    for (int n = 0; n < maxProb; n++)
                    {
                        ints.Add(n);
                    }
                }
                else
                    maxProb = 10000;


                for (int n = 0; n < count; n++)
                {
                    int select = rand.Next(maxProb);
                    int selectItem = 0;
                    if(select < ints.Count)
                    {
                        selectItem = ints[select];
                    }
                    else
                    {
                        select = rand.Next(zero.Count);
                        selectItem = zero[select];
                    }
                    switch (randomRewardDatas[selectItem].reward_item_type)
                    {
                        case eRewardItemType.gold:
                            user.gold += randomRewardDatas[selectItem].return_count;
                            break;
                        case eRewardItemType.freecash:
                            user.free_cash += randomRewardDatas[selectItem].return_count;
                            break;
                        case eRewardItemType.paycash:
                            user.pay_cash += randomRewardDatas[selectItem].return_count;
                            break;
                        case eRewardItemType.character:
                            DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
                            deckUnitInfo.user_id = user.id;
                            deckUnitInfo.unit_data_id = randomRewardDatas[selectItem].reward;
                            if (!box.Add(deckUnitInfo))
                                user.free_cash += 2500;
                            break;
                        case eRewardItemType.equipment:
                            int reward_count = randomRewardDatas[selectItem].return_count;
                            for (int m = 0; m < reward_count; m++)
                            {
                                Equipment equipment = new Equipment();
                                equipment.user_id = user.id;
                                equipment.equip_unit = 0;
                                equipment.rand_stats = rand.Next(4);
                                equipment.equipment_data_id = randomRewardDatas[selectItem].reward;
                                if (!box.Add(equipment))
                                    throw new RuntimeException("Unknown Error [box.Add(equipment)]", Error.RuntimeException);
                            }
                            break;
                        case eRewardItemType.consumable:
                            //패키지에서 나온 아이탬은 절대 가챠를 돌리지 않고 아이템 형태로 인벤 지급
                            ConsumableItem consumableItem = new ConsumableItem();
                            consumableItem.user_id = user.id;
                            consumableItem.consumable_item_data_id = randomRewardDatas[selectItem].reward;
                            consumableItem.count = randomRewardDatas[selectItem].return_count;
                            if (!box.Add(consumableItem))
                                throw new RuntimeException("Unknown Error [box.Add(consumableItem)]", Error.RuntimeException);
                            break;
                        case eRewardItemType.etc:
                            EtcItem etcItem = new EtcItem();
                            etcItem.user_id = user.id;
                            etcItem.etc_item_data_id = randomRewardDatas[selectItem].reward;
                            etcItem.count = randomRewardDatas[selectItem].return_count;
                            if (!box.Add(etcItem))
                                throw new RuntimeException("Unknown Error [box.Add(etcItem)]", Error.RuntimeException);
                            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;

        User user;
        public ItemBox(User user)
        {
            this.user = user;
            _deckUnitInfo = Statics.deckUnitInfoSQL.SelectUid(user.id);
            _equipment = Statics.equipmentrSQL.SelectUid(user.id);
            _consumableItem = Statics.consumableItemSQL.SelectUid(user.id);
            _etcItem = Statics.etcItemSQL.SelectUid(user.id);
            addDeckUnitInfo = new List<DeckUnitInfo>();
            addEquipment = new List<Equipment>();
            addConsumableItem = new List<ConsumableItem>();
            addEtcItem = new List<EtcItem>();
        }

        public void SaveSQL()
        {
            Statics.userSQL.Update(user);
            Statics.userSQL.SaveChanges();
            if (addDeckUnitInfo.Count != 0)
                Statics.deckUnitInfoSQL.Insert(addDeckUnitInfo);
            if (addEquipment.Count != 0)
                Statics.equipmentrSQL.Insert(addEquipment);
            if (addConsumableItem.Count != 0)
            {
                List<ConsumableItem> newItem = new List<ConsumableItem>();
                foreach (var item in _consumableItem)
                {
                    if (item.id == 0)
                    {
                        newItem.Add(item);
                    }
                }
                if (newItem.Count != 0)
                    Statics.consumableItemSQL.Insert(newItem);
            }
            if (addEtcItem.Count != 0)
            {
                List<EtcItem> newItem = new List<EtcItem>();
                foreach (var item in _etcItem)
                {
                    if (item.id == 0)
                    {
                        newItem.Add(item);
                    }
                }
                if (newItem.Count != 0)
                    Statics.etcItemSQL.Insert(newItem);
            }
            Statics.deckUnitInfoSQL.SaveChanges();
            Statics.equipmentrSQL.SaveChanges();
            Statics.consumableItemSQL.SaveChanges();
            Statics.etcItemSQL.SaveChanges();
        }

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

        public bool Add(List<DeckUnitInfo> items)
        {
            foreach (DeckUnitInfo item in items)
            {
                if (!Add(item))
                    return false;
            }
            return true;
        }

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

        public bool Add(List<Equipment> items)
        {
            foreach (Equipment item in items)
            {
                if (!Add(item))
                    return false;
            }
            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;
                item.id = _consumableItem[index].id;
            }
            if (addIndex == -1)
            {
                addConsumableItem.Add(item);
            }
            else
            {
                addConsumableItem[addIndex].count += item.count;
            }
            return true;
        }

        public bool Add(List<ConsumableItem> items)
        {
            foreach(ConsumableItem item in items)
            {
                if (!Add(item))
                    return false;
            }
            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;
                item.id = _etcItem[index].id;
            }
            if (addIndex == -1)
            {
                addEtcItem.Add(item);
            }
            else
            {
                addEtcItem[addIndex].count += item.count;
            }
            return true;
        }

        public bool Add(List<EtcItem> items)
        {
            foreach (EtcItem item in items)
            {
                if (!Add(item))
                    return false;
            }
            return true;
        }
    }

}