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

namespace DuckEmulator.HabboHotel.Outside.Habbos.HabStructure
{
    class Messenger
    {
        private HabboData Habbo;

        internal SecurityDictionary<uint, Buddy> Buddies;
        internal Dictionary<uint, Request> Requests;

        private Buddy OwnBuddyDetails;

        internal Messenger(HabboData Data)
        {
            this.Habbo = Data;

            this.OwnBuddyDetails = new Buddy(Habbo.Id, Habbo.Username, "", Habbo.Motto);

            this.LoadBuddies();
            this.LoadRequests();

            this.OnLogin(true);
        }

        internal void LoadBuddies()
        {
            Buddies = new SecurityDictionary<uint, Buddy>();
            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT friend_id FROM user_friends WHERE user_id = '" + Habbo.Id + "'");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                DataRow UserRow = null;

                using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
                {
                    Adapter.setQuery("SELECT id,username,last_login,motto FROM users WHERE id = '" + Row["friend_id"] + "' LIMIT 1");
                    UserRow = Adapter.getRow();
                }

                if (UserRow == null) continue;

                Buddies.Add((uint)UserRow["id"], new Buddy((uint)UserRow["id"], UserRow["username"].ToString(), UserRow["last_login"].ToString(), UserRow["motto"].ToString()));
            }
        }

        internal void LoadRequests()
        {
            Requests = new Dictionary<uint, Request>();
            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT from_id FROM user_friendrequests WHERE to_id = '" + Habbo.Id + "'");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                DataRow UserRow = null;

                using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
                {
                    Adapter.setQuery("SELECT username,look FROM users WHERE id = '" + Row["from_id"] + "' LIMIT 1");
                    UserRow = Adapter.getRow();
                }

                if (UserRow == null) continue;

                Requests.Add((uint)Row["from_id"], new Request((uint)Row["from_id"], UserRow["username"].ToString(), UserRow["look"].ToString()));
            }
        }

        internal ServerMessage SerializeBuddies()
        {
            ServerMessage Message = new ServerMessage(12);

            Message.AppendInt32(300);
            Message.AppendInt32(300);
            Message.AppendInt32(800);
            Message.AppendInt32(1100);
            Message.AppendBoolean(false);

            Message.AppendInt32(Buddies.Count);

            foreach (Buddy Buddy in Buddies.Values.ToList())
            {
                Buddy.SerializeFriend(Message);
            }

            Message.AppendInt32(100); // maxfriends :D

            return Message;
        }

        internal ServerMessage SerializeRequests()
        {
            ServerMessage Message = new ServerMessage(314);

            Message.AppendBoolean(true);
            Message.AppendInt32(Requests.Count);

            foreach (Request Request in Requests.Values.ToList())
            {
                Request.Serialize(Message);
            }

            return Message;
        }

        internal void OnLogin(bool Login)
        {
            foreach (Buddy Buddy in Buddies.Values.ToList())
            {
                if (Buddy.Online)
                {
                    ServerMessage Message = new ServerMessage(13);

                    OwnBuddyDetails.SerializeUpdates(Message);

                    Buddy.SendResponse(Message);
                }
            }
        }

        internal void BroadcastAchievement(string Data1, bool Achievement)
        {
            foreach (Buddy Buddy in Buddies.Values.ToList())
            {
                if (Buddy.Online)
                {
                    ServerMessage Message = new ServerMessage(833);

                    Message.AppendStringWithBreak(Habbo.Id.ToString());
                    Message.AppendBoolean(Achievement);
                    Message.AppendStringWithBreak(Data1);

                    Buddy.SendResponse(Message);
                }
            }
        }

        internal void UpdateStatus()
        {
            foreach (Buddy Buddy in Buddies.Values.ToList())
            {
                if (Buddy.Online)
                {
                    ServerMessage Message = new ServerMessage(13);

                    OwnBuddyDetails.SerializeUpdates(Message);

                    Buddy.SendResponse(Message);
                }
            }
        }

        internal ServerMessage Search(string Name)
        {
            DataTable Data = null;
            ServerMessage Message = new ServerMessage(435);

            var NotFriends = new List<Buddy>();
            var Friends = new List<Buddy>();

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT id,username,last_login,look,motto FROM users WHERE username LIKE '%" + Name.ToLower() + "%' ");
                Data = Adapter.getTable();
            }

            foreach (DataRow Row in Data.Rows)
            {
                if (Buddies.ContainsKey((uint)Row["id"]))
                {
                    Friends.Add(GetBuddy((uint)Row["id"]));
                }
                else
                {
                    Buddy Buddy = new Buddy((uint)Row["id"], Row["username"].ToString(), Row["last_login"].ToString(), Row["motto"].ToString());
                    Buddy.Motto = Row["motto"].ToString();

                    NotFriends.Add(Buddy);
                }
            }

            Message.AppendInt32(Friends.Count);

            foreach (Buddy Buddy in Friends.ToList())
            {
                Buddy.SerializeSearch(Message);
            }

            Message.AppendInt32(NotFriends.Count);

            foreach (Buddy Buddy in NotFriends.ToList())
            {
                Buddy.SerializeSearch(Message);
            }

            return Message;
        }

        internal ServerMessage DeletBuddy(uint ID)
        {
            if (!HasBuddy(ID)) return null;

            if (GetBuddy(ID).Online)
            {
                GetBuddy(ID).GetClient().GetHabbo().GetMessenger().Buddies.Remove(Habbo.Id);

                ServerMessage ToMessage = new ServerMessage(13);
                ToMessage.AppendBoolean(false);
                ToMessage.AppendBoolean(true);
                ToMessage.AppendInt32(-1);
                ToMessage.AppendUInt(Habbo.Id);

                GetBuddy(ID).SendResponse(ToMessage);
            }

            Buddies.Remove(ID);

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.runFastQuery("DELETE FROM user_friends WHERE user_id = '" + Habbo.Id + "' AND friend_id = '" + ID + "' LIMIT 1");
                Adapter.runFastQuery("DELETE FROM user_friends WHERE user_id = '" + ID + "' AND friend_id = '" + Habbo.Id + "' LIMIT 1");
            }

            ServerMessage Message = new ServerMessage(13);
            Message.AppendBoolean(false);
            Message.AppendBoolean(true);
            Message.AppendInt32(-1);
            Message.AppendUInt(ID);
            return Message;
        }

        internal void RequestUser(string Username)
        {
            uint Id = DuckEnvironment.ClientManager.GetIdByUsername(Username);

            if (Id <= 0)
            {
                return;
            }

            if (HasRequest(Id))
            {
                return;
            }

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.runFastQuery("INSERT INTO user_friendrequests (from_id,to_id) VALUES ('" + Habbo.Id + "','" + Id + "')");
            }

            if (DuckEnvironment.ClientManager.GetClientByHabboId(Id) != null)
            {
                DuckEnvironment.ClientManager.GetClientByHabboId(Id).GetHabbo().GetMessenger().LoadRequests();
                DuckEnvironment.ClientManager.GetClientByHabboId(Id).GetHabbo().GetMessenger().InstantRequest(Habbo.Id);
            }
        }

        internal void AcceptUser(uint ID)
        {
            try
            {
                if (!HasRequest(ID)) return;

                Requests.Remove(ID);

                using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
                {
                    Adapter.runFastQuery("DELETE FROM user_friendrequests WHERE from_id = '" + ID + "' AND to_id = '" + Habbo.Id + "' LIMIT 1");
                    Adapter.runFastQuery("INSERT INTO user_friends (user_id,friend_id) VALUES ('" + Habbo.Id + "','" + ID + "')");
                    Adapter.runFastQuery("INSERT INTO user_friends (user_id,friend_id) VALUES ('" + ID + "','" + Habbo.Id + "')");
                }

                LoadBuddies();

                if (!HasBuddy(ID)) return;

                ServerMessage Message = new ServerMessage(13);
                GetBuddy(ID).SerializeUpdates(Message);
                Habbo.SendResponse(Message);

                if (GetBuddy(ID).Online)
                {
                    GetBuddy(ID).GetClient().GetHabbo().GetMessenger().LoadBuddies();

                    ServerMessage ToMessage = new ServerMessage(13);

                    GetBuddy(ID).GetClient().GetHabbo().GetMessenger().GetBuddy(Habbo.Id).SerializeUpdates(ToMessage);
                    GetBuddy(ID).SendResponse(ToMessage);
                }
            }
            catch (Exception e)
            {
                DuckEnvironment.WriteLine(e.ToString());
            }
        }

        internal void FollowBuddy(uint Id)
        {
            if (!HasBuddy(Id)) return;
            if (!GetBuddy(Id).InRoom) return;

            Room Room = DuckEnvironment.RoomManager.GetRoom(GetBuddy(Id).GetClient().GetHabbo().CurrentRoomId);
            if (Room == null) return;

            if (Habbo.CurrentRoomId == Room.Id) return;

            ServerMessage Message = new ServerMessage(286);
            Message.AppendBoolean(false);
            Message.AppendUInt(Room.Id);

            Habbo.GetConnection().SendResponse(Message);

            Habbo.GetConnection().GetClient().GetMessageHandler().PrepareRoom(Room, "");
        }

        internal void InstantRequest(uint Id)
        {
            if (!HasRequest(Id))
            {
                return;
            }

            Request Req = GetRequest(Id); if (Req == null) return;
            ServerMessage Message = new ServerMessage(132);
            Req.Serialize(Message);
            Habbo.SendResponse(Message);
        }

        internal void DenyUser(uint Id)
        {
            if (!HasRequest(Id)) return;

            Requests.Remove(Id);

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.runFastQuery("DELETE FROM user_friendrequests WHERE from_id = '" + Id + "' AND to_id = '" + Habbo.Id + "' LIMIT 1");
            }
        }

        internal void ChatTo(uint BuddyId, string Message)
        {
            if (!HasBuddy(BuddyId) || Message == "")
            {
                return;
            }

            GetBuddy(BuddyId).SendChatMessage(Message, Habbo.Id);
        }

        internal void SendFollow(uint BuddyId, string Message)
        {
            if (!HasBuddy(BuddyId) || Message == "")
            {
                return;
            }

            GetBuddy(BuddyId).SendFollowMessage(Message, Habbo.Id);
        }

        internal Buddy GetBuddy(uint ID)
        {
            try { return Buddies[ID]; }
            catch { return null; }
        }

        internal Request GetRequest(uint ID)
        {
            try { return Requests[ID]; }
            catch { return null; }
        }

        internal Boolean HasBuddy(uint ID)
        {
            return Buddies.ContainsKey(ID);
        }

        internal Boolean HasRequest(uint ID)
        {
            return Requests.ContainsKey(ID);
        }
    }

    class Buddy
    {
        private readonly uint HabboId;
        private readonly string Username;
        private string iMotto;
        private string LastLoggedIn;

        internal Boolean Online
        {
            get
            {
                return (GetClient() != null);
            }
        }

        internal string Look
        {
            get
            {
                return ((Online) ? GetClient().GetHabbo().Look : "");
            }
        }

        internal string Motto
        {
            get
            {
                return ((!Online) ? iMotto : GetClient().GetHabbo().Motto);
            }
            set { iMotto = value; }
        }

        internal Boolean InRoom
        {
            get
            {
                return ((!Online) ? false : true);
            }
        }

        internal Buddy(uint HabboId, string Username, string LastLoggedin, string Motto)
        {
            this.HabboId = HabboId;
            this.Username = Username;
            this.LastLoggedIn = LastLoggedin;
            this.Motto = Motto;
        }

        internal void SerializeFriend(ServerMessage Message)
        {
            Message.AppendUInt(GetHabboId());
            Message.AppendStringWithBreak(GetUsername());
            Message.AppendBoolean(true);
            Message.AppendBoolean(Online);
            Message.AppendBoolean(InRoom);
            Message.AppendStringWithBreak(Look);
            Message.AppendBoolean(false);
            Message.AppendStringWithBreak("");
            Message.AppendStringWithBreak(GetLast());
            Message.AppendStringWithBreak("");
            Message.AppendStringWithBreak("");
        }

        internal void SerializeUpdates(ServerMessage Message)
        {
            Message.AppendBoolean(false);
            Message.AppendBoolean(true);
            Message.AppendBoolean(false);

            Message.AppendUInt(GetHabboId());
            Message.AppendStringWithBreak(GetUsername());
            Message.AppendBoolean(true);
            Message.AppendBoolean(Online);
            Message.AppendBoolean(InRoom);
            Message.AppendStringWithBreak(Look);
            Message.AppendBoolean(false);
            Message.AppendStringWithBreak(GetLast());

            Message.AppendStringWithBreak("");
            Message.AppendStringWithBreak("");
        }

        internal void SerializeSearch(ServerMessage Message)
        {
            Message.AppendUInt(GetHabboId());
            Message.AppendStringWithBreak(GetUsername());
            Message.AppendStringWithBreak(Motto);
            Message.AppendBoolean(InRoom);
            Message.AppendBoolean(Online);
            Message.AppendStringWithBreak("");
            Message.AppendBoolean(false);
            Message.AppendStringWithBreak(Look);
            Message.AppendStringWithBreak("");
            Message.AppendStringWithBreak("");
        }

        internal void SendChatMessage(string MessageTXT, uint From)
        {
            if (!Online)
            {
                return;
            }

            ServerMessage Message = new ServerMessage(134);
            Message.AppendUInt(From);
            Message.AppendStringWithBreak(MessageTXT);

            SendResponse(Message);
        }

        internal void SendFollowMessage(string MessageTXT, uint From)
        {
            if (!Online)
            {
                return;
            }

            ServerMessage Message = new ServerMessage(135);
            Message.AppendUInt(From);
            Message.AppendStringWithBreak(MessageTXT);

            SendResponse(Message);
        }

        internal void SendResponse(ServerMessage Message)
        {
            if (!Online) return;

            if (GetClient().GetConnection() == null) return;

            GetClient().GetConnection().SendResponse(Message);
        }

        internal Client GetClient()
        {
            return DuckEnvironment.ClientManager.GetClientByHabboId(GetHabboId());
        }

        internal string GetUsername()
        {
            return Username;
        }

        internal uint GetHabboId()
        {
            return HabboId;
        }

        internal string GetLast()
        {
            return ((!Online) ? LastLoggedIn : "");
        }
    }

    class Request
    {
        internal readonly uint HabboId;
        internal readonly string Username;
        internal string Look;

        internal Request(uint HabboId,string Username,string Look)
        {
            this.HabboId = HabboId;
            this.Username = Username;
            this.Look = Look;
        }

        internal void Serialize(ServerMessage Message)
        {
            Message.AppendUInt(HabboId);
            Message.AppendStringWithBreak(Username);
            Message.AppendStringWithBreak(Look);
        }
    }
}