using System;
using System.Linq;
using System.Data;
using System.Text;
using System.Data.SqlClient;

using Filter.Networking.Instances;
using Filter.Networking.Manager;
using Filter.Networking.RemoteConsole;

using Filter.Utilities;

namespace Filter.Handlers.Manager
{
    internal class Manager8Handle
    {
        [ManagerPacketHandler(Manager8TypeClient.WhisperMessage)]
        public static void HandleWhisperMessage(ManagerClient ClientSocket, Packet ClientPacket)
        {
            if (ClientSocket.IsConnected != 0)
            {
                ClientPacket.Dispose();

                return;
            }
            else
            {
                String Receiver;
                String Message = String.Empty;

                Char InvalidSymbol;
                
                ManagerClient MClient;

                if (!ClientPacket.ReadString(out Receiver, 16)) { }
                else if (!ClientPacket.ReadString(out Message)) { }
                else if (Injection.ContainsInvalidSymbol(Message, out InvalidSymbol))
                {
                    if (Program.Config.BinType == MessageType.Whisper) { Echo.SendWhisper(ClientSocket, Program.Config.BinMessage); }
                    else { Echo.SendWorldMessage(ClientSocket, Program.Config.BinMessage); }
                }
                else if (Receiver.ToLower() == Program.Config.BotName.ToLower() && Message.StartsWith("&")) { Command.HandleCommand(ClientSocket, ClientPacket, Message); }
                else if (Program.Config.RemoteEnabled && ((MClient = Program.ManagerLoggedIn.Values.Where(Character => Character.CharacterName.ToLower() == Receiver.ToLower()).FirstOrDefault()) == null))
                {
                    RemoteClient RClient;

                    if ((RClient = Program.RemoteLoggedIn.Where(Character => Character.CharacterName.ToLower() == Receiver.ToLower()).FirstOrDefault()) != null)
                    {
                        RClient.Send(Encoding.ASCII.GetBytes(String.Format("Whisper#{0}#{1}", ClientSocket.CharacterName, Message)));

                        Packet RemakeClientPacket = new Packet(Manager8TypeServer.WhisperMessageTo);
                        RemakeClientPacket.WriteString(Receiver, 16);
                        RemakeClientPacket.WriteString(Message, true);

                        ClientSocket.SendPacket(RemakeClientPacket);
                    }
                    else { Echo.SendWhisper(ClientSocket, String.Format("{0} is not online.", Receiver)); }
                }
                else
                {
                    if (Program.Config.WhisperProtect)
                    {
                        Message = Message.Replace('?', '?');

                        Packet RemakeClientPacket = new Packet(Manager8TypeClient.WhisperMessage);
                        RemakeClientPacket.WriteString(Receiver, 16);
                        RemakeClientPacket.WriteString(Message, true);

                        ClientSocket.Server.SendPacket(RemakeClientPacket);
                    }
                    else { ClientSocket.Server.SendPacket(ClientPacket); }
                }

                if (Program.Config.WhisperLog)
                {
                    using (var Connection = new SqlConnection())
                    {
                        Connection.ConnectionString = Program.ConnectionBuilder.ConnectionString;

                        try { Connection.Open(); }
                        catch { }

                        if (Connection.State == ConnectionState.Open)
                        {
                            using (var Command = Connection.CreateCommand())
                            {
                                Command.CommandText = String.Format("INSERT INTO {0}..tWhisper (sSender, sMessage) VALUES ('{1}', '{2}')", Program.Config.SQLChatLogs, ClientSocket.CharacterName, Message);

                                try { Command.ExecuteNonQuery(); }
                                catch { }
                            }
                        }

                        Connection.Close();
                    }
                }
            }

            ClientPacket.Dispose();
        }

        [ManagerPacketHandler(Manager8TypeClient.PartyMessage)]
        public static void HandlePartyMessage(ManagerClient ClientSocket, Packet ClientPacket)
        {
            if (ClientSocket.IsConnected != 0)
            {
                ClientPacket.Dispose();

                return;
            }
            else
            {
                if (Program.Config.PartyProtect)
                {
                    String Message;

                    Char InvalidSymbol;

                    if (!ClientPacket.ReadString(out Message)) { }
                    else if (Injection.ContainsInvalidSymbol(Message, out InvalidSymbol)) { Echo.SendWorldMessage(ClientSocket, "Please dont bin :'("); }
                    else
                    {
                        Message = Message.Replace('?', '?');

                        Packet RemakeClientPacket = new Packet(Manager8TypeClient.PartyMessage);
                        RemakeClientPacket.WriteString(Message, true);

                        ClientSocket.Server.SendPacket(RemakeClientPacket);

                        if (Program.Config.PartyLog)
                        {
                            using (var Connection = new SqlConnection())
                            {
                                Connection.ConnectionString = Program.ConnectionBuilder.ConnectionString;

                                try { Connection.Open(); }
                                catch { }

                                if (Connection.State == ConnectionState.Open)
                                {
                                    using (var Command = Connection.CreateCommand())
                                    {
                                        Command.CommandText = String.Format("INSERT INTO {0}..tParty (sSender, sMessage) VALUES ('{1}', '{2}')", Program.Config.SQLChatLogs, ClientSocket.CharacterName, Message);

                                        try { Command.ExecuteNonQuery(); }
                                        catch { }
                                    }
                                }

                                Connection.Close();
                            }
                        }
                    }
                }
                else { ClientSocket.Server.SendPacket(ClientPacket); }
            }

            ClientPacket.Dispose();
        }
    }
}