namespace Butterfly.HabboHotel.Rooms.Games
{
    using Butterfly;
    using Butterfly.HabboHotel.Items;
    using Butterfly.HabboHotel.Rooms;
    using Butterfly.Messages;
    using HabboEvents;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Linq;

    internal class Freeze
    {
        private RoomItem exitTeleport;
        private Hashtable freezeBlocks;
        private Hashtable freezeTiles;
        private bool gameStarted;
        private Random rnd;
        private Room room;

        public Freeze(Room room)
        {
            this.room = room;
            this.freezeTiles = new Hashtable();
            this.freezeBlocks = new Hashtable();
            this.exitTeleport = null;
            this.rnd = new Random();
            this.gameStarted = false;
        }

        private static void ActivateShield(RoomUser user)
        {
            user.ApplyEffect(((int) user.team) + 0x30);
            user.shieldActive = true;
            user.shieldCounter = 0;
        }

        internal void AddFreezeBlock(RoomItem item)
        {
            if (this.freezeBlocks.ContainsKey(item.Id))
            {
                this.freezeBlocks.Remove(item.Id);
            }
            this.freezeBlocks.Add(item.Id, item);
        }

        internal void AddFreezeTile(RoomItem item)
        {
            this.freezeTiles.Add(item.Id, item);
        }

        private void CountTeamPoints()
        {
            this.room.GetGameManager().Reset();
            foreach (RoomUser user in this.room.GetRoomUserManager().UserList.Values)
            {
                if ((!user.IsBot && (user.team != Team.none)) && (user.GetClient() != null))
                {
                    user.banzaiPowerUp = FreezePowerUp.None;
                    user.FreezeLives = 3;
                    user.shieldActive = false;
                    user.shieldCounter = 11;
                    this.room.GetGameManager().AddPointToTeam(user.team, 40, null);
                    ServerMessage message = new ServerMessage();
                    message.Init(Outgoing.UpdateFreezeLives);
                    message.AppendInt32(user.InternalRoomID);
                    message.AppendInt32(user.FreezeLives);
                    user.GetClient().SendMessage(message);
                }
            }
        }

        internal void CycleUser(RoomUser user)
        {
            if (user.Freezed)
            {
                user.FreezeCounter++;
                if (user.FreezeCounter > 10)
                {
                    user.Freezed = false;
                    user.FreezeCounter = 0;
                    ActivateShield(user);
                }
            }
            if (user.shieldActive)
            {
                user.shieldCounter++;
                if (user.shieldCounter > 10)
                {
                    user.shieldActive = false;
                    user.shieldCounter = 10;
                    user.ApplyEffect(((int) user.team) + 0x27);
                }
            }
        }

        internal void Destroy()
        {
            this.freezeBlocks.Clear();
            this.freezeTiles.Clear();
            this.room = null;
            this.freezeTiles = null;
            this.freezeBlocks = null;
            this.exitTeleport = null;
            this.rnd = null;
        }

        private static void ExitGame(RoomUser user)
        {
            user.team = Team.none;
        }

        private void FreezeUser(RoomUser user)
        {
            if ((!user.IsBot && !user.shieldActive) && (user.team != Team.none))
            {
                if (user.Freezed)
                {
                    user.Freezed = false;
                    user.ApplyEffect(((int) user.team) + 0x27);
                }
                else
                {
                    user.Freezed = true;
                    user.FreezeCounter = 0;
                    user.FreezeLives--;
                    if (user.FreezeLives <= 0)
                    {
                        ServerMessage message = new ServerMessage();
                        message.Init(Outgoing.UpdateFreezeLives);
                        message.AppendInt32(user.InternalRoomID);
                        message.AppendInt32(user.FreezeLives);
                        user.GetClient().SendMessage(message);
                        user.ApplyEffect(-1);
                        this.room.GetGameManager().AddPointToTeam(user.team, -20, user);
                        TeamManager teamManagerForFreeze = this.room.GetTeamManagerForFreeze();
                        teamManagerForFreeze.OnUserLeave(user);
                        user.team = Team.none;
                        if (this.exitTeleport != null)
                        {
                            this.room.GetGameMap().TeleportToItem(user, this.exitTeleport);
                        }
                        user.Freezed = false;
                        user.SetStep = false;
                        user.IsWalking = false;
                        user.UpdateNeeded = true;
                        if ((((teamManagerForFreeze.BlueTeam.Count <= 0) && (teamManagerForFreeze.RedTeam.Count <= 0)) && (teamManagerForFreeze.GreenTeam.Count <= 0)) && (teamManagerForFreeze.YellowTeam.Count > 0))
                        {
                            this.StopGame();
                        }
                        else if ((((teamManagerForFreeze.BlueTeam.Count > 0) && (teamManagerForFreeze.RedTeam.Count <= 0)) && (teamManagerForFreeze.GreenTeam.Count <= 0)) && (teamManagerForFreeze.YellowTeam.Count <= 0))
                        {
                            this.StopGame();
                        }
                        else if ((((teamManagerForFreeze.BlueTeam.Count <= 0) && (teamManagerForFreeze.RedTeam.Count > 0)) && (teamManagerForFreeze.GreenTeam.Count <= 0)) && (teamManagerForFreeze.YellowTeam.Count <= 0))
                        {
                            this.StopGame();
                        }
                        else if ((((teamManagerForFreeze.BlueTeam.Count <= 0) && (teamManagerForFreeze.RedTeam.Count <= 0)) && (teamManagerForFreeze.GreenTeam.Count > 0)) && (teamManagerForFreeze.YellowTeam.Count <= 0))
                        {
                            this.StopGame();
                        }
                    }
                    else
                    {
                        this.room.GetGameManager().AddPointToTeam(user.team, -10, user);
                        user.ApplyEffect(12);
                        ServerMessage message2 = new ServerMessage();
                        message2.Init(Outgoing.UpdateFreezeLives);
                        message2.AppendInt32(user.InternalRoomID);
                        message2.AppendInt32(user.FreezeLives);
                        user.GetClient().SendMessage(message2);
                    }
                }
            }
        }

        private List<RoomItem> GetDiagonalItems(int x, int y, int length)
        {
            int num;
            Point point;
            List<RoomItem> itemsForSquare;
            List<RoomItem> list = new List<RoomItem>();
            for (num = 0; num < length; num++)
            {
                point = new Point(x + num, y + num);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    break;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    break;
                }
            }
            for (num = 0; num < length; num++)
            {
                point = new Point(x - num, y - num);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    break;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    break;
                }
            }
            for (num = 0; num < length; num++)
            {
                point = new Point(x - num, y + num);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    break;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    break;
                }
            }
            for (num = 0; num < length; num++)
            {
                point = new Point(x + num, y - num);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    return list;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    return list;
                }
            }
            return list;
        }

        private RoomItem GetFirstTile(int x, int y)
        {
            foreach (RoomItem item in this.room.GetGameMap().GetCoordinatedItems(new Point(x, y)))
            {
                if (item.GetBaseItem().InteractionType == InteractionType.freezetile)
                {
                    return item;
                }
            }
            return null;
        }

        private List<RoomItem> GetItemsForSquare(Point point)
        {
            return this.room.GetGameMap().GetCoordinatedItems(point);
        }

        private List<RoomItem> GetVerticalItems(int x, int y, int length)
        {
            int num;
            Point point;
            List<RoomItem> itemsForSquare;
            List<RoomItem> list = new List<RoomItem>();
            for (num = 0; num < length; num++)
            {
                point = new Point(x + num, y);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    break;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    break;
                }
            }
            for (num = 1; num < length; num++)
            {
                point = new Point(x, y + num);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    break;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    break;
                }
            }
            for (num = 1; num < length; num++)
            {
                point = new Point(x - num, y);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    break;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    break;
                }
            }
            for (num = 1; num < length; num++)
            {
                point = new Point(x, y - num);
                itemsForSquare = this.GetItemsForSquare(point);
                if (!SquareGotFreezeTile(itemsForSquare))
                {
                    return list;
                }
                this.HandleUserFreeze(point);
                list.AddRange(itemsForSquare);
                if (SquareGotFreezeBlock(itemsForSquare))
                {
                    return list;
                }
            }
            return list;
        }

        private void HandleBanzaiFreezeItems(List<RoomItem> items)
        {
            foreach (RoomItem item in items)
            {
                switch (item.GetBaseItem().InteractionType)
                {
                    case InteractionType.freezetileblock:
                        this.SetRandomPowerUp(item);
                        item.UpdateState(false, true);
                        break;

                    case InteractionType.freezetile:
                        item.ExtraData = "11000";
                        item.UpdateState(false, true);
                        break;
                }
            }
        }

        private void HandleUserFreeze(Point point)
        {
            RoomUser user = this.room.GetGameMap().GetRoomUsers(point).FirstOrDefault<RoomUser>();
            if ((user != null) && ((!user.IsWalking || (user.SetX == point.X)) || (user.SetY == point.Y)))
            {
                this.FreezeUser(user);
            }
        }

        internal static void OnCycle()
        {
        }

        internal void onFreezeTiles(RoomItem item, FreezePowerUp powerUp, uint userID)
        {
            if (this.room.GetRoomUserManager().GetRoomUserByHabbo(userID) != null)
            {
                List<RoomItem> list;
                switch (powerUp)
                {
                    case FreezePowerUp.BlueArrow:
                        list = this.GetVerticalItems(item.GetX, item.GetY, 5);
                        break;

                    case FreezePowerUp.GreenArrow:
                        list = this.GetDiagonalItems(item.GetX, item.GetY, 5);
                        break;

                    case FreezePowerUp.OrangeSnowball:
                        list = this.GetVerticalItems(item.GetX, item.GetY, 5);
                        list.AddRange(this.GetDiagonalItems(item.GetX, item.GetY, 5));
                        break;

                    default:
                        list = this.GetVerticalItems(item.GetX, item.GetY, 3);
                        break;
                }
                this.HandleBanzaiFreezeItems(list);
            }
        }

        internal void OnUserWalk(RoomUser user)
        {
            if (this.gameStarted && (user.team != Team.none))
            {
                if (((user.X == user.GoalX) && (user.GoalY == user.Y)) && user.throwBallAtGoal)
                {
                    foreach (RoomItem item in this.freezeTiles.Values)
                    {
                        if ((item.interactionCountHelper == 0) && ((item.GetX == user.X) && (item.GetY == user.Y)))
                        {
                            ButterflyEnvironment.GetGame().GetQuestManager().GetQuests().UpdateState("GAME_FREEZE_THROW_BOMB", user.GetClient());
                            item.interactionCountHelper = 1;
                            item.ExtraData = "1000";
                            item.UpdateState();
                            item.InteractingUser = user.userID;
                            item.freezePowerUp = user.banzaiPowerUp;
                            item.ReqUpdate(4, true);
                            switch (user.banzaiPowerUp)
                            {
                                case FreezePowerUp.GreenArrow:
                                case FreezePowerUp.OrangeSnowball:
                                    user.banzaiPowerUp = FreezePowerUp.None;
                                    break;
                            }
                            break;
                        }
                    }
                }
                foreach (RoomItem item in this.freezeBlocks.Values)
                {
                    if (((user.X == item.GetX) && (user.Y == item.GetY)) && (item.freezePowerUp != FreezePowerUp.None))
                    {
                        this.PickUpPowerUp(item, user);
                    }
                }
            }
        }

        private void PickUpPowerUp(RoomItem item, RoomUser user)
        {
            switch (item.freezePowerUp)
            {
                case FreezePowerUp.BlueArrow:
                case FreezePowerUp.GreenArrow:
                case FreezePowerUp.OrangeSnowball:
                    user.banzaiPowerUp = item.freezePowerUp;
                    break;

                case FreezePowerUp.Shield:
                    ActivateShield(user);
                    break;

                case FreezePowerUp.Heart:
                {
                    if (user.FreezeLives < 3)
                    {
                        user.FreezeLives++;
                        this.room.GetGameManager().AddPointToTeam(user.team, 10, user);
                    }
                    ServerMessage message = new ServerMessage();
                    message.Init(Outgoing.UpdateFreezeLives);
                    message.AppendInt32(user.InternalRoomID);
                    message.AppendInt32(user.FreezeLives);
                    user.GetClient().SendMessage(message);
                    break;
                }
            }
            item.freezePowerUp = FreezePowerUp.None;
            item.ExtraData = "1" + item.ExtraData;
            item.UpdateState(false, true);
        }

        internal void RemoveFreezeBlock(uint itemID)
        {
            this.freezeBlocks.Remove(itemID);
        }

        internal void RemoveFreezeTile(uint itemID)
        {
            this.freezeTiles.Remove(itemID);
        }

        private static void RemoveUserFromTeam(RoomUser user)
        {
            user.team = Team.none;
            user.ApplyEffect(-1);
        }

        internal void ResetGame()
        {
            foreach (RoomItem item in this.freezeBlocks.Values)
            {
                if (!(((string.IsNullOrEmpty(item.ExtraData) || item.GetBaseItem().InteractionType.Equals(InteractionType.freezebluegate)) || (item.GetBaseItem().InteractionType.Equals(InteractionType.freezeredgate) || item.GetBaseItem().InteractionType.Equals(InteractionType.freezegreengate))) || item.GetBaseItem().InteractionType.Equals(InteractionType.freezeyellowgate)))
                {
                    item.ExtraData = "";
                    item.UpdateState(false, true);
                    this.room.GetGameMap().AddItemToMap(item, false);
                }
            }
        }

        private void SetRandomPowerUp(RoomItem item)
        {
            if (string.IsNullOrEmpty(item.ExtraData))
            {
                switch (this.rnd.Next(1, 14))
                {
                    case 2:
                        item.ExtraData = "2000";
                        item.freezePowerUp = FreezePowerUp.BlueArrow;
                        break;

                    case 3:
                        item.ExtraData = "3000";
                        item.freezePowerUp = FreezePowerUp.Snowballs;
                        break;

                    case 4:
                        item.ExtraData = "4000";
                        item.freezePowerUp = FreezePowerUp.GreenArrow;
                        break;

                    case 5:
                        item.ExtraData = "5000";
                        item.freezePowerUp = FreezePowerUp.OrangeSnowball;
                        break;

                    case 6:
                        item.ExtraData = "6000";
                        item.freezePowerUp = FreezePowerUp.Heart;
                        break;

                    case 7:
                        item.ExtraData = "7000";
                        item.freezePowerUp = FreezePowerUp.Shield;
                        break;

                    default:
                        item.ExtraData = "1000";
                        item.freezePowerUp = FreezePowerUp.None;
                        break;
                }
                this.room.GetGameMap().RemoveFromMap(item, false);
                item.UpdateState(false, true);
            }
        }

        private static bool SquareGotFreezeBlock(List<RoomItem> items)
        {
            foreach (RoomItem item in items)
            {
                if (item.GetBaseItem().InteractionType == InteractionType.freezetileblock)
                {
                    return true;
                }
            }
            return false;
        }

        private static bool SquareGotFreezeTile(List<RoomItem> items)
        {
            foreach (RoomItem item in items)
            {
                if (item.GetBaseItem().InteractionType == InteractionType.freezetile)
                {
                    return true;
                }
            }
            return false;
        }

        internal void StartGame()
        {
            this.gameStarted = true;
            this.CountTeamPoints();
            this.ResetGame();
            this.room.GetGameManager().LockGates();
            this.room.GetGameManager().StartGame();
        }

        internal void StopGame()
        {
            this.gameStarted = false;
            this.room.GetGameManager().UnlockGates();
            this.room.GetGameManager().StopGame();
            Team team = this.room.GetGameManager().getWinningTeam();
            foreach (RoomUser user in this.room.GetRoomUserManager().UserList.Values)
            {
                user.FreezeLives = 0;
                if (user.team == team)
                {
                    user.Unidle();
                    user.DanceId = 0;
                    ServerMessage message = new ServerMessage(Outgoing.Action);
                    message.AppendInt32(user.VirtualId);
                    message.AppendInt32(1);
                    this.room.SendMessage(message);
                }
            }
        }

        internal RoomItem ExitTeleport
        {
            get
            {
                return this.exitTeleport;
            }
            set
            {
                this.exitTeleport = value;
            }
        }

        internal bool GameIsStarted
        {
            get
            {
                return this.gameStarted;
            }
        }
    }
}