using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DuckEmulator.HabboHotel.Outside.Messages.Types;
using System.Data;
using DuckEmulator.HabboHotel.Inside.Storage.MySql.Database.Interfaces;
using DuckEmulator.HabboHotel.Outside.Habbos;
using DuckEmulator.HabboHotel.Outside.Rooms;

namespace DuckEmulator.HabboHotel.Outside.Navigator
{
    class NavigatorManager
    {
        internal Dictionary<uint, PublicCat> PublicCats;
        internal Dictionary<uint, PublicRoom> PublicRooms;

        internal Dictionary<int, PrivateCat> PrivateCats;

        internal NavigatorManager()
        {
            LoadPrivCats();
            LoadPubCats();
            LoadPubRooms();
        }

        internal void LoadPubCats()
        {
            PublicCats = new Dictionary<uint, PublicCat>();
            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT * FROM public_categorys WHERE enabled = '1'");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                PublicCats.Add((uint)Row["id"], new PublicCat((uint)Row["id"], Row["name"].ToString(), Row["image"].ToString()));
            }

            DuckEnvironment.WriteLine("Loaded " + PublicCats.Count + " public categorys.", ConsoleColor.Yellow);
        }

        internal void LoadPrivCats()
        {
            PrivateCats = new Dictionary<int, PrivateCat>();
            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT * FROM private_categorys");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                PrivateCats.Add((int)Row["id"], new PrivateCat((int)Row["id"], (int)Row["min_rank"], Row["name"].ToString()));
            }

            DuckEnvironment.WriteLine("Loaded " + PrivateCats.Count + " private categorys.", ConsoleColor.Yellow);
        }

        internal void LoadPubRooms()
        {
            PublicRooms = new Dictionary<uint, PublicRoom>();
            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT * FROM public_rooms");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                PublicRooms.Add((uint)Row["id"], new PublicRoom((uint)Row["id"], (uint)Row["private_room_id"], (string)Row["image"], int.Parse(Row["image_type"].ToString()), (int)Row["public_category"]));
            }
        }

        internal ServerMessage SerializePublicRooms()
        {
            ServerMessage Message = new ServerMessage(450);
            Message.AppendInt32(PublicCats.Count + PublicRooms.Count); // pub count

            foreach (PublicCat Pub in PublicCats.Values.ToList())
            {
                Pub.Serialize(Message);

                foreach (PublicRoom Room in PublicRooms.Values.ToList())
                {
                    if (Room.Category == Pub.Id)
                        Room.Serialize(Message);
                }
            }

            foreach (PublicRoom Room in PublicRooms.Values.ToList())
            {
                if (Room.Category == 0)
                    Room.Serialize(Message);
            }

            return Message;
        }

        internal ServerMessage SerializeOwnRooms(HabboData Habbo)
        {
            var Rooms = DuckEnvironment.RoomManager.GetOwnRooms(Habbo.Username);

            ServerMessage Message = new ServerMessage(451);
            Message.AppendInt32(5);
            Message.AppendStringWithBreak("");
            Message.AppendInt32(Rooms.Count);

            foreach (Room Room in Rooms)
            {
                Room.SerializeNavigator(Message,true);
            }

            return Message;
        }

        internal ServerMessage SerializeFavoriteRooms(HabboData Habbo)
        {
            var Rooms = DuckEnvironment.RoomManager.GetFavoriteRooms(Habbo);

            ServerMessage Message = new ServerMessage(451);
            Message.AppendInt32(6);
            Message.AppendStringWithBreak("");
            Message.AppendInt32(Rooms.Count);

            foreach (Room Room in Rooms)
            {
                Room.SerializeNavigator(Message,false);
            }

            return Message;
        }

        internal ServerMessage SerializeLastVisited(HabboData Habbo)
        {
            var Rooms = DuckEnvironment.RoomManager.GetLastVisted(Habbo);

            ServerMessage Message = new ServerMessage(451);
            Message.AppendInt32(7);
            Message.AppendStringWithBreak("");
            Message.AppendInt32(Rooms.Count);

            foreach (Room Room in Rooms)
            {
                Room.SerializeNavigator(Message,false);
            }

            return Message;
        }

        internal ServerMessage SerializePrivateCats()
        {
            ServerMessage Message = new ServerMessage(221);
            Message.AppendInt32(PrivateCats.Count);

            int i = 0;

            foreach (PrivateCat Cat in PrivateCats.Values.ToList())
            {
                if (i > 0)
                {
                    Message.AppendBoolean(true);
                }

                Message.AppendInt32(Cat.Category);
                Message.AppendStringWithBreak(Cat.Name);

                i++;
            }

            Message.AppendStringWithBreak("");

            return Message;
        }

        internal ServerMessage SerializeWhereFriendsAre(HabboData Habbo)
        {
            var Rooms = DuckEnvironment.RoomManager.GetWhereFriendsAre(Habbo);

            ServerMessage Message = new ServerMessage(451);
            Message.AppendInt32(4);
            Message.AppendStringWithBreak("");
            Message.AppendInt32(Rooms.Count);

            foreach (Room Room in Rooms)
            {
                Room.SerializeNavigator(Message,false);
            }

            return Message;
        }

        internal ServerMessage SearchRooms(string Q)
        {
            var Rooms = new List<Room>();

            if (Q.Length > 3)
            {
                Rooms = DuckEnvironment.RoomManager.SeachRooms(Q);
            }

            ServerMessage Message = new ServerMessage(451);
            Message.AppendInt32(8);
            Message.AppendStringWithBreak(Q);
            Message.AppendInt32(Rooms.Count);

            foreach (Room Room in Rooms)
            {
                Room.SerializeNavigator(Message, false);

                if (Room.HasEvent)
                {
                    Room.SerializeNavigator(Message, true);
                }
            }

            return Message;
        }

        internal ServerMessage SerializeEvents(int Category)
        {
            var Rooms = DuckEnvironment.RoomManager.GetEvents(Category);

            ServerMessage Message = new ServerMessage(451);
            Message.AppendInt32(12);
            Message.AppendStringWithBreak(Category.ToString());
            Message.AppendInt32(Rooms.Count);

            foreach (Room Room in Rooms)
            {
                Room.SerializeNavigator(Message, true);
            }

            return Message;
        }

        internal ServerMessage SerializePopulairTags()
        {
            var Tags = DuckEnvironment.RoomManager.GetPopulairTags();

            ServerMessage Message = new ServerMessage(452);
            Message.AppendInt32(Tags.Count);

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

            return Message;
        }

        internal ServerMessage SerializePrivRooms(int Category)
        {
            var List = new List<Room>();

            foreach (Room Room in DuckEnvironment.RoomManager.GetRooms())
            {
                if (Room.Category == Category || Category == -1)
                {
                    List.Add(Room);
                }
            }

            ServerMessage Message = new ServerMessage(451);
            Message.AppendBoolean(true);
            Message.AppendStringWithBreak(Category.ToString());
            Message.AppendInt32(List.Count);

            foreach (Room Room in List)
            {
                Room.SerializeNavigator(Message, false);
            }

            return Message;
        }

        internal ServerMessage SerializeHighestScore()
        {
            //431
            return null;
        }
    }
}