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

    internal class BattleBanzai
    {
        private bool banzaiStarted;
        internal Hashtable banzaiTiles;
        private GameField field;
        private byte[,] floorMap;
        private QueuedDictionary<uint, RoomItem> pucks;
        private Room room;

        public BattleBanzai(Room room)
        {
            this.room = room;
            this.banzaiTiles = new Hashtable();
            this.banzaiStarted = false;
            this.pucks = new QueuedDictionary<uint, RoomItem>();
        }

        internal void AddPuck(RoomItem item)
        {
            if (!this.pucks.ContainsKey(item.Id))
            {
                this.pucks.Add(item.Id, item);
            }
        }

        internal void AddTile(RoomItem item, uint itemID)
        {
            if (!this.banzaiTiles.ContainsKey(itemID))
            {
                this.banzaiTiles.Add(itemID, item);
            }
        }

        internal void BanzaiEnd()
        {
            this.banzaiStarted = false;
            this.room.GetGameManager().StopGame();
            this.floorMap = null;
            Team team = this.room.GetGameManager().getWinningTeam();
            foreach (RoomItem item in this.banzaiTiles.Values)
            {
                if (item.team == team)
                {
                    item.interactionCount = 0;
                    item.interactionCountHelper = 0;
                    item.UpdateNeeded = true;
                }
                else if (item.team == Team.none)
                {
                    item.ExtraData = "0";
                    item.UpdateState();
                }
            }
            if (team != Team.none)
            {
                List<RoomUser> roomUsers = this.room.GetRoomUserManager().GetRoomUsers();
                List<ServerMessage> list2 = new List<ServerMessage>();
                foreach (RoomUser user in roomUsers)
                {
                    ServerMessage message;
                    switch (team)
                    {
                        case Team.blue:
                            if (user.CurrentEffect == 0x23)
                            {
                                message = new ServerMessage(Outgoing.Action);
                                message.AppendInt32(user.VirtualId);
                                message.AppendInt32(1);
                                list2.Add(message);
                            }
                            break;

                        case Team.red:
                            if (user.CurrentEffect == 0x21)
                            {
                                message = new ServerMessage(Outgoing.Action);
                                message.AppendInt32(user.VirtualId);
                                message.AppendInt32(1);
                                list2.Add(message);
                            }
                            break;

                        case Team.green:
                            if (user.CurrentEffect == 0x22)
                            {
                                message = new ServerMessage(Outgoing.Action);
                                message.AppendInt32(user.VirtualId);
                                message.AppendInt32(1);
                                list2.Add(message);
                            }
                            break;

                        default:
                            if ((team == Team.yellow) && (user.CurrentEffect == 0x24))
                            {
                                message = new ServerMessage(Outgoing.Action);
                                message.AppendInt32(user.VirtualId);
                                message.AppendInt32(1);
                                list2.Add(message);
                            }
                            break;
                    }
                }
                if (list2.Count > 0)
                {
                    foreach (ServerMessage message2 in list2)
                    {
                        this.room.SendMessage(message2);
                    }
                }
                this.field.destroy();
            }
        }

        internal void BanzaiStart()
        {
            if (!this.banzaiStarted)
            {
                this.room.GetGameManager().StartGame();
                this.floorMap = new byte[this.room.GetGameMap().Model.MapSizeY, this.room.GetGameMap().Model.MapSizeX];
                this.field = new GameField(this.floorMap, true);
                for (int i = 1; i < 5; i++)
                {
                    this.room.GetGameManager().Points[i] = 0;
                }
                foreach (RoomItem item in this.banzaiTiles.Values)
                {
                    item.ExtraData = "1";
                    item.value = 0;
                    item.team = Team.none;
                    item.UpdateState();
                }
                this.room.GetRoomItemHandler().mFloorItems.QueueDelegate(new onCycleDoneDelegate(this.ResetTiles));
                this.banzaiStarted = true;
            }
        }

        internal void Destroy()
        {
            this.banzaiTiles.Clear();
            this.pucks.Clear();
            Array.Clear(this.floorMap, 0, this.floorMap.Length);
            this.field.destroy();
            this.room = null;
            this.banzaiTiles = null;
            this.pucks = null;
            this.floorMap = null;
            this.field = null;
        }

        private void HandleBanzaiTiles(Point coord, Team team, RoomUser user)
        {
            if (team != Team.none)
            {
                List<RoomItem> coordinatedItems = this.room.GetGameMap().GetCoordinatedItems(coord);
                int num = 0;
                foreach (RoomItem item in this.banzaiTiles.Values)
                {
                    if (item.GetBaseItem().InteractionType == InteractionType.banzaifloor)
                    {
                        if (((item.ExtraData.Equals("5") || item.ExtraData.Equals("8")) || item.ExtraData.Equals("11")) || item.ExtraData.Equals("14"))
                        {
                            num++;
                        }
                        else if ((item.GetX == coord.X) && (item.GetY == coord.Y))
                        {
                            this.SetTile(item, team, user);
                            if (((item.ExtraData.Equals("5") || item.ExtraData.Equals("8")) || item.ExtraData.Equals("11")) || item.ExtraData.Equals("14"))
                            {
                                num++;
                            }
                            item.UpdateState(false, true);
                        }
                    }
                }
                if (num == this.banzaiTiles.Count)
                {
                    this.BanzaiEnd();
                }
            }
        }

        private void HandleMaxBanzaiTiles(Point coord, Team team, RoomUser user)
        {
            if (team != Team.none)
            {
                List<RoomItem> coordinatedItems = this.room.GetGameMap().GetCoordinatedItems(coord);
                foreach (RoomItem item in this.banzaiTiles.Values)
                {
                    if ((item.GetBaseItem().InteractionType == InteractionType.banzaifloor) && ((item.GetX == coord.X) && (item.GetY == coord.Y)))
                    {
                        SetMaxForTile(item, team);
                        this.room.GetGameManager().AddPointToTeam(team, user);
                        item.UpdateState(false, true);
                    }
                }
            }
        }

        internal void MovePuck(RoomItem item, GameClient mover, int newX, int newY, Team team)
        {
            if (this.room.GetGameMap().itemCanBePlacedHere(newX, newY))
            {
                Point coordinate = item.Coordinate;
                double k = this.room.GetGameMap().Model.SqFloorHeight[newX, newY];
                if ((coordinate.X != newX) || (coordinate.Y != newY))
                {
                    item.ExtraData = ((int) team).ToString();
                    item.UpdateNeeded = true;
                    item.UpdateState();
                    ServerMessage message = new ServerMessage();
                    message.Init(Outgoing.ObjectOnRoller);
                    message.AppendInt32(item.Coordinate.X);
                    message.AppendInt32(item.Coordinate.Y);
                    message.AppendInt32(newX);
                    message.AppendInt32(newY);
                    message.AppendInt32(1);
                    message.AppendInt32(item.Id);
                    message.AppendString(TextHandling.GetString(item.GetZ));
                    message.AppendString(TextHandling.GetString(k));
                    message.AppendInt32(1);
                    this.room.SendMessage(message);
                    this.room.GetRoomItemHandler().SetFloorItem(mover, item, newX, newY, item.Rot, false, false, false, false);
                    if ((mover != null) && (mover.GetHabbo() != null))
                    {
                        RoomUser roomUserByHabbo = mover.GetHabbo().CurrentRoom.GetRoomUserManager().GetRoomUserByHabbo(mover.GetHabbo().Id);
                        if (this.banzaiStarted)
                        {
                            this.HandleBanzaiTiles(new Point(newX, newY), team, roomUserByHabbo);
                        }
                    }
                }
            }
        }

        internal void MovePuck(RoomItem item, GameClient client, Point user, Point ball, int length, Team team)
        {
            int num = user.X - ball.X;
            int num2 = user.Y - ball.Y;
            if ((((num <= 1) && (num >= -1)) && (num2 <= 1)) && (num2 >= -1))
            {
                List<Point> list = new List<Point>();
                int x = ball.X;
                int y = ball.Y;
                for (int i = 1; i < length; i++)
                {
                    x = num * (0 - i);
                    y = num2 * (0 - i);
                    x += item.GetX;
                    y += item.GetY;
                    if (!this.room.GetGameMap().itemCanBePlacedHere(x, y))
                    {
                        if (i != 1)
                        {
                            if (i != length)
                            {
                                list.Add(new Point(x, y));
                            }
                            i--;
                            x = num * (0 - i);
                            y = num2 * (0 - i);
                            x += item.GetX;
                            y += item.GetY;
                        }
                        break;
                    }
                    if (i != length)
                    {
                        list.Add(new Point(x, y));
                    }
                }
                if ((client != null) && (client.GetHabbo() != null))
                {
                    RoomUser roomUserByHabbo = client.GetHabbo().CurrentRoom.GetRoomUserManager().GetRoomUserByHabbo(client.GetHabbo().Id);
                    foreach (Point point in list)
                    {
                        this.HandleBanzaiTiles(point, team, roomUserByHabbo);
                    }
                    if ((x != ball.X) || (y != ball.Y))
                    {
                        this.MovePuck(item, client, x, y, team);
                    }
                }
            }
        }

        internal void OnCycle()
        {
            this.pucks.OnCycle();
        }

        internal void OnUserWalk(RoomUser User)
        {
            if (User != null)
            {
                foreach (RoomItem item in this.pucks.Values)
                {
                    int num = User.X - item.GetX;
                    int num2 = User.Y - item.GetY;
                    if ((((num <= 1) && (num >= -1)) && (num2 <= 1)) && (num2 >= -1))
                    {
                        int x = num * -1;
                        int y = num2 * -1;
                        x += item.GetX;
                        y += item.GetY;
                        if ((item.interactingBallUser == User.userID) && this.room.GetGameMap().ValidTile(x, y))
                        {
                            item.interactingBallUser = 0;
                            this.MovePuck(item, User.GetClient(), User.Coordinate, item.Coordinate, 6, User.team);
                        }
                        else if (this.room.GetGameMap().ValidTile(x, y))
                        {
                            this.MovePuck(item, User.GetClient(), x, y, User.team);
                        }
                    }
                }
                if (this.banzaiStarted)
                {
                    this.HandleBanzaiTiles(User.Coordinate, User.team, User);
                }
            }
        }

        internal void RemovePuck(uint itemID)
        {
            this.pucks.Remove(itemID);
        }

        internal void RemoveTile(uint itemID)
        {
            this.banzaiTiles.Remove(itemID);
        }

        internal void ResetTiles()
        {
            foreach (RoomItem item in this.room.GetRoomItemHandler().mFloorItems.Values)
            {
                switch (item.GetBaseItem().InteractionType)
                {
                    case InteractionType.banzaiscoreblue:
                    case InteractionType.banzaiscorered:
                    case InteractionType.banzaiscoreyellow:
                    case InteractionType.banzaiscoregreen:
                        item.ExtraData = "0";
                        item.UpdateState();
                        break;
                }
            }
        }

        private static void SetMaxForTile(RoomItem item, Team team)
        {
            if (item.value < 3)
            {
                item.value = 3;
                item.team = team;
            }
            item.ExtraData = ((item.value + (7) - 1).ToString());
        }

        private void SetTile(RoomItem item, Team team, RoomUser user)
        {
            if (item.team == team)
            {
                if (item.value < 3)
                {
                    item.value++;
                    if (item.value == 3)
                    {
                        ButterflyEnvironment.GetGame().GetQuestManager().GetQuests().UpdateState("GAME_BB_LOCK_TILE", user.GetClient());
                        this.room.GetGameManager().AddPointToTeam(item.team, user);
                        this.field.updateLocation(item.GetX, item.GetY, (byte) team);
                        List<PointField> list = this.field.doUpdate(false);
                        foreach (PointField field in list)
                        {
                            Team forValue = (Team) field.forValue;
                            foreach (Point point in field.getPoints())
                            {
                                this.HandleMaxBanzaiTiles(new Point(point.X, point.Y), forValue, user);
                                this.floorMap[point.Y, point.X] = field.forValue;
                            }
                        }
                    }
                }
            }
            else if (item.value < 3)
            {
                item.team = team;
                item.value = 1;
            }
            item.ExtraData = ((item.value + (7)) - 1).ToString();
        }

        internal bool isBanzaiActive
        {
            get
            {
                return this.banzaiStarted;
            }
        }
    }
}