using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using prjMango.Game.Rooms;
using prjMango.Game.Items;
using prjMango.Utilities;
using prjMango.Storage.MySql;
using prjMango.Game.Navigators;
using prjMango.Game.Pathfinding;
using prjMango.Game.Users.Badges;
using prjMango.Game.Sessions;

namespace prjMango.Messages
{
    partial class MessageHandler
    {
        private void GetAdvertisement()
        {
            GetResponse().Init(258);
            GetResponse().AppendStringWithBreak("");
            GetResponse().AppendStringWithBreak("");
            SendResponse();
        }

        private void GetPub()
        {
            int Id = Request.PopWiredInt32();

            RoomData Data = MangoServer.GetGame().GetRoomManager().GenerateRoomData(Id);

            if (Data == null || Data.Type != "public")
            {
                return;
            }

            GetResponse().Init(453);
            GetResponse().AppendInt32(Data.Id);
            GetResponse().AppendStringWithBreak(Data.CCTs);
            GetResponse().AppendInt32(Data.Id);
            SendResponse();
        }

        private void OpenFlat()
        {
            int Id = Request.PopWiredInt32();
            string Password = Request.PopFixedString();
            int Junk = Request.PopWiredInt32();

            RoomData Data = MangoServer.GetGame().GetRoomManager().GenerateRoomData(Id);

            if (Data == null || Data.Type != "private")
            {
                return;
            }

            PrepareRoomForUser(Id, Password);
        }

        private void OpenPub()
        {
            int Junk = Request.PopWiredInt32();
            int Id = Request.PopWiredInt32();
            int Junk2 = Request.PopWiredInt32();

            RoomData Data = MangoServer.GetGame().GetRoomManager().GenerateRoomData(Id);

            if (Data == null || Data.Type != "public")
            {
                return;
            }

            PrepareRoomForUser(Data.Id, "");
        }

        private void GetGroupBadges()
        {
            /*GetResponse().Init(309);
            GetResponse().AppendStringWithBreak("IcIrDs43103s19014d5a1dc291574a508bc80a64663e61a00");
            SendResponse();*/
        }

        private void GetRoomData1()
        {
            GetResponse().Init(297);
            GetResponse().AppendInt32(0);
            SendResponse();
        }

        private void GetRoomData2()
        {
            if (Session.GetPlayer().LoadingRoom == null)
            {
                return;
            }

            RoomData Data = new RoomData();
            Data.Fill(Session.GetPlayer().LoadingRoom);

            if (Data == null)
            {
                return;
            }

            if (Data.Model == null)
            {
                Session.SendNotif("Sorry, model data is missing from this room and therefore cannot be loaded.");
                Session.SendMessage(new ServerMessage(18));
                ClearRoomLoading();
                return;
            }

            Session.SendMessage(Data.Model.SerializeHeightmap());
            Session.SendMessage(Data.Model.SerializeRelativeHeightmap());
        }

        private void GetRoomData3()
        {
            if (Session.GetPlayer().LoadingRoom == null || !Session.GetPlayer().LoadingChecksPassed)
            {
                return;
            }

            Room Room = Session.GetPlayer().LoadingRoom;

            if (Room == null)
            {
                return;
            }

            ClearRoomLoading();

            GetResponse().Init(30);

            if (Room.Model.StaticFurniMap != "")
            {
                GetResponse().AppendStringWithBreak(Room.Model.StaticFurniMap);
            }
            else
            {
                GetResponse().AppendInt32(0);
            }

            SendResponse();

            if (Room.Type == "private")
            {
                List<RoomItem> FloorItems = Room.FloorItems;
                List<RoomItem> WallItems = Room.WallItems;

                GetResponse().Init(32);
                GetResponse().AppendInt32(FloorItems.Count);

                foreach (RoomItem Item in FloorItems)
                {
                    Item.Serialize(GetResponse());
                }

                SendResponse();

                GetResponse().Init(45);
                GetResponse().AppendInt32(WallItems.Count);

                foreach (RoomItem Item in WallItems)
                {
                    Item.Serialize(GetResponse());
                }

                SendResponse();
            }

            Room.AddUserToRoom(Session, Session.GetPlayer().SpectatorMode);

            List<RoomUser> UsersToDisplay = new List<RoomUser>();

                foreach (RoomUser User in Room.GetUsers)
                {
                    if (User.IsSpectator)
                    {
                        continue;
                    }

                    UsersToDisplay.Add(User);
                }

            GetResponse().Init(28);
            GetResponse().AppendInt32(UsersToDisplay.Count);

            foreach (RoomUser User in UsersToDisplay)
            {
                User.Serialize(GetResponse());
            }

            SendResponse();

            if (Room.Type == "public")
            {
                GetResponse().Init(471);
                GetResponse().AppendBoolean(false);
                GetResponse().AppendStringWithBreak(Room.ModelName);
                GetResponse().AppendBoolean(false);
                SendResponse();
            }
            else if (Room.Type == "private")
            {
                GetResponse().Init(471);
                GetResponse().AppendBoolean(true);
                GetResponse().AppendInt32(Room.RoomId);

                if (Room.CheckRights(Session, true))
                {
                    GetResponse().AppendBoolean(true);
                }
                else
                {
                    GetResponse().AppendBoolean(false);
                }

                SendResponse();

                // GQhntX]uberEmu PacketloggingDescriptionHQMSCQFJtag1tag2Ika^SMqurbIHH


                GetResponse().Init(454);
                GetResponse().AppendInt32(1);
                GetResponse().AppendInt32(Room.RoomId);
                GetResponse().AppendInt32(0);
                GetResponse().AppendStringWithBreak(Room.Name);
                GetResponse().AppendStringWithBreak(Room.Owner);
                GetResponse().AppendInt32(Room.State);
                GetResponse().AppendInt32(0);
                GetResponse().AppendInt32(25);
                GetResponse().AppendStringWithBreak(Room.Description);
                GetResponse().AppendInt32(0);
                GetResponse().AppendInt32(1);
                GetResponse().AppendInt32(8228);
                GetResponse().AppendInt32(Room.Category);
                GetResponse().AppendStringWithBreak("");
                GetResponse().AppendInt32(Room.TagCount);

                foreach (string Tag in Room.Tags) // TODO: Review tags and possibility thread-safe?
                {
                    GetResponse().AppendStringWithBreak(Tag);
                }

                Room.Icon.Serialize(GetResponse());
                GetResponse().AppendBoolean(false);
                SendResponse();
            }

            ServerMessage Updates = Room.SerializeStatusUpdates(true);

            if (Updates != null)
            {
                Session.SendMessage(Updates);
            }

            foreach (RoomUser User in Room.GetUsers)
            {
                if (User.IsSpectator)
                {
                    continue;
                }

                if (User.IsDancing)
                {
                    GetResponse().Init(480);
                    GetResponse().AppendInt32(User.VirtualId);
                    GetResponse().AppendInt32(User.DanceId);
                    SendResponse();
                }

                if (User.IsAsleep)
                {
                    GetResponse().Init(486);
                    GetResponse().AppendInt32(User.VirtualId);
                    GetResponse().AppendBoolean(true);
                    SendResponse();
                }

                if (User.CarryItemID > 0 && User.CarryTimer > 0)
                {
                    GetResponse().Init(482);
                    GetResponse().AppendInt32(User.VirtualId);
                    GetResponse().AppendInt32(User.CarryTimer);
                    SendResponse();
                }

                if (!User.IsBot)
                {
                    if (User.GetSession().GetPlayer() != null && User.GetSession().GetPlayer().GetEffectsComponent() != null && User.GetSession().GetPlayer().GetEffectsComponent().CurrentEffect >= 1)
                    {
                        GetResponse().Init(485);
                        GetResponse().AppendInt32(User.VirtualId);
                        GetResponse().AppendInt32(User.GetSession().GetPlayer().GetEffectsComponent().CurrentEffect);
                        SendResponse();
                    }
                }
            }
        }

        public void PrepareRoomForUser(int Id, string Password)
        {
            ClearRoomLoading();

            if (Session.GetPlayer().InRoom)
            {
                Room OldRoom = MangoServer.GetGame().GetRoomManager().GetRoom(Session.GetPlayer().CurrentRoomId);

                if (OldRoom != null)
                {
                    OldRoom.RemoveUserFromRoom(Session, false, false);
                }
            }

            if (MangoServer.GetGame().GetRoomManager().IsRoomLoaded(Id))
            {
                MangoServer.GetGame().GetRoomManager().LoadRoom(Id);
            }

            Room Room = MangoServer.GetGame().GetRoomManager().GetRoom(Id);

            if (Room == null)
            {
                return;
            }

            Session.GetPlayer().LoadingRoom = Room;

            if (Room.UserIsBanned(Session.GetPlayer().Id))
            {
                if (Room.HasBanExpired(Session.GetPlayer().Id))
                {
                    Room.RemoveBan(Session.GetPlayer().Id);
                }
                else
                {
                    // C`PA

                    GetResponse().Init(224);
                    GetResponse().AppendInt32(4);
                    SendResponse();

                    GetResponse().Init(18);
                    SendResponse();

                    return;
                }
            }

            if (Room.UsersNow >= Room.UsersMax) // TODO: Admin ranks to allow access when room is full
            {
                GetResponse().Init(224);
                GetResponse().AppendInt32(1);
                SendResponse();

                GetResponse().Init(18);
                SendResponse();

                return;
            }

            if (Room.Type == "public")
            {
                if (Room.State > 0) // TODO: Admin ranks to allow access
                {
                    Session.SendNotif("This public room is accessible to staff only.");

                    GetResponse().Init(18);
                    SendResponse();

                    return;
                }

                GetResponse().Init(166);
                GetResponse().AppendStringWithBreak("/client/public/" + Room.ModelName + "/0");
                SendResponse();
            }
            else if (Room.Type == "private")
            {
                GetResponse().Init(19);
                SendResponse();

                if (!Room.CheckRights(Session, true) && !Session.GetPlayer().IsTeleporting) // TODO: Admin ranks to allow access
                {
                    if (Room.State == 1)
                    {
                        if (Room.UserCount == 0)
                        {
                            GetResponse().Init(131);
                            SendResponse();
                        }
                        else
                        {
                            GetResponse().Init(91);
                            GetResponse().AppendStringWithBreak("");
                            SendResponse();

                            ServerMessage RingMessage = new ServerMessage(91);
                            RingMessage.AppendStringWithBreak(Session.GetPlayer().Username);
                            Room.SendMessageToUsersWithRights(RingMessage);
                        }

                        return;
                    }
                    else if (Room.State == 2)
                    {
                        if (Password.ToLower() != Room.Password.ToLower())
                        {
                            GetResponse().Init(33);
                            GetResponse().AppendInt32(-100002);
                            SendResponse();

                            GetResponse().Init(18);
                            SendResponse();

                            return;
                        }
                    }
                }

                GetResponse().Init(166);
                GetResponse().AppendStringWithBreak("/client/private/" + Room.RoomId + "/id");
                SendResponse();
            }

            Session.GetPlayer().LoadingChecksPassed = true;

            LoadRoomForUser();
        }

        private void ReqLoadRoomForUser()
        {
            LoadRoomForUser();
        }

        public void LoadRoomForUser()
        {
            Room Room = Session.GetPlayer().LoadingRoom;

            if (Room == null || !Session.GetPlayer().LoadingChecksPassed)
            {
                return;
            }

            // todo: Room.SerializeGroupBadges()
            /*GetResponse().Init(309);
            GetResponse().AppendStringWithBreak("IcIrDs43103s19014d5a1dc291574a508bc80a64663e61a00"); // GROUP BADGES!
            SendResponse();*/

            GetResponse().Init(69);
            GetResponse().AppendStringWithBreak(Room.ModelName);
            GetResponse().AppendInt32(Room.RoomId);
            SendResponse();

            if (Session.GetPlayer().SpectatorMode)
            {
                GetResponse().Init(254);
                SendResponse();
            }

            if (Room.Type == "private")
            {
                if (Room.Wallpaper != "0.0")
                {
                    GetResponse().Init(46);
                    GetResponse().AppendStringWithBreak("wallpaper");
                    GetResponse().AppendStringWithBreak(Room.Wallpaper);
                    SendResponse();
                }

                if (Room.Floor != "0.0")
                {
                    GetResponse().Init(46);
                    GetResponse().AppendStringWithBreak("floor");
                    GetResponse().AppendStringWithBreak(Room.Floor);
                    SendResponse();
                }

                GetResponse().Init(46);
                GetResponse().AppendStringWithBreak("landscape");
                GetResponse().AppendStringWithBreak(Room.Landscape);
                SendResponse();

                if (Room.CheckRights(Session, true))
                {
                    GetResponse().Init(42);
                    SendResponse();

                    GetResponse().Init(47);
                    SendResponse();
                }
                else if (Room.CheckRights(Session))
                {
                    GetResponse().Init(42);
                    SendResponse();
                }

                GetResponse().Init(345);

                if (Session.GetPlayer().RatedRooms.Contains(Room.RoomId) || Room.CheckRights(Session, true))
                {
                    GetResponse().AppendInt32(Room.Score);
                }
                else
                {
                    GetResponse().AppendInt32(-1);
                }

                SendResponse();

                if (Room.HasOngoingEvent)
                {
                    Session.SendMessage(Room.Event.Serialize(Session));
                }
                else
                {
                    GetResponse().Init(370);
                    GetResponse().AppendStringWithBreak("-1");
                    SendResponse();
                }
            }
        }

        public void ClearRoomLoading()
        {
            Session.GetPlayer().LoadingRoom = null;
            Session.GetPlayer().LoadingChecksPassed = false;
        }

        private void Talk()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            User.Chat(Session, Filtering.FilterInjectionChars(Request.PopFixedString()), false);
        }

        private void Shout()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            User.Chat(Session, Filtering.FilterInjectionChars(Request.PopFixedString()), true);
        }

        private void Whisper()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            if (Session.GetPlayer().Muted)
            {
                Session.SendNotif("You are muted.");
                return;
            }

            string Params = Filtering.FilterInjectionChars(Request.PopFixedString());
            string ToUser = Params.Split(' ')[0];
            string Message = Params.Substring(ToUser.Length + 1);

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);
            RoomUser User2 = Room.GetRoomUserByPlayer(ToUser);

            ServerMessage TellMsg = new ServerMessage();
            TellMsg.Init(25);
            TellMsg.AppendInt32(User.VirtualId);
            TellMsg.AppendStringWithBreak(Message);
            TellMsg.AppendBoolean(false);

            if (User != null && !User.IsBot)
            {
                User.GetSession().SendMessage(TellMsg);
            }

            User.Unidle();

            if (User2 != null && !User2.IsBot)
            {
                if (!User2.GetSession().GetPlayer().MutedUsers.Contains(Session.GetPlayer().Id))
                {
                    User2.GetSession().SendMessage(TellMsg);
                }

                // TODO: WHISPER CHAT LOGS
            }
        }

        private void Move()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null || !User.CanWalk)
            {
                return;
            }

            int MoveX = Request.PopWiredInt32();
            int MoveY = Request.PopWiredInt32();

            if (MoveX == User.X && MoveY == User.Y)
            {
                return;
            }

            User.MoveTo(MoveX, MoveY);
        }

        private void CanCreateRoom()
        {
            GetResponse().Init(512);
            GetResponse().AppendBoolean(false); // true = show error with number below
            GetResponse().AppendInt32(99999);
            SendResponse();

            // todo: room limit
        }

        private void CreateRoom()
        {
            string RoomName = Filtering.FilterInjectionChars(Request.PopFixedString());
            string ModelName = Request.PopFixedString();
            string RoomState = Request.PopFixedString(); // unused, room open by default on creation. may be added in later build of Habbo?

            RoomData NewRoom = MangoServer.GetGame().GetRoomManager().CreateRoom(Session, RoomName, ModelName);

            if (NewRoom != null)
            {
                GetResponse().Init(59);
                GetResponse().AppendInt32(NewRoom.Id);
                GetResponse().AppendStringWithBreak(NewRoom.Name);
                SendResponse();
            }
        }

        private void GetRoomEditData()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            GetResponse().Init(465);
            GetResponse().AppendInt32(Room.RoomId);
            GetResponse().AppendStringWithBreak(Room.Name);
            GetResponse().AppendStringWithBreak(Room.Description);
            GetResponse().AppendInt32(Room.State);
            GetResponse().AppendInt32(Room.Category);
            GetResponse().AppendInt32(Room.UsersMax);
            GetResponse().AppendInt32(25);
            GetResponse().AppendInt32(Room.TagCount);

            foreach (string Tag in Room.Tags)
            {
                GetResponse().AppendStringWithBreak(Tag);
            }

            GetResponse().AppendInt32(Room.UsersWithRights.Count); // users /w rights count

            foreach (int UserId in Room.UsersWithRights)
            {
                GetResponse().AppendInt32(UserId);
                GetResponse().AppendStringWithBreak(MangoServer.GetGame().GetSessionManager().GetNameById(UserId));
            }

            GetResponse().AppendInt32(Room.UsersWithRights.Count); // users /w rights count

            GetResponse().AppendBoolean(Room.AllowPets); // allows pets in room - pet system lacking, so always off
            GetResponse().AppendBoolean(Room.AllowPetsEating); // allows pets to eat your food - pet system lacking, so always off
            GetResponse().AppendBoolean(Room.AllowWalkthrough);
            SendResponse();
        }

        private void SaveRoomIcon()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            int Junk = Request.PopWiredInt32(); // always 3

            Dictionary<int, int> Items = new Dictionary<int, int>();

            int Background = Request.PopWiredInt32();
            int TopLayer = Request.PopWiredInt32();
            int AmountOfItems = Request.PopWiredInt32();

            for (int i = 0; i < AmountOfItems; i++)
            {
                int Pos = Request.PopWiredInt32();
                int Item = Request.PopWiredInt32();

                if (Pos < 0 || Pos > 10)
                {
                    return;
                }

                if (Item < 1 || Item > 27)
                {
                    return;
                }

                if (Items.ContainsKey(Pos))
                {
                    return;
                }

                Items.Add(Pos, Item);
            }

            if (Background < 1 || Background > 24)
            {
                return;
            }

            if (TopLayer < 0 || TopLayer > 11)
            {
                return;
            }

            StringBuilder FormattedItems = new StringBuilder();
            int j = 0;

            foreach (KeyValuePair<int, int> Item in Items)
            {
                if (j > 0)
                {
                    FormattedItems.Append("|");
                }

                FormattedItems.Append(Item.Key + "," + Item.Value);

                j++;
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("UPDATE rooms SET icon_bg = '" + Background + "', icon_fg = '" + TopLayer + "', icon_items = '" + FormattedItems.ToString() + "' WHERE id = '" + Room.RoomId + "' LIMIT 1");
            }

            Room.Icon = new RoomIcon(Background, TopLayer, Items);

            GetResponse().Init(457);
            GetResponse().AppendInt32(Room.RoomId);
            GetResponse().AppendBoolean(true);
            SendResponse();

            GetResponse().Init(456);
            GetResponse().AppendInt32(Room.RoomId);
            SendResponse();

            RoomData Data = new RoomData();
            Data.Fill(Room);

            GetResponse().Init(454);
            GetResponse().AppendBoolean(false);
            Data.Serialize(GetResponse(), false);
            SendResponse();
        }

        private void SaveRoomData()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            int Id = Request.PopWiredInt32();
            string Name = Filtering.FilterInjectionChars(Request.PopFixedString());
            string Description = Filtering.FilterInjectionChars(Request.PopFixedString());
            int State = Request.PopWiredInt32();
            string Password = Filtering.FilterInjectionChars(Request.PopFixedString());
            int MaxUsers = Request.PopWiredInt32();
            int CategoryId = Request.PopWiredInt32();
            int TagCount = Request.PopWiredInt32();

            List<string> Tags = new List<string>();
            StringBuilder formattedTags = new StringBuilder();

            for (int i = 0; i < TagCount; i++)
            {
                if (i > 0)
                {
                    formattedTags.Append(",");
                }

                string tag = Filtering.FilterInjectionChars(Request.PopFixedString().ToLower());

                Tags.Add(tag);
                formattedTags.Append(tag);
            }

            int AllowPets = 0;
            int AllowPetsEat = 0;
            int AllowWalkthrough = 0;

            string _AllowPets = Request.PlainReadBytes(1)[0].ToString();
            Request.AdvanceCursor(1);

            string _AllowPetsEat = Request.PlainReadBytes(1)[0].ToString();
            Request.AdvanceCursor(1);

            string _AllowWalkthrough = Request.PlainReadBytes(1)[0].ToString();
            Request.AdvanceCursor(1);

            if (Name.Length < 1)
            {
                return;
            }

            if (State < 0 || State > 2)
            {
                return;
            }

            if (MaxUsers != 10 && MaxUsers != 15 && MaxUsers != 20 && MaxUsers != 25)
            {
                return;
            }

            FlatCat FlatCat = MangoServer.GetGame().GetNavigator().GetFlatCat(CategoryId);

            if (FlatCat == null)
            {
                return;
            }

            if (FlatCat.MinRank > Session.GetPlayer().Rank)
            {
                Session.SendNotif("You are not allowed to use this category. Your room has been moved to no category instead.");
                CategoryId = 0;
            }

            if (TagCount > 2)
            {
                return;
            }

            if (State < 0 || State > 2)
            {
                return;
            }

            if (_AllowPets == "65")
            {
                AllowPets = 1;
                Room.AllowPets = true;
            }
            else
            {
                Room.AllowPets = false;
            }

            if (_AllowPetsEat == "65")
            {
                AllowPetsEat = 1;
                Room.AllowPetsEating = true;
            }
            else
            {
                Room.AllowPetsEating = false;
            }

            if (_AllowWalkthrough == "65")
            {
                AllowWalkthrough = 1;
                Room.AllowWalkthrough = true;
            }
            else
            {
                Room.AllowWalkthrough = false;
            }

            Room.Name = Name;
            Room.State = State;
            Room.Description = Description;
            Room.Category = CategoryId;
            Room.Password = Password;
            Room.Tags = Tags;
            Room.UsersMax = MaxUsers;

            string formattedState = "open";

            if (Room.State == 1)
            {
                formattedState = "locked";
            }
            else if (Room.State > 1)
            {
                formattedState = "password";
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.AddParamWithValue("caption", Room.Name);
                SqlClient.AddParamWithValue("description", Room.Description);
                SqlClient.AddParamWithValue("password", Room.Password);
                SqlClient.AddParamWithValue("tags", formattedTags.ToString());
                SqlClient.RunQuery("UPDATE rooms SET caption = @caption, description = @description, password = @password, category = '" + CategoryId + "', state = '" + formattedState + "', tags = @tags, users_max = '" + MaxUsers + "', allow_pets = '" + AllowPets + "', allow_pets_eat = '" + AllowPetsEat + "', allow_walkthrough = '" + AllowWalkthrough + "' WHERE id = '" + Room.RoomId + "' LIMIT 1");
            }

            GetResponse().Init(467);
            GetResponse().AppendInt32(Room.RoomId);
            SendResponse();

            GetResponse().Init(456);
            GetResponse().AppendInt32(Room.RoomId);
            SendResponse();

            RoomData Data = new RoomData();
            Data.Fill(Room);

            GetResponse().Init(454);
            GetResponse().AppendBoolean(false);
            Data.Serialize(GetResponse(), false);
            SendResponse();
        }

        private void GiveRights()
        {
            int UserId = Request.PopWiredInt32();

            Room Room = Session.GetPlayer().GetRoom();
            RoomUser RoomUser = Room.GetRoomUserByPlayer(UserId);

            if (Room == null || !Room.CheckRights(Session, true) || RoomUser == null || RoomUser.IsBot)
            {
                return;
            }

            if (Room.UsersWithRights.Contains(UserId))
            {
                // todo: fix silly bug
                Session.SendNotif("User already has rights! (There appears to be a bug with the rights button, we are looking into it - for now rely on 'Advanced settings')");
                return;
            }

            Room.UsersWithRights.Add(UserId);

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("INSERT INTO rooms_rights (room_id,user_id) VALUES ('" + Room.RoomId + "','" + UserId + "')");
            }

            GetResponse().Init(510);
            GetResponse().AppendInt32(Room.RoomId);
            GetResponse().AppendInt32(UserId);
            GetResponse().AppendStringWithBreak(RoomUser.GetSession().GetPlayer().Username);
            SendResponse();

            RoomUser.AddStatus("flatcrtl", "");
            RoomUser.UpdateNeeded = true;

            RoomUser.GetSession().SendMessage(new ServerMessage(42));

            // G~hntX]h_u@UMeth0d9

        }

        private void TakeRights()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            StringBuilder DeleteParams = new StringBuilder();

            int Amount = Request.PopWiredInt32();

            for (int i = 0; i < Amount; i++)
            {
                if (i > 0)
                {
                    DeleteParams.Append(" OR ");
                }

                int UserId = Request.PopWiredInt32();
                Room.UsersWithRights.Remove(UserId);
                DeleteParams.Append("room_id = '" + Room.RoomId + "' AND user_id = '" + UserId + "'");

                RoomUser User = Room.GetRoomUserByPlayer(UserId);

                if (User != null && !User.IsBot)
                {
                    User.GetSession().SendMessage(new ServerMessage(43));
                }

                // GhntX]hqu@U

                GetResponse().Init(511);
                GetResponse().AppendInt32(Room.RoomId);
                GetResponse().AppendInt32(UserId);
                SendResponse();
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("DELETE FROM rooms_rights WHERE " + DeleteParams.ToString());
            }
        }

        private void TakeAllRights()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            foreach (int UserId in Room.UsersWithRights)
            {
                RoomUser User = Room.GetRoomUserByPlayer(UserId);

                if (User != null && !User.IsBot)
                {
                    User.GetSession().SendMessage(new ServerMessage(43));
                }

                GetResponse().Init(511);
                GetResponse().AppendInt32(Room.RoomId);
                GetResponse().AppendInt32(UserId);
                SendResponse();
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("DELETE FROM rooms_rights WHERE room_id = '" + Room.RoomId + "'");
            }

            Room.UsersWithRights.Clear();
        }

        private void KickUser()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            if (!Room.CheckRights(Session))
            {
                return; // insufficient permissions
            }

            int UserId = Request.PopWiredInt32();
            RoomUser User = Room.GetRoomUserByPlayer(UserId);

            if (User == null || User.IsBot)
            {
                return;
            }

            if (Room.CheckRights(User.GetSession(), true)) // TODO: fuse_mod
            {
                return; // can't kick room owner or mods!
            }

            Room.RemoveUserFromRoom(User.GetSession(), true, true);
        }

        private void BanUser()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return; // insufficient permissions
            }

            int UserId = Request.PopWiredInt32();
            RoomUser User = Room.GetRoomUserByPlayer(UserId);

            if (User == null || User.IsBot)
            {
                return;
            }

            /*if (User.GetSession().GetHabbo().HasFuse("fuse_mod"))
            {
                return;
            }*/

            Room.AddBan(UserId);
            Room.RemoveUserFromRoom(User.GetSession(), true, true);
        }

        private void SetHomeRoom()
        {
            int RoomId = Request.PopWiredInt32();
            RoomData Data = MangoServer.GetGame().GetRoomManager().GenerateRoomData(RoomId);

            if (RoomId != 0)
            {
                if (Data == null || Data.Owner.ToLower() != Session.GetPlayer().Username.ToLower())
                {
                    return;
                }
            }

            Session.GetPlayer().HomeRoomId = RoomId;

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("UPDATE users SET home_room = '" + RoomId + "' WHERE id = '" + Session.GetPlayer().Id + "' LIMIT 1");
            }

            GetResponse().Init(455);
            GetResponse().AppendInt32(RoomId);
            SendResponse();
        }

        private void DeleteRoom()
        {
            int RoomId = Request.PopWiredInt32();
            RoomData Data = MangoServer.GetGame().GetRoomManager().GenerateRoomData(RoomId);

            if (Data == null || Data.Owner.ToLower() != Session.GetPlayer().Username.ToLower())
            {
                return;
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("DELETE FROM rooms WHERE id = '" + Data.Id + "' LIMIT 1");
                SqlClient.RunQuery("DELETE FROM users_favorites WHERE room_id = '" + Data.Id + "'");
                SqlClient.RunQuery("DELETE FROM rooms_items WHERE room_id = '" + Data.Id + "'");
                SqlClient.RunQuery("DELETE FROM rooms_rights WHERE room_id = '" + Data.Id + "'");
                SqlClient.RunQuery("UPDATE users SET home_room = '0' WHERE home_room = '" + Data.Id + "'");
                // todo: delete room stuff
            }

            Room Room = MangoServer.GetGame().GetRoomManager().GetRoom(Data.Id);

            if (Room != null)
            {
                foreach (RoomUser User in Room.GetUsers)
                {
                    if (User.IsBot)
                    {
                        continue;
                    }

                    User.GetSession().SendMessage(new ServerMessage(18));
                    User.GetSession().GetPlayer().OnLeaveRoom();
                }

                MangoServer.GetGame().GetRoomManager().UnloadRoom(Data.Id);
            }

            GetResponse().Init(101);
            SendResponse();

            Session.SendMessage(MangoServer.GetGame().GetNavigator().SerializeRoomListing(Session, -3));
        }

        private void LookAt()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            User.Unidle();

            int X = Request.PopWiredInt32();
            int Y = Request.PopWiredInt32();

            if (X == User.X && Y == User.Y)
            {
                return;
            }

            int Rot = Rotation.Calculate(User.X, User.Y, X, Y);

            User.SetRot(Rot);
        }

        private void StartTyping()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            ServerMessage Message = new ServerMessage(361);
            Message.AppendInt32(User.VirtualId);
            Message.AppendBoolean(true);
            Room.SendMessage(Message);
        }

        private void StopTyping()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            ServerMessage Message = new ServerMessage(361);
            Message.AppendInt32(User.VirtualId);
            Message.AppendBoolean(false);
            Room.SendMessage(Message);
        }

        private void IgnoreUser()
        {
            /*Room Room = UberEnvironment.GetGame().GetRoomManager().GetRoom(Session.GetHabbo().CurrentRoom);

            if (Room == null)
            {
                return;
            }

            uint Id = Request.PopWiredUInt();

            if (Session.GetHabbo().MutedUsers.Contains(Id))
            {
                return;
            }

            Session.GetHabbo().MutedUsers.Add(Id);

            GetResponse().Init(419);
            GetResponse().AppendInt32(1);
            SendResponse();*/
        }

        private void UnignoreUser()
        {
            /*Room Room = UberEnvironment.GetGame().GetRoomManager().GetRoom(Session.GetHabbo().CurrentRoom);

            if (Room == null)
            {
                return;
            }

            uint Id = Request.PopWiredUInt();

            if (!Session.GetHabbo().MutedUsers.Contains(Id))
            {
                return;
            }

            Session.GetHabbo().MutedUsers.Remove(Id);

            GetResponse().Init(419);
            GetResponse().AppendInt32(3);
            SendResponse();*/
        }

        private void CanCreateRoomEvent()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            Boolean Allow = true;
            int ErrorCode = 0;

            if (Room.State != 0)
            {
                Allow = false;
                ErrorCode = 3;
            }

            GetResponse().Init(367);
            GetResponse().AppendBoolean(Allow);
            GetResponse().AppendInt32(ErrorCode);
            SendResponse();
        }

        private void StartEvent()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true) || Room.Event != null || Room.State != 0)
            {
                return;
            }

            int category = Request.PopWiredInt32();
            string name = Filtering.FilterInjectionChars(Request.PopFixedString());
            string descr = Filtering.FilterInjectionChars(Request.PopFixedString());
            int tagCount = Request.PopWiredInt32();

            Room.Event = new RoomEvent(Room.RoomId, name, descr, category, null);
            Room.Event.Tags = new List<string>();

            for (int i = 0; i < tagCount; i++)
            {
                Room.Event.Tags.Add(Filtering.FilterInjectionChars(Request.PopFixedString()));
            }

            Room.SendMessage(Room.Event.Serialize(Session));
        }

        private void StopEvent()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true) || Room.Event == null)
            {
                return;
            }

            Room.Event = null;

            ServerMessage Message = new ServerMessage(370);
            Message.AppendStringWithBreak("-1");
            Room.SendMessage(Message);
        }

        private void EditEvent()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true) || Room.Event == null)
            {
                return;
            }

            int category = Request.PopWiredInt32();
            string name = Filtering.FilterInjectionChars(Request.PopFixedString());
            string descr = Filtering.FilterInjectionChars(Request.PopFixedString());
            int tagCount = Request.PopWiredInt32();

            Room.Event.Category = category;
            Room.Event.Name = name;
            Room.Event.Description = descr;
            Room.Event.Tags = new List<string>();

            for (int i = 0; i < tagCount; i++)
            {
                Room.Event.Tags.Add(Filtering.FilterInjectionChars(Request.PopFixedString()));
            }

            Room.SendMessage(Room.Event.Serialize(Session));
        }

        private void Wave()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            User.Unidle();

            User.DanceId = 0;

            ServerMessage Message = new ServerMessage(481);
            Message.AppendInt32(User.VirtualId);
            Room.SendMessage(Message);
        }

        private void GetUserTags()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Request.PopWiredInt32());

            if (User == null || User.IsBot)
            {
                return;
            }

            List<string> Tags = new List<string>(User.GetSession().GetPlayer().Tags);

            GetResponse().Init(350);
            GetResponse().AppendInt32(User.GetSession().GetPlayer().Id);
            GetResponse().AppendInt32(Tags.Count);

            foreach (string Tag in Tags)
            {
                GetResponse().AppendStringWithBreak(Tag);
            }

            SendResponse();
        }

        private void GetUserBadges()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Request.PopWiredInt32());

            if (User == null || User.IsBot)
            {
                return;
            }

            // CdjUzYZJIACH_RespectEarned1JACH_EmailVerification1
E^jUzYZH


            List<Badge> Badges = new List<Badge>(); // Initialise an empty badge list

            foreach (Badge Badge in User.GetSession().GetPlayer().GetBadgeComponent().GetBadges()) // Get all equipped badges to display
            {
                if (Badge.Slot <= 0)
                {
                    continue;
                }

                Badges.Add(Badge);
            }

            GetResponse().Init(228);
            GetResponse().AppendInt32(User.GetSession().GetPlayer().Id);
            GetResponse().AppendInt32(Badges.Count); // Set the amount of badges to serialize

            foreach (Badge Badge in Badges) // Serialize all badges
            {
                GetResponse().AppendInt32(Badge.Slot);
                GetResponse().AppendStringWithBreak(Badge.Code);
            }

            SendResponse();
        }

        private void RateRoom()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || Session.GetPlayer().RatedRooms.Contains(Room.RoomId) || Room.CheckRights(Session, true))
            {
                return;
            }

            int Rating = Request.PopWiredInt32();

            switch (Rating)
            {
                case -1:

                    Room.Score--;
                    break;

                case 1:

                    Room.Score++;
                    break;

                default:

                    return;
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("UPDATE rooms SET score = '" + Room.Score + "' WHERE id = '" + Room.RoomId + "' LIMIT 1");
            }

            Session.GetPlayer().RatedRooms.Add(Room.RoomId);

            GetResponse().Init(345);
            GetResponse().AppendInt32(Room.Score);
            SendResponse();
        }

        private void Dance()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomUser User = Room.GetRoomUserByPlayer(Session.GetPlayer().Id);

            if (User == null)
            {
                return;
            }

            User.Unidle();

            int DanceId = Request.PopWiredInt32();

            if (DanceId < 0 || DanceId > 4 || (!Session.GetPlayer().GetSubscriptionManager().HasSubscription("habbo_club") && DanceId > 1))
            {
                DanceId = 0;
            }

            if (DanceId > 0 && User.CarryItemID > 0)
            {
                User.CarryItem(0);
            }

            User.DanceId = DanceId;

            ServerMessage DanceMessage = new ServerMessage(480);
            DanceMessage.AppendInt32(User.VirtualId);
            DanceMessage.AppendInt32(DanceId);
            Room.SendMessage(DanceMessage);
        }

        private void AnswerDoorbell()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session))
            {
                return;
            }

            string Name = Request.PopFixedString();
            byte[] Result = Request.ReadBytes(1);

            Session Client = MangoServer.GetGame().GetSessionManager().GetSessionByPlayer(Name);

            if (Client == null)
            {
                return;
            }

            if (Result[0] == Convert.ToByte(65))
            {
                Client.GetPlayer().LoadingChecksPassed = true;

                Client.GetMessageHandler().GetResponse().Init(41);
                Client.GetMessageHandler().SendResponse();
            }
            else
            {
                Client.GetMessageHandler().GetResponse().Init(131);
                Client.GetMessageHandler().SendResponse();
            }
        }

        private void ApplyRoomEffect()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            UserItem Item = Session.GetPlayer().GetInventoryComponent().GetItem(Request.PopWiredInt32());

            if (Item == null)
            {
                return;
            }

            string type = "floor";

            if (Item.GetBaseItem().Name.ToLower().Contains("wallpaper"))
            {
                type = "wallpaper";
            }
            else if (Item.GetBaseItem().Name.ToLower().Contains("landscape"))
            {
                type = "landscape";
            }

            switch (type)
            {
                case "floor":

                    Room.Floor = Item.ExtraData;
                    break;

                case "wallpaper":

                    Room.Wallpaper = Item.ExtraData;
                    break;

                case "landscape":

                    Room.Landscape = Item.ExtraData;
                    break;
            }

            using (SqlConnection SqlClient = MangoServer.GetSqlManager().GetConnection())
            {
                SqlClient.RunQuery("UPDATE rooms SET " + type + " = '" + Item.ExtraData + "' WHERE id = '" + Room.RoomId + "' LIMIT 1");
            }

            Session.GetPlayer().GetInventoryComponent().RemoveItem(Item.Id);

            ServerMessage Message = new ServerMessage(46);
            Message.AppendStringWithBreak(type);
            Message.AppendStringWithBreak(Item.ExtraData);
            Room.SendMessage(Message);
        }

        private void PlaceItem()
        {
            // AZ@J16 10 10 0

            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session))
            {
                return;
            }

            string PlacementData = Request.PopFixedString();
            string[] DataBits = PlacementData.Split(' ');
            int ItemId = int.Parse(DataBits[0]);

            UserItem Item = Session.GetPlayer().GetInventoryComponent().GetItem(ItemId);

            if (Item == null)
            {
                return;
            }

            switch (Item.GetBaseItem().InteractionType.ToLower())
            {
                case "dimmer":

                    if (Room.ItemCountByType("dimmer") >= 1)
                    {
                        Session.SendNotif("You can only have one moodlight in a room.");
                        return;
                    }

                    break;
            }

            // Wall Item
            if (DataBits[1].StartsWith(":"))
            {
                string WallPos = Room.WallPositionCheck(":" + PlacementData.Split(':')[1]);

                if (WallPos == null)
                {
                    GetResponse().Init(516);
                    GetResponse().AppendInt32(11);
                    SendResponse();

                    return;
                }

                RoomItem RoomItem = new RoomItem(Item.Id, Item.BaseItem, Item.ExtraData, 0, 0, 0.0, 0, WallPos, Room);

                if (Room.SetWallItem(Session, RoomItem))
                {
                    Session.GetPlayer().GetInventoryComponent().RemoveItem(ItemId);
                }
            }
            // Floor Item
            else
            {
                int X = int.Parse(DataBits[1]);
                int Y = int.Parse(DataBits[2]);
                int Rot = int.Parse(DataBits[3]);

                RoomItem RoomItem = new RoomItem(Item.Id, Item.BaseItem, Item.ExtraData, 0, 0, 0, 0, "", Room);

                if (Room.SetFloorItem(Session, RoomItem, X, Y, Rot, true))
                {
                    Session.GetPlayer().GetInventoryComponent().RemoveItem(ItemId);
                }
            }
        }

        private void TakeItem()
        {
            int junk = Request.PopWiredInt32();

            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session, true))
            {
                return;
            }

            RoomItem Item = Room.GetItem(Request.PopWiredInt32());

            if (Item == null)
            {
                return;
            }

            switch (Item.GetBaseItem().InteractionType.ToLower())
            {
                case "postit":

                    return; // not allowed to pick up post.its
            }

            Room.RemoveFurniture(Session, Item.Id);
            Session.GetPlayer().GetInventoryComponent().AddItem(Item.Id, Item.BaseItem, Item.ExtraData);
            Session.GetPlayer().GetInventoryComponent().UpdateItems(false);
        }

        private void MoveItem()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null || !Room.CheckRights(Session))
            {
                return;
            }

            RoomItem Item = Room.GetItem(Request.PopWiredInt32());

            if (Item == null)
            {
                return;
            }

            int x = Request.PopWiredInt32();
            int y = Request.PopWiredInt32();
            int Rotation = Request.PopWiredInt32();
            int Junk = Request.PopWiredInt32();

            Room.SetFloorItem(Session, Item, x, y, Rotation, false);
        }

        private void TriggerItem()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomItem Item = Room.GetItem(Request.PopWiredInt32());

            if (Item == null)
            {
                return;
            }

            Boolean hasRights = false;

            if (Room.CheckRights(Session))
            {
                hasRights = true;
            }

            Item.Interactor.OnTrigger(Session, Item, Request.PopWiredInt32(), hasRights);
        }

        private void TriggerItemDiceSpecial()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomItem Item = Room.GetItem(Request.PopWiredInt32());

            if (Item == null)
            {
                return;
            }

            bool hasRights = false;

            if (Room.CheckRights(Session))
            {
                hasRights = true;
            }

            Item.Interactor.OnTrigger(Session, Item, -1, hasRights);
        }

        private void OpenPostit()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomItem Item = Room.GetItem(Request.PopWiredInt32());

            if (Item == null || Item.GetBaseItem().InteractionType.ToLower() != "postit")
            {
                return;
            }

            // @p181855059CFF9C stickynotemsg
            GetResponse().Init(48);
            GetResponse().AppendStringWithBreak(Item.Id.ToString());
            GetResponse().AppendStringWithBreak(Item.ExtraData);
            SendResponse();
        }

        private void SavePostit()
        {
            Room Room = Session.GetPlayer().GetRoom();

            if (Room == null)
            {
                return;
            }

            RoomItem Item = Room.GetItem(Request.PopWiredInt32());

            if (Item == null || Item.GetBaseItem().InteractionType.ToLower() != "postit")
            {
                return;
            }

            String Data = Request.PopFixedString();
            String Color = Data.Split(' ')[0];
            String Text = Filtering.FilterInjectionChars(Data.Substring(Color.Length + 1), true);

            if (!Room.CheckRights(Session))
            {
                if (!Data.StartsWith(Item.ExtraData))
                {
                    return; // we can only ADD stuff! older stuff changed, this is not allowed
                }
            }

            switch (Color)
            {
                case "FFFF33":
                case "FF9CFF":
                case "9CCEFF":
                case "9CFF9C":

                    break;

                default:

                    return; // invalid color
            }

            Item.ExtraData = Color + " " + Text;
            Item.UpdateState(true, true);
        }
    }
}