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

namespace Blizzard.HabboHotel.Users
{
    class Navigator
    {
        internal Habbo User;
        internal Navigator(Habbo cUser)
        {
            User = cUser;
        }

        internal void GetSearchRooms()
        {
            ServerMessage Search = new ServerMessage("GD");
            Dictionary<int, string> Tags = new Dictionary<int, string>();
            foreach (RoomsData Room in RoomsData.AllRoom)
            {
                if (Room.TagList.Count > 0)
                {
                    foreach (string s in Room.TagList)
                    {
                        if (!Tags.ContainsValue(s))
                        {
                            Tags.Add(Room.Id, s);
                            break;
                        }
                    }
                }
                else
                {
                    continue;
                }
            }
            foreach (KeyValuePair<int, string> L in Tags)
            {
                Search.AddInt(L.Key); // Tags Id
                Search.AddStringWithBreak(L.Value);
            }
            User.SendMessage(Search);
        }

        internal void SearchByName()
        {
            // Fu@FItachi
            string Name = User.ActualClientMessage.GetNextString();
            ServerMessage NameRooms = new ServerMessage("GC");
            NameRooms.AddStringWithBreak("PB");
            List<RoomsData> RoomsSearch = new List<RoomsData>();
            List<RoomEvent> RoomEventsSearch = new List<RoomEvent>();
            bool searchforuser = false;
            foreach (UsersData Uzer in UsersData.UsersRegistered)
            {
                if (Uzer.UserName == Name)
                    searchforuser = true;
            }
            if (searchforuser)
            {
                foreach (RoomsData Data in RoomsData.AllRoom)
                {
                    if (RoomEvent.HasEvent(Data.Id))
                    {
                        RoomEvent E = RoomEvent.GetEventForRoom(Data.Id);
                        if (Data.OwnerName == Name)
                            RoomEventsSearch.Add(E);
                    }
                    else
                    {
                        if (Data.OwnerName == Name)
                            RoomsSearch.Add(Data);
                    }
                }
            }
            else
            {
                foreach (RoomsData Data in RoomsData.AllRoom)
                {
                    if (RoomEvent.HasEvent(Data.Id))
                    {
                        RoomEvent E = RoomEvent.GetEventForRoom(Data.Id);
                        if (E.Title.Contains(Name))
                            RoomEventsSearch.Add(E);
                    }
                    else
                    {
                        if (Data.Name.Contains(Name))
                            RoomsSearch.Add(Data);
                    }
                }
            }
            NameRooms.AddInt(RoomsSearch.Count + RoomEventsSearch.Count);
            foreach (RoomsData Data in RoomsSearch)
            {
                this.SerializeRoom(NameRooms, Data);
            }
            foreach (RoomEvent Event in RoomEventsSearch)
            {
                this.SerializeEvent(NameRooms, RoomsData.Rooms[Event.RoomId], Event);
            }
            NameRooms.AddInt(0);
            User.SendMessage(NameRooms);
        }

        internal void SearchByTag()
        {
            // Fv@Ctag
            string Tag = User.ActualClientMessage.GetNextString();
            ServerMessage NameRooms = new ServerMessage("GC");
            NameRooms.AddStringWithBreak("PB");
            List<RoomsData> RoomsSearch = new List<RoomsData>();
            List<RoomEvent> RoomEventsSearch = new List<RoomEvent>();
            foreach (RoomsData Data in RoomsData.AllRoom)
            {
                if (Data.TagList.Contains(Tag))
                    RoomsSearch.Add(Data);
            }
            foreach (RoomEvent Event in RoomEvent.Events)
            {
                if (Event.Tags.Contains(Tag))
                    RoomEventsSearch.Add(Event);
            }
            NameRooms.AddInt(RoomsSearch.Count + RoomEventsSearch.Count);
            foreach (RoomsData Data in RoomsSearch)
            {
                this.SerializeRoom(NameRooms, Data);
            }
            foreach (RoomEvent Event in RoomEventsSearch)
            {
                this.SerializeEvent(NameRooms, RoomsData.Rooms[Event.RoomId], Event);
            }
            NameRooms.AddInt(0);
            User.SendMessage(NameRooms);
        }

        internal void GetPublics()
        {
        }

        internal void CanCreateRoom()
        {
            List<RoomsData> MyRoom = new List<RoomsData>();
            foreach (RoomsData Data in RoomsData.AllRoom)
            {
                if (Data.OwnerId == User.Id)
                    MyRoom.Add(Data);
            }

            UsersData uData = UsersData.UsersRegister[User.Id];
            ServerMessage CanCreate = new ServerMessage("H@");
            if ((MyRoom.Count + 1) > uData.MaxRooms)
            {
                CanCreate.AddBoolean(true);
                CanCreate.AddInt(uData.MaxRooms);
            }
            else
            {
                CanCreate.AddBoolean(false);
            }

            User.SendMessage(CanCreate);
        }

        internal void CreateNewRoom()
        {
            // @]@HRoomName@Gmodel_a
            string RoomName = User.ActualClientMessage.GetNextString();
            string RoomModel = User.ActualClientMessage.GetNextString();

            Updater.SQLStoExecute.Add("INSERT INTO rooms (id, ownerid, name, description, state, maxusers, score, category, tags, model, public_room, icon_bg, icon_fg, wall, floor, landscape) VALUES (NULL , '" + User.Id + "', '" + RoomName + "', '', '0', '10', '0', '0', '', '" + RoomModel + "', '0', '0', '0', 0, 0 ,'0.0');");
            int LastId = RoomsData.GetLastId() + 1;
            RoomsData.AddNewRoom(LastId, User.Id, RoomName, RoomModel);

            ServerMessage GoToRoom = new ServerMessage("@{");
            GoToRoom.AddInt(LastId);
            GoToRoom.AddStringWithBreak(RoomName);
            User.SendMessage(GoToRoom);
        }

        internal void GetRoomInfo()
        {
            // FAQCIH
            int RoomId = User.ActualClientMessage.GetNextInt();
            int uk1 = User.ActualClientMessage.GetNextInt();
            int uk2 = User.ActualClientMessage.GetNextInt();
            if (RoomsData.Rooms.ContainsKey(RoomId))
            {
                // :O
                RoomsData D = RoomsData.Rooms[RoomId];
                ServerMessage SRoomData = new ServerMessage("GF");
                SRoomData.AddBoolean(false);
                SRoomData.AddInt(D.Id);
                SRoomData.AddBoolean(false);
                SRoomData.AddStringWithBreak(D.Name);
                SRoomData.AddStringWithBreak(D.OwnerName);
                SRoomData.AddInt(D.State);
                SRoomData.AddInt(D.CurrentUsersInRoom); // Users on this
                SRoomData.AddInt(D.MaxUsers);
                SRoomData.AddStringWithBreak(D.Description);
                SRoomData.AddInt(0);
                if (D.Category == 3)
                {
                    SRoomData.AddInt(1);
                }
                else
                {
                    SRoomData.AddInt(0);
                }
                SRoomData.AddInt(8228);
                SRoomData.AddInt(D.Category);
                SRoomData.AddStringWithBreak("");
                SRoomData.AddInt(D.TagList.Count); // Tag Count

                foreach (string Tag in D.TagList)
                {
                    SRoomData.AddStringWithBreak(Tag);
                }
                // Icon
                SRoomData.AddInt(D.IconBackground);
                SRoomData.AddInt(D.IconForeground);
                SRoomData.AddInt(D.Icons.Count); // Icon items

                // Serialize Icons
                if (D.Icons.Count > 0)
                {
                    foreach (KeyValuePair<int, int> Icon in D.Icons)
                    {
                        SRoomData.AddInt(Icon.Key);
                        SRoomData.AddInt(Icon.Value);
                    }
                }

                SRoomData.AddBoolean(false);
                SRoomData.AddBoolean(true);
                User.SendMessage(SRoomData);
            }

        }

        internal void GetRoomsForScore()
        {
            ServerMessage Rooms = new ServerMessage("GC");
            Rooms.AddStringWithBreak("QA");
            List<RoomsData> zRoom = new List<RoomsData>();
            List<RoomsData> Room = new List<RoomsData>();
            int CurrentMax = 0;
            foreach (RoomsData Data in RoomsData.AllRoom)
            {
                // I must code this later uh...
                if (Data.CurrentUsersInRoom > 0)
                {
                    if (Data.Score > CurrentMax)
                        CurrentMax = Data.Score;
                    zRoom.Add(Data);
                }
            }

            for (int i = 0; CurrentMax != i; )
            {
                foreach (RoomsData Data in zRoom)
                {
                    if (Data.Score == CurrentMax)
                        Room.Add(Data);
                }
                CurrentMax--;
            }

            Rooms.AddInt(Room.Count);
            foreach (RoomsData Data in Room)
            {
                this.SerializeRoom(Rooms, Data);
            }
            Rooms.AddInt(0);
            User.SendMessage(Rooms);
        }

        internal void GetAllRooms()
        {
            ServerMessage Rooms = new ServerMessage("GC");
            Rooms.AddStringWithBreak("QA");
            int Category = int.Parse(User.ActualClientMessage.GetNextString());
            // Rooms with most visitors
            List<RoomsData> RoomsToSearch = new List<RoomsData>();
            if (Category == -1)
                RoomsToSearch = RoomsData.AllRoom;
            else if (Category == 0)
                RoomsToSearch = RoomsData.GetRoomsForCategory(8);
            else
                RoomsToSearch = RoomsData.GetRoomsForCategory(Category);
            List<RoomsData> zRoom = new List<RoomsData>();
            List<RoomsData> Room = new List<RoomsData>();
            int CurrentMax = 0;
            foreach (RoomsData Data in RoomsToSearch)
            {
                // I must code this later uh...
                if (Data.CurrentUsersInRoom > 0)
                {
                    if (Data.CurrentUsersInRoom > CurrentMax)
                        CurrentMax = Data.CurrentUsersInRoom;
                    zRoom.Add(Data);
                }
            }

            for (int i = 0; CurrentMax != i; )
            {
                foreach (RoomsData Data in zRoom)
                {
                    if (Data.CurrentUsersInRoom == CurrentMax)
                        Room.Add(Data);
                }
                CurrentMax--;
            }

            Rooms.AddInt(Room.Count);
            foreach (RoomsData Data in Room)
            {
                this.SerializeRoom(Rooms, Data);
            }
            Rooms.AddInt(0);
            User.SendMessage(Rooms);
        }

        internal void GetEvents()
        {
            int CategoryId = int.Parse(User.ActualClientMessage.GetNextString());
            ServerMessage Rooms = new ServerMessage("GC");
            Rooms.AddInt(CategoryId);
            Rooms.AddStringWithBreak("PC");
            List<RoomEvent> Events = RoomEvent.GetEventForCategorys(CategoryId);
            Rooms.AddInt(Events.Count);
            foreach (RoomEvent E in Events)
            {
                this.SerializeEvent(Rooms, RoomsData.Rooms[E.RoomId], E);
            }
            Rooms.AddInt(0);
            User.SendMessage(Rooms);
        }

        internal void DeleteFromFavourites()
        {
            int RoomId = HabboEncode.decodeVL64(User.ActualPacket.Substring(2));
            User.FavouriteRooms.Remove(RoomId);

            string Favs = "";
            foreach (int i in User.FavouriteRooms)
            {
                if (i == RoomId)
                    continue;

                Favs += i.ToString() + ";";
            }

            ServerMessage F = new ServerMessage("GK");
            F.AddInt(RoomId);
            F.AddBoolean(false);
            User.SendMessage(F);

            Updater.SQLStoExecute.Add("UPDATE users SET roomfavourites = '" + Favs + "' WHERE id = " + User.Id);
        }

        internal void DeleteFromFavourites(int RoomId)
        {
            User.FavouriteRooms.Remove(RoomId);
            string Favs = "";
            foreach (int i in User.FavouriteRooms)
            {
                if (i == RoomId)
                    continue;

                Favs += i.ToString() + ";";
            }

            ServerMessage F = new ServerMessage("GK");
            F.AddInt(RoomId);
            F.AddBoolean(false);
            User.SendMessage(F);

            Updater.SQLStoExecute.Add("UPDATE users SET roomfavourites = '" + Favs + "' WHERE id = " + User.Id);
        }

        internal void AddToFavourites()
        {
            int RoomId = HabboEncode.decodeVL64(User.ActualPacket.Substring(2));

            if(User.FavouriteRooms.Contains(RoomId))
                return;

            User.FavouriteRooms.Add(RoomId);

            string Favs = "";
            foreach (int i in User.FavouriteRooms)
                Favs += i.ToString() + ";";

            ServerMessage F = new ServerMessage("GK");
            F.AddInt(RoomId);
            F.AddBoolean(true);
            User.SendMessage(F);

            Updater.SQLStoExecute.Add("UPDATE users SET roomfavourites = '" + Favs + RoomId.ToString() + ";' WHERE id = " + User.Id);
        }

        internal void GetFavs()
        {
            ServerMessage MyRooms = new ServerMessage("GC");
            MyRooms.AddStringWithBreak("QA");
            if(User.FavouriteRooms.Count > 0)
            {
                List<RoomsData> MyRoom = new List<RoomsData>();
                foreach (RoomsData Data in RoomsData.AllRoom)
                {
                    foreach (int VId in User.FavouriteRooms)
                    {
                        if (Data.Id == VId)
                            MyRoom.Add(Data);
                        else
                            continue;
                    }
                }
                MyRooms.AddInt(MyRoom.Count);
                foreach (RoomsData Data in MyRoom)
                {
                    this.SerializeRoom(MyRooms, Data);
                }
            }
            else
            {
                MyRooms.AddInt(0);
            }
            MyRooms.AddInt(0);
            User.SendMessage(MyRooms);
        }

        internal void GetRecentRooms()
        {
            ServerMessage MyRooms = new ServerMessage("GC");
            MyRooms.AddStringWithBreak("QA");

            List<int> RecentRooms = new List<int>();
            if (User.VisitedRooms.Contains(";"))
            {
                string[] recents = User.VisitedRooms.Split(';');

                foreach (string rec in recents)
                {
                    if (rec == "")
                        continue;

                    if(RecentRooms.Contains(int.Parse(rec)))
                        continue;
                    RecentRooms.Add(int.Parse(rec));
                }
                List<RoomsData> MyRoom = new List<RoomsData>();
                foreach (RoomsData Data in RoomsData.AllRoom)
                {
                    foreach (int VId in RecentRooms)
                    {
                        if (Data.Id == VId)
                            MyRoom.Add(Data);
                        else
                            continue;
                    }
                }
                MyRooms.AddInt(MyRoom.Count);
                foreach (RoomsData Data in MyRoom)
                {
                    this.SerializeRoom(MyRooms, Data);
                }
            }
            else
            {
                MyRooms.AddInt(0);
            }
            MyRooms.AddInt(0);
            User.SendMessage(MyRooms);
        }

        internal void GetMyRooms()
        {
            ServerMessage MyRooms = new ServerMessage("GC");
            MyRooms.AddStringWithBreak("QA");
            List<RoomsData> MyRoom = new List<RoomsData>();
            foreach (RoomsData Data in RoomsData.AllRoom)
            {
                if (Data.OwnerId == User.Id)
                    MyRoom.Add(Data);
            }
            MyRooms.AddInt(MyRoom.Count);
            foreach (RoomsData Data in MyRoom)
            {
                this.SerializeRoom(MyRooms, Data);
            }
            MyRooms.AddInt(0);
            User.SendMessage(MyRooms);
        }

        internal void SerializeRoom(ServerMessage Message, RoomsData Data)
        {
            if (Data == null)
                return;

            Message.AddInt(Data.Id);
            Message.AddBoolean(false); // Events
            Message.AddStringWithBreak(Data.Name);
            Message.AddStringWithBreak(Data.OwnerName);
            Message.AddInt(Data.State); // State (0 = Open, 1 = Locked, 2 = Password)
            Message.AddInt(Data.CurrentUsersInRoom);
            Message.AddInt(Data.MaxUsers);
            Message.AddStringWithBreak(Data.Description);
            Message.AddInt(0);
            Message.AddBoolean((Data.Category == 3));
            Message.AddInt(Data.Score);
            Message.AddInt(Data.Category);
            Message.AddStringWithBreak("");
            Message.AddInt(Data.TagList.Count); // Tag Count
            foreach (string Tag in Data.TagList)
            {
                Message.AddStringWithBreak(Tag);
            }
            // Icon
            Message.AddInt(Data.IconBackground);
            Message.AddInt(Data.IconForeground);
            Message.AddInt(Data.Icons.Count); // Icon items

            // Serialize Icons
            if (Data.Icons.Count > 0)
            {
                foreach (KeyValuePair<int, int> Icon in Data.Icons)
                {
                    Message.AddInt(Icon.Key);
                    Message.AddInt(Icon.Value);
                }
            }

            // bools extra
            Message.AddBoolean(false);
            Message.AddBoolean(true);

        }

        internal void SerializeCategories()
        {
            ServerMessage Categories = new ServerMessage("C]");
            int CountCategorys = RoomCategory.CountCategorysForMyRank(User.Rank);
            Categories.AddInt(CountCategorys);
            foreach (RoomCategory Cat in RoomCategory.Categorys)
            {
                if (Cat.MinRank > User.Rank)
                    continue;
                else
                {
                    if (Cat.Id != 8)
                    {
                        Categories.AddBoolean(true);
                        Categories.AddInt(Cat.Id);
                    }
                    else
                        Categories.AddBoolean(false);
                    Categories.AddStringWithBreak(Cat.Caption);
                }
            }
            Categories.AddChar(2);
            User.SendMessage(Categories);
        }

        internal void SerializeEvent(ServerMessage Message, RoomsData Data, RoomEvent Event)
        {
            Message.AddInt(Data.Id);
            Message.AddBoolean(true);
            Message.AddStringWithBreak(Event.Title);
            Message.AddStringWithBreak(Data.OwnerName);
            Message.AddInt(Data.State);
            Message.AddInt(Data.CurrentUsersInRoom);
            Message.AddInt(Data.MaxUsers);
            Message.AddStringWithBreak(Event.Description);
            Message.AddInt(0);
            Message.AddBoolean((Data.Category == 3));
            Message.AddInt(Data.Score);
            Message.AddInt(Event.CategoryId);
            Message.AddStringWithBreak(Event.StartTime.ToString());
            Message.AddInt(Event.Tags.Count);

            foreach (string Tag in Event.Tags)
            {
                Message.AddStringWithBreak(Tag);
            }

            Message.AddInt(Data.IconBackground);
            Message.AddInt(Data.IconForeground);
            Message.AddInt(Data.Icons.Count); // Icon items

            // Serialize Icons
            if (Data.Icons.Count > 0)
            {
                foreach (KeyValuePair<int, int> Icon in Data.Icons)
                {
                    Message.AddInt(Icon.Key);
                    Message.AddInt(Icon.Value);
                }
            }

            Message.AddBoolean(false);
            Message.AddBoolean(true);
        }
    }
}