namespace Supercell.Laser.Logic.Home
{
    using Supercell.Laser.Logic.Avatar;
    using Supercell.Laser.Logic.Battle.Objects;
    using Supercell.Laser.Logic.Command;
    using Supercell.Laser.Logic.Data;
    using Supercell.Laser.Logic.Data.Helper;
    using Supercell.Laser.Logic.Home.Gatcha;
    using Supercell.Laser.Logic.Home.Items;
    using Supercell.Laser.Logic.Home.Structures;
    using Supercell.Laser.Logic.Listener;
    using Supercell.Laser.Logic.Message.Home;
    using Supercell.Laser.Titan.Math;
    using System.Diagnostics;

    public class HomeMode
    {
        public const int UNLOCKABLE_HEROES_COUNT = 49;

        public readonly LogicGameListener GameListener;

        public ClientHome Home;
        public ClientAvatar Avatar;

        public Action<int> CharacterChanged;

        public HomeMode(ClientHome home, ClientAvatar avatar, LogicGameListener gameListener)
        {
            Home = home;
            Avatar = avatar;

            Home.HomeMode = this;
            Avatar.HomeMode = this;

            GameListener = gameListener;
        }

        public static HomeMode LoadHomeState(LogicGameListener gameListener, ClientHome home, ClientAvatar avatar, EventData[] events)
        {
            home.Events = events;

            HomeMode homeMode = new HomeMode(home, avatar, gameListener);
            homeMode.Enter(DateTime.UtcNow);

            return homeMode;
        }
        
        public bool ProcessPinPack(List<DeliveryUnit> deliveryUnits, int packType, int skinDataId)
{
    var emoteTable = DataTables.Get(DataType.Emote);
    var unlocked = new HashSet<int>(Home.UnlockedEmotes);

    List<EmoteData> pool = emoteTable.GetAll<EmoteData>()
        .Where(e => !e.Disabled && !string.IsNullOrEmpty(e.Character) && string.IsNullOrEmpty(e.Skin) && e.Rarity >= 0 && e.EmoteType != -1)
        .Where(e => !unlocked.Contains(e.GetGlobalId()))
        .Where(e =>
        {
            CharacterData ch = DataTables.Get(DataType.Character).GetData<CharacterData>(e.Character);
            return ch != null && Avatar.HasHero(ch.GetGlobalId());
        })
        .ToList();

    List<EmoteData> commonPool = pool.Where(e => e.Rarity == 0).ToList();
    List<EmoteData> rarePool = pool.Where(e => e.Rarity == 1).ToList();
    List<EmoteData> epicPool = pool.Where(e => e.Rarity >= 2).ToList();

    List<EmoteData> result = new List<EmoteData>();
    System.Random rnd = new System.Random();

    if (packType == 0)
    {
        if (pool.Count == 0)
        {
            AddGoldCompensation(deliveryUnits);
            return false;
        }

        result.AddRange(commonPool.OrderBy(x => Guid.NewGuid()).Take(2));

        int roll = rnd.Next(100);
        EmoteData bonus = null;

        if (roll < 70)
            bonus = rarePool.Except(result).OrderBy(x => Guid.NewGuid()).FirstOrDefault();

        bonus ??= epicPool.Except(result).OrderBy(x => Guid.NewGuid()).FirstOrDefault();
        bonus ??= rarePool.Except(result).OrderBy(x => Guid.NewGuid()).FirstOrDefault();
        bonus ??= commonPool.Except(result).OrderBy(x => Guid.NewGuid()).FirstOrDefault();

        if (bonus != null)
            result.Add(bonus);
    }
    else if (packType == 1)
    {
        List<EmoteData> targetPool = skinDataId == 0
            ? commonPool
            : skinDataId == 1
                ? rarePool
                : epicPool;

        if (targetPool.Count == 0)
        {
            AddGoldCompensation(deliveryUnits);
            return false;
        }

        result.AddRange(targetPool.OrderBy(x => Guid.NewGuid()).Take(3));
    }

    if (result.Count == 0)
    {
        AddGoldCompensation(deliveryUnits);
        return false;
    }

    DeliveryUnit unit = new DeliveryUnit(100);

    foreach (var emote in result)
    {
        GatchaDrop reward = new GatchaDrop(11)
        {
            Count = 1,
            PinGlobalId = emote.GetGlobalId()
        };

        unit.AddDrop(reward);
        Home.UnlockedEmotes.Add(emote.GetGlobalId());
    }

    deliveryUnits.Add(unit);
    return true;
}

private void AddGoldCompensation(List<DeliveryUnit> deliveryUnits)
{
    DeliveryUnit unit = new DeliveryUnit(100);
    GatchaDrop reward = new GatchaDrop(7);
    reward.Count = 3000;
    unit.AddDrop(reward);
    deliveryUnits.Add(unit);
}
 
        private bool GetRandomBrawlerForGatcha(Random rand, DeliveryUnit unit)
        {
            List<int> Brawlers = new() { 4, 5, 6, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 28, 29, 31, 32, 34, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47 };

            List<int> UnlockedBrawlers = new List<int>();
            foreach (Hero hero in Avatar.Heroes)
            {
                UnlockedBrawlers.Add(GlobalId.GetInstanceId(hero.CharacterId));
            }
            List<int> UnlockableBrawlers = Brawlers.Where(x => !UnlockedBrawlers.Contains(x)).ToList();
            if (UnlockableBrawlers.Count == 0) return false;
            int Brawler = GlobalId.CreateGlobalId(16, UnlockableBrawlers[rand.Next(UnlockableBrawlers.Count)]);

            CharacterData Character = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(Brawler);
            //CardData Card = DataTables.Get(DataType.Card).GetData<CardData>(Character.Name + "_unlock");
            GatchaDrop drop = new(1)
            {
                DataGlobalId = Character.GetGlobalId(),
                Count = 1
            };
            unit.AddDrop(drop);
            return true;
        }

        public bool ProcChance(Random r, double chance, string type, double forcedDrops)
        {
            double v1 = r.Next(0, 1000) / 10;
            switch (type)
            {
                case "bonus":
                    chance += forcedDrops * 2;
                    break;
                case "starpower":
                    chance += forcedDrops * 1.25;
                    break;
                case "character":
                    chance += forcedDrops * 0.5;
                    break;
            }
            return v1 < chance;
        }
        public double GetMultByRarity(string rarity)
        {
            double result = 0;
            switch (rarity)
            {
                case "bonus":
                    result = 0.5;
                    break;
                case "character":
                    result = 2;
                    break;
                case "card_notchar":
                    result = 4;
                    break;
                case "rare":
                    result = 2;
                    break;
                case "super_rare":
                    result = 3;
                    break;
                case "epic":
                    result = 5;
                    break;
                case "super_epic":
                    result = 7;
                    break;
                case "legendary":
                    result = 10;
                    break;
            }
            return result;
        }
        public double CalcForcedDrop(bool proc, string rarity, string type, double forcedDrops, string box)
        {
            double result = 0.0;
            double v1 = 0.0;
            double v2 = 0.0;
            double v3 = 0.0;

            double v4 = 0.0;
            double v5 = 0.0;
            double v6 = 0.0;

            double v7 = GetMultByRarity(rarity);
            double v8 = forcedDrops;
            switch (box)
            {
                case "mega":
                    v1 = 0.66;
                    v2 = 0.33;
                    v3 = 0.125;

                    v4 = 0.66 * v7;
                    v5 = 0.66 * v7;
                    v6 = 0.66 * v7;
                    break;
                case "big":
                    v1 = 0.33;
                    v2 = 0.125;
                    v3 = 0.065;

                    v4 = 0.55 * v7;
                    v5 = 0.55 * v7;
                    v6 = 0.55 * v7;
                    break;
                case "box":
                    v1 = 0.22;
                    v2 = 0.10;
                    v3 = 0.045;

                    v4 = 0.44 * v7;
                    v5 = 0.44 * v7;
                    v6 = 0.44 * v7;
                    break;
            }
            if (!proc)
            {
                switch (type)
                {
                    case "bonus":
                        v8 += v3;
                        break;
                    case "character":
                        v8 += v1;
                        break;
                    case "starpower":
                        v8 += v2;
                        break;
                }
            }
            else
            {
                switch (type)
                {
                    case "bonus":
                        v8 = Math.Max(0, v8 - v6);
                        break;
                    case "character":
                        v8 += Math.Max(0, v8 - v4);
                        break;
                    case "starpower":
                        v8 = Math.Max(0, v8 - v5);
                        break;
                }

            }
            if (v8 > 10)
            {
                result = 10;
            }
            else
            {
                result = v8;
            }
            return result;
        }
        public void SimulateGatcha(DeliveryUnit unit)
{
    List<int> Brawlers = new() { 4, 5, 6, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47 };

    List<int> UnlockedBrawlers = new List<int>();
    foreach (Hero hero in Avatar.Heroes)
    {
        UnlockedBrawlers.Add(GlobalId.GetInstanceId(hero.CharacterId));
    }
    List<int> UnlockableBrawlers = Brawlers.Where(x => !UnlockedBrawlers.Contains(x)).ToList();
    bool isBr = false;

    bool isSp = false; bool canDropSp = false; List<int> sps = new(); Avatar.RollsSinceGoodDrop++; Random rand = new(); List<int> DiamondsReward = new() { 3, 5, 7, 12 }; int unlockedBrawlersCount = Avatar.GetUnlockedHeroesCount(); List<int> possibleBonuses = new() { 1 }; List<int> powerPoints = new(); if (unit.Type == 10)
    {
        List<int> TokenDoublersReward = new() { 200 }; List<int> TicketsReward = new() { 1, 2, 3 }; List<Hero> CanHavePowerPoints = new List<Hero>(); foreach (Hero hero in Avatar.Heroes)
        {
            if (hero.PowerLevel != 8)
            {
                if (hero.PowerPoints < 1410)
                {
                    CanHavePowerPoints.Add(hero);
                }
                continue;
            }
        }
        int count = CanHavePowerPoints.Count; Dictionary<int, int> Avards = new(); int bonusChance = 0; if (UnlockedBrawlers.Count < 3)
        {
            bonusChance = 6;
        }
        else if (UnlockedBrawlers.Count < 5)
        {
            bonusChance = 4;
        }
        else if (UnlockedBrawlers.Count < 7)
        {
            bonusChance = 2;
        }
        if (UnlockableBrawlers.Count > 0 && !isBr)
        {
            Avatar.ForcedDrops = CalcForcedDrop(false, "character", "starpower", Avatar.ForcedDrops, "box");
        }
        foreach (Hero hero in Avatar.Heroes)
        {
            if (hero.PowerLevel >= 6)
            {
                canDropSp = true;
                break;
            }
        }
        if (ProcChance(rand, 5 * 1 + bonusChance, "character", Avatar.ForcedDrops) && UnlockableBrawlers.Count > 0)
        {
            isBr = true;
            int Brawler = GlobalId.CreateGlobalId(16, UnlockableBrawlers[rand.Next(UnlockableBrawlers.Count)]);
            UnlockableBrawlers.Remove(GlobalId.GetInstanceId(Brawler));
            CharacterData Character = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(Brawler);
            CardData Card = DataTables.Get(DataType.Card).GetData<CardData>(Character.Name + "_unlock");
            GatchaDrop drop = new(1) { DataGlobalId = Character.GetGlobalId(), Count = 1 };
            unit.AddDrop(drop);
            Avatar.ForcedDrops = CalcForcedDrop(true, Card.Rarity, "starpower", Avatar.ForcedDrops, "box");
        }
        if (!isBr && canDropSp)
        {
            foreach (Hero hero in Avatar.Heroes)
            {
                if (hero.PowerLevel == 8)
                {
                    CardData card = null;
                    CharacterData cd = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(hero.CharacterId);
                    card = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique");
                    CardData card2 = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique_2");
                    CardData card3 = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique_3");
                    if (card3 != null)
                    {
                        if (card3.LockedForChronos)
                        {
                            card3 = null;
                        }
                    }
                    if (card3 == null)
                    {
                        if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            sps.Add(card2.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            sps.Add(card.GetGlobalId());
                        }
                    }
                    else
                    {
                        if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            int r = rand.Next(0, 2);
                            if (r == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else if (r == 1)
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card3.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card.GetGlobalId());
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card2.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                    }
                }
                if (hero.PowerLevel > 5)
                {
                    CharacterData cd = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(hero.CharacterId);
                    foreach (CardData cardData in DataTables.Get(DataType.Card).GetAll<CardData>())
                    {
                        if (cardData.Target == cd.Name)
                        {
                            if (cardData.MetaType == 4 && hero.PowerLevel >= 8 && !Avatar.UnlockedMeta.Contains(cardData.GetGlobalId()) && !sps.Contains(cardData.GetGlobalId()))
                            {
                                sps.Add(cardData.GetGlobalId());
                            }
                            else if (cardData.MetaType == 5 && hero.PowerLevel >= 6 && !Avatar.UnlockedMeta.Contains(cardData.GetGlobalId()) && !sps.Contains(cardData.GetGlobalId()))
                            {
                                sps.Add(cardData.GetGlobalId());
                            }
                        }
                    }
                }
            }
            bool spdrop = false; if (ProcChance(rand, 11 * 1, "starpower", Avatar.ForcedDrops) && sps.Count > 0)
            {
                spdrop = true;
                int sp = sps[rand.Next(sps.Count)];
                GatchaDrop drop = new(4) { CardGlobalId = sp, Count = 1 };
                unit.AddDrop(drop);
                CardData card = DataTables.Get(DataType.Card).GetDataByGlobalId<CardData>(sp);
                CharacterData hero = DataTables.Get(DataType.Character).GetData<CharacterData>(card.Name.Split("_")[0]);
                Hero h = Avatar.GetHero(hero.GetGlobalId());
                h.HasStarpower = true;
                Avatar.ForcedDrops = CalcForcedDrop(true, "card_notchar", "starpower", Avatar.ForcedDrops, "box");
                sps.Remove(sp);
            }
            else
            {
                Avatar.ForcedDrops = CalcForcedDrop(false, "card_notchar", "starpower", Avatar.ForcedDrops, "box");
                canDropSp = false;
            }
        }
        if (!canDropSp && !isBr)
        {
            GatchaDrop coins = new(7) { Count = rand.Next(25, 75) };
            unit.AddDrop(coins);
            for (int x = 0; Math.Min(count, 2) > x; x++)
            {
                Hero Brawler = CanHavePowerPoints[rand.Next(CanHavePowerPoints.Count)];
                CanHavePowerPoints.RemoveAll(h => h.CharacterId == Brawler.CharacterId);
                int oldpp = Brawler.PowerPoints;
                int PowerPoints = rand.Next(5, 45);
                if (oldpp + PowerPoints > 1410)
                {
                    PowerPoints = 1410 - oldpp;
                }
                if (Avards.ContainsKey(Brawler.CharacterId))
                    Avards[Brawler.CharacterId] += PowerPoints;
                else
                    Avards.Add(Brawler.CharacterId, PowerPoints);
            }
            List<KeyValuePair<int, int>> list = Avards.ToList();
            list.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
            Dictionary<int, int> FinalAwards = new Dictionary<int, int>();
            foreach (KeyValuePair<int, int> pair in list)
            {
                FinalAwards.Add(pair.Key, pair.Value);
            }
            foreach (KeyValuePair<int, int> avard in FinalAwards)
            {
                GatchaDrop drop = new(6) { Count = avard.Value, DataGlobalId = avard.Key };
                unit.AddDrop(drop);
            }
            while (ProcChance(rand, 10, "bonus", Avatar.ForcedDrops) && possibleBonuses.Count > 0)
            {
                Avatar.ForcedDrops = CalcForcedDrop(true, "bonus", "bonus", Avatar.ForcedDrops, "box");
                int bonusType = possibleBonuses[rand.Next(0, possibleBonuses.Count)];
                switch (bonusType)
                {
                    case 1: GatchaDrop tokens = new(2) { Count = TokenDoublersReward[rand.Next(TokenDoublersReward.Count)] }; unit.AddDrop(tokens); break;
                    case 2: GatchaDrop tickets = new(3) { Count = TicketsReward[rand.Next(TicketsReward.Count)] }; unit.AddDrop(tickets); break;
                }
                possibleBonuses.Remove(bonusType);
            }
            if (possibleBonuses.Count == 3)
            {
                Avatar.ForcedDrops = CalcForcedDrop(false, "bonus", "bonus", Avatar.ForcedDrops, "box");
            }
        }
    }
    else if (unit.Type == 12)
    {
        List<int> TokenDoublersReward = new() { 200, 400 }; List<int> TicketsReward = new() { 1, 2, 3, 5 }; GatchaDrop coins = new(7) { Count = rand.Next(50, 200) }; unit.AddDrop(coins); List<Hero> CanHavePowerPoints = new List<Hero>(); foreach (Hero hero in Avatar.Heroes)
        {
            if (hero.PowerLevel != 8)
            {
                if (hero.PowerPoints < 1410)
                {
                    CanHavePowerPoints.Add(hero);
                }
                continue;
            }
        }
        int count = CanHavePowerPoints.Count; Dictionary<int, int> Avards = new(); for (int x = 0; Math.Min(count, 3) > x; x++)
        {
            Hero Brawler = CanHavePowerPoints[rand.Next(CanHavePowerPoints.Count)];
            CanHavePowerPoints.RemoveAll(h => h.CharacterId == Brawler.CharacterId);
            int oldpp = Brawler.PowerPoints;
            int PowerPoints = rand.Next(15, 125);
            if (oldpp + PowerPoints > 1410)
            {
                PowerPoints = 1410 - oldpp;
            }
            if (Avards.ContainsKey(Brawler.CharacterId))
                Avards[Brawler.CharacterId] += PowerPoints;
            else
                Avards.Add(Brawler.CharacterId, PowerPoints);
        }
        List<KeyValuePair<int, int>> list = Avards.ToList();
        list.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
        Dictionary<int, int> FinalAwards = new Dictionary<int, int>();
        foreach (KeyValuePair<int, int> pair in list)
        {
            FinalAwards.Add(pair.Key, pair.Value);
        }
        foreach (KeyValuePair<int, int> avard in FinalAwards)
        {
            GatchaDrop drop = new(6) { Count = avard.Value, DataGlobalId = avard.Key };
            unit.AddDrop(drop);
        }
        int bonusChance = 0; if (UnlockedBrawlers.Count < 3)
        {
            bonusChance = 6;
        }
        else if (UnlockedBrawlers.Count < 5)
        {
            bonusChance = 4;
        }
        else if (UnlockedBrawlers.Count < 7)
        {
            bonusChance = 2;
        }
        while (ProcChance(rand, 5 * 2 + bonusChance, "character", Avatar.ForcedDrops) && UnlockableBrawlers.Count > 0)
        {
            isBr = true;
            int Brawler = GlobalId.CreateGlobalId(16, UnlockableBrawlers[rand.Next(UnlockableBrawlers.Count)]);
            UnlockableBrawlers.Remove(GlobalId.GetInstanceId(Brawler));
            CharacterData Character = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(Brawler);
            CardData Card = DataTables.Get(DataType.Card).GetData<CardData>(Character.Name + "_unlock");
            GatchaDrop drop = new(1) { DataGlobalId = Character.GetGlobalId(), Count = 1 };
            unit.AddDrop(drop);
            Avatar.ForcedDrops = CalcForcedDrop(true, Card.Rarity, "starpower", Avatar.ForcedDrops, "big");
        }
        if (UnlockableBrawlers.Count > 0 && !isBr)
        {
            Avatar.ForcedDrops = CalcForcedDrop(false, "character", "starpower", Avatar.ForcedDrops, "big");
        }
        foreach (Hero hero in Avatar.Heroes)
        {
            if (hero.PowerLevel >= 6)
            {
                canDropSp = true;
                break;
            }
        }
        if (canDropSp)
        {
            foreach (Hero hero in Avatar.Heroes)
            {
                if (hero.PowerLevel == 8)
                {
                    CardData card = null;
                    CharacterData cd = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(hero.CharacterId);
                    card = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique");
                    CardData card2 = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique_2");
                    CardData card3 = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique_3");
                    if (card3 != null)
                    {
                        if (card3.LockedForChronos)
                        {
                            card3 = null;
                        }
                    }
                    if (card3 == null)
                    {
                        if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            sps.Add(card2.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            sps.Add(card.GetGlobalId());
                        }
                    }
                    else
                    {
                        if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            int r = rand.Next(0, 2);
                            if (r == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else if (r == 1)
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card3.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card.GetGlobalId());
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card2.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                    }
                }
                if (hero.PowerLevel > 5)
                {
                    CharacterData cd = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(hero.CharacterId);
                    foreach (CardData cardData in DataTables.Get(DataType.Card).GetAll<CardData>())
                    {
                        if (cardData.Target == cd.Name)
                        {
                            if (cardData.MetaType == 4 && hero.PowerLevel >= 8 && !Avatar.UnlockedMeta.Contains(cardData.GetGlobalId()) && !sps.Contains(cardData.GetGlobalId()))
                            {
                                sps.Add(cardData.GetGlobalId());
                            }
                            else if (cardData.MetaType == 5 && hero.PowerLevel >= 6 && !Avatar.UnlockedMeta.Contains(cardData.GetGlobalId()) && !sps.Contains(cardData.GetGlobalId()))
                            {
                                sps.Add(cardData.GetGlobalId());
                            }
                        }
                    }
                }
            }
        }
        if (canDropSp && sps.Count > 0)
        {
            bool spdrop = false;
            while (ProcChance(rand, 11 * 2, "starpower", Avatar.ForcedDrops) && sps.Count > 0)
            {
                spdrop = true;
                int sp = sps[rand.Next(sps.Count)];
                GatchaDrop drop = new(4) { CardGlobalId = sp, Count = 1 };
                unit.AddDrop(drop);
                CardData card = DataTables.Get(DataType.Card).GetDataByGlobalId<CardData>(sp);
                CharacterData hero = DataTables.Get(DataType.Character).GetData<CharacterData>(card.Name.Split("_")[0]);
                Hero h = Avatar.GetHero(hero.GetGlobalId());
                h.HasStarpower = true;
                Avatar.ForcedDrops = CalcForcedDrop(true, "card_notchar", "starpower", Avatar.ForcedDrops, "big");
                sps.Remove(sp);
            }
            if (sps.Count > 0 && !spdrop)
            {
                Avatar.ForcedDrops = CalcForcedDrop(false, "card_notchar", "starpower", Avatar.ForcedDrops, "big");
            }
        }
        while (ProcChance(rand, 20, "bonus", Avatar.ForcedDrops) && possibleBonuses.Count > 0)
        {
            Avatar.ForcedDrops = CalcForcedDrop(true, "bonus", "bonus", Avatar.ForcedDrops, "big");
            int bonusType = possibleBonuses[rand.Next(0, possibleBonuses.Count)];
            switch (bonusType)
            {
                case 1: GatchaDrop tokens = new(2) { Count = TokenDoublersReward[rand.Next(TokenDoublersReward.Count)] }; unit.AddDrop(tokens); break;
                case 2: GatchaDrop tickets = new(3) { Count = TicketsReward[rand.Next(TicketsReward.Count)] }; unit.AddDrop(tickets); break;
            }
            possibleBonuses.Remove(bonusType);
        }
        if (possibleBonuses.Count == 3)
        {
            Avatar.ForcedDrops = CalcForcedDrop(false, "bonus", "bonus", Avatar.ForcedDrops, "mega");
        }
    }
    else if (unit.Type == 11)
    {
        List<int> TokenDoublersReward = new() { 200, 400, 600 }; List<int> TicketsReward = new() { 1, 2, 3, 5 }; GatchaDrop coins = new(7) { Count = rand.Next(175, 750) }; unit.AddDrop(coins); List<Hero> CanHavePowerPoints = new List<Hero>(); foreach (Hero hero in Avatar.Heroes)
        {
            if (hero.PowerLevel != 8)
            {
                if (hero.PowerPoints < 1410)
                {
                    CanHavePowerPoints.Add(hero);
                }
                continue;
            }
        }
        int count = CanHavePowerPoints.Count; Dictionary<int, int> Avards = new(); for (int x = 0; Math.Min(count, 5) > x; x++)
        {
            Hero Brawler = CanHavePowerPoints[rand.Next(CanHavePowerPoints.Count)];
            CanHavePowerPoints.RemoveAll(h => h.CharacterId == Brawler.CharacterId);
            int oldpp = Brawler.PowerPoints;
            int PowerPoints = rand.Next(25, 250);
            if (oldpp + PowerPoints > 1410)
            {
                PowerPoints = 1410 - oldpp;
            }
            if (Avards.ContainsKey(Brawler.CharacterId))
                Avards[Brawler.CharacterId] += PowerPoints;
            else
                Avards.Add(Brawler.CharacterId, PowerPoints);
        }
        List<KeyValuePair<int, int>> list = Avards.ToList();
        list.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
        Dictionary<int, int> FinalAwards = new Dictionary<int, int>();
        foreach (KeyValuePair<int, int> pair in list)
        {
            FinalAwards.Add(pair.Key, pair.Value);
        }
        foreach (KeyValuePair<int, int> avard in FinalAwards)
        {
            GatchaDrop drop = new(6) { Count = avard.Value, DataGlobalId = avard.Key };
            unit.AddDrop(drop);
        }
        int bonusChance = 0; if (UnlockedBrawlers.Count < 3)
        {
            bonusChance = 7;
        }
        else if (UnlockedBrawlers.Count < 5)
        {
            bonusChance = 5;
        }
        else if (UnlockedBrawlers.Count < 7)
        {
            bonusChance = 3;
        }
        while (ProcChance(rand, 5 * 3 + bonusChance, "character", Avatar.ForcedDrops) && UnlockableBrawlers.Count > 0)
        {
            isBr = true;
            int Brawler = GlobalId.CreateGlobalId(16, UnlockableBrawlers[rand.Next(UnlockableBrawlers.Count)]);
            UnlockableBrawlers.Remove(GlobalId.GetInstanceId(Brawler));
            CharacterData Character = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(Brawler);
            CardData Card = DataTables.Get(DataType.Card).GetData<CardData>(Character.Name + "_unlock");
            GatchaDrop drop = new(1) { DataGlobalId = Character.GetGlobalId(), Count = 1 };
            unit.AddDrop(drop);
            Avatar.ForcedDrops = CalcForcedDrop(true, Card.Rarity, "starpower", Avatar.ForcedDrops, "mega");
        }
        if (UnlockableBrawlers.Count > 0 && !isBr)
        {
            Avatar.ForcedDrops = CalcForcedDrop(false, "character", "starpower", Avatar.ForcedDrops, "mega");
        }
        foreach (Hero hero in Avatar.Heroes)
        {
            if (hero.PowerLevel >= 6)
            {
                canDropSp = true;
                break;
            }
        }
        if (canDropSp)
        {
            foreach (Hero hero in Avatar.Heroes)
            {
                if (hero.PowerLevel == 8)
                {
                    CardData card = null;
                    CharacterData cd = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(hero.CharacterId);
                    card = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique");
                    CardData card2 = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique_2");
                    CardData card3 = DataTables.Get(DataType.Card).GetData<CardData>(cd.Name + "_unique_3");
                    if (card3 != null)
                    {
                        if (card3.LockedForChronos)
                        {
                            card3 = null;
                        }
                    }
                    if (card3 == null)
                    {
                        if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            sps.Add(card2.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()))
                        {
                            sps.Add(card.GetGlobalId());
                        }
                    }
                    else
                    {
                        if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            int r = rand.Next(0, 2);
                            if (r == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else if (r == 1)
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card3.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card.GetGlobalId());
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            sps.Add(card2.GetGlobalId());
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                        }
                        else if (!Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                        else if (Avatar.UnlockedMeta.Contains(card.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card2.GetGlobalId()) && !Avatar.UnlockedMeta.Contains(card3.GetGlobalId()))
                        {
                            if (rand.Next(0, 1) == 0)
                            {
                                sps.Add(card2.GetGlobalId());
                            }
                            else
                            {
                                sps.Add(card3.GetGlobalId());
                            }
                        }
                    }
                }
                if (hero.PowerLevel > 5)
                {
                    CharacterData cd = DataTables.Get(DataType.Character).GetDataByGlobalId<CharacterData>(hero.CharacterId);
                    foreach (CardData cardData in DataTables.Get(DataType.Card).GetAll<CardData>())
                    {
                        if (cardData.Target == cd.Name)
                        {
                            if (cardData.MetaType == 4 && hero.PowerLevel >= 8 && !Avatar.UnlockedMeta.Contains(cardData.GetGlobalId()) && !sps.Contains(cardData.GetGlobalId()))
                            {
                                sps.Add(cardData.GetGlobalId());
                            }
                            else if (cardData.MetaType == 5 && hero.PowerLevel >= 6 && !Avatar.UnlockedMeta.Contains(cardData.GetGlobalId()) && !sps.Contains(cardData.GetGlobalId()))
                            {
                                sps.Add(cardData.GetGlobalId());
                            }
                        }
                    }
                }
            }
        }
        if (canDropSp && sps.Count > 0)
        {
            bool spdrop = false;
            while (ProcChance(rand, 11 * 3, "starpower", Avatar.ForcedDrops) && sps.Count > 0)
            {
                spdrop = true;
                int sp = sps[rand.Next(sps.Count)];
                GatchaDrop drop = new(4) { CardGlobalId = sp, Count = 1 };
                unit.AddDrop(drop);
                CardData card = DataTables.Get(DataType.Card).GetDataByGlobalId<CardData>(sp);
                CharacterData hero = DataTables.Get(DataType.Character).GetData<CharacterData>(card.Name.Split("_")[0]);
                Hero h = Avatar.GetHero(hero.GetGlobalId());
                h.HasStarpower = true;
                Avatar.ForcedDrops = CalcForcedDrop(true, "card_notchar", "starpower", Avatar.ForcedDrops, "mega");
                sps.Remove(sp);
            }
            if (sps.Count > 0 && !spdrop)
            {
                Avatar.ForcedDrops = CalcForcedDrop(false, "card_notchar", "starpower", Avatar.ForcedDrops, "mega");
            }
        }
        while (ProcChance(rand, 30, "bonus", Avatar.ForcedDrops) && possibleBonuses.Count > 0)
        {
            Avatar.ForcedDrops = CalcForcedDrop(true, "bonus", "bonus", Avatar.ForcedDrops, "mega");
            int bonusType = possibleBonuses[rand.Next(0, possibleBonuses.Count)];
            switch (bonusType)
            {
                case 1: GatchaDrop tokens = new(2) { Count = TokenDoublersReward[rand.Next(TokenDoublersReward.Count)] }; unit.AddDrop(tokens); break;
                case 2: GatchaDrop tickets = new(3) { Count = TicketsReward[rand.Next(TicketsReward.Count)] }; unit.AddDrop(tickets); break;
            }
            possibleBonuses.Remove(bonusType);
        }
        if (possibleBonuses.Count == 3)
        {
            Avatar.ForcedDrops = CalcForcedDrop(false, "bonus", "bonus", Avatar.ForcedDrops, "mega");
        }
    }
}

        public void Enter(DateTime dateTime)
        {
            Home.HomeVisited();
            Home.Tick();
        }

        public void ClientTurnReceived(int tick, int checksum, List<Command> commands)
        {
            Home.Tick();
        }
    }
}