namespace Holo.Virtual.Rooms.Games
{
    using Holo;
    using Holo.Managers;
    using Holo.Virtual.Rooms;
    using Holo.Virtual.Users;
    using System;
    using System.Collections;
    using System.Text;

    internal class gameLobby
    {
        private int[] allowedPowerups;
        internal Hashtable Games = new Hashtable();
        internal bool isBattleBall = true;
        internal rankManager.gameRank Rank;
        internal virtualRoom Room;

        internal gameLobby(virtualRoom Room, bool isBattleBall, string rankTitle)
        {
            this.Room = Room;
            this.Rank = rankManager.getGameRank(isBattleBall, rankTitle);
            this.isBattleBall = isBattleBall;
            if (isBattleBall)
            {
                string[] strArray = DB.runReadUnsafe("SELECT bb_allowedpowerups FROM games_lobbies WHERE id = '" + Room.roomID + "'").Split(new char[] { ',' });
                this.allowedPowerups = new int[strArray.Length];
                for (int i = 0; i < strArray.Length; i++)
                {
                    this.allowedPowerups[i] = int.Parse(strArray[i]);
                }
            }
        }

        internal bool allowsPowerup(int ID)
        {
            try
            {
                for (int i = 0; i < this.allowedPowerups.Length; i++)
                {
                    if (this.allowedPowerups[i] == ID)
                    {
                        return true;
                    }
                }
                return false;
            }
            catch
            {
                return false;
            }
        }

        internal void Clear()
        {
            this.Games.Clear();
            this.Games = null;
            this.Room = null;
        }

        internal void createGame(gamePlayer Owner, string Name, int mapID, int teamAmount, int[] enabledPowerups)
        {
            int key = 0;
            while (this.Games.ContainsKey(key))
            {
                key++;
            }
            Owner.Game = new Game(this, key, Name, mapID, teamAmount, enabledPowerups, Owner);
            Owner.Game.movePlayer(Owner, -1, 0);
            this.Games.Add(key, Owner.Game);
        }

        internal string gameList()
        {
            try
            {
                int[] numArray = new int[3];
                StringBuilder builder = new StringBuilder();
                foreach (Game game in this.Games.Values)
                {
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(game.ID), game.Name, Convert.ToChar(2), Holo.Encoding.encodeVL64(game.Owner.roomUID), game.Owner.User._Username, Convert.ToChar(2) }));
                    if (!this.isBattleBall)
                    {
                        builder.Append(Holo.Encoding.encodeVL64(game.leftTime));
                    }
                    builder.Append(Holo.Encoding.encodeVL64(game.mapID));
                    numArray[(int) game.State]++;
                }
                if ((numArray[1] > 0) || (numArray[2] > 0))
                {
                    return (Holo.Encoding.encodeVL64(numArray[0]) + Holo.Encoding.encodeVL64(numArray[1]) + Holo.Encoding.encodeVL64(numArray[2]) + builder.ToString());
                }
                return (Holo.Encoding.encodeVL64(numArray[0]) + builder.ToString());
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.Message);
                return "";
            }
        }

        internal string getCreateGameSettings()
        {
            if (this.isBattleBall)
            {
                StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(4));
                builder.Append(string.Concat(new object[] { "fieldType", Convert.ToChar(2), "HJIII", Holo.Encoding.encodeVL64(5) }));
                builder.Append(string.Concat(new object[] { "numTeams", Convert.ToChar(2), "HJJIJI", Holo.Encoding.encodeVL64(4) }));
                builder.Append("allowedPowerups" + Convert.ToChar(2) + "IJ");
                int length = this.allowedPowerups.Length;
                if (length == 0)
                {
                    builder.Append("9");
                }
                else
                {
                    for (int i = 0; i < length; i++)
                    {
                        if (i == (length - 1))
                        {
                            builder.Append(this.allowedPowerups[i]);
                        }
                        else
                        {
                            builder.Append(this.allowedPowerups[i] + ",");
                        }
                    }
                }
                builder.Append(Convert.ToChar(2) + "H");
                builder.Append(string.Concat(new object[] { "name", Convert.ToChar(2), "IJ", Convert.ToChar(2), "H" }));
                return builder.ToString();
            }
            return "#";
        }

        internal bool validGamerank(int Points)
        {
            return ((Points >= this.Rank.minPoints) && ((this.Rank.maxPoints == 0) || (Points <= this.Rank.maxPoints)));
        }

        internal string playerRanks
        {
            get
            {
                ICollection users = this.Room.Users;
                StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(users.Count));
                foreach (virtualRoomUser user in users)
                {
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(user.roomUID), user.gamePoints, Convert.ToChar(2), rankManager.getGameRankTitle(this.isBattleBall, user.gamePoints), Convert.ToChar(2) }));
                }
                return builder.ToString();
            }
        }

        internal string Type
        {
            get
            {
                if (this.isBattleBall)
                {
                    return "bb";
                }
                return "ss";
            }
        }
    }
}