using System;
using System.Collections.Generic;
using System.Text;
using MySql.Data.MySqlClient;

namespace ArcServer
{
    public class PacketHandler : mPacketHandler
    {
        public PacketHandler()
            : base()
        {
            AddHandlers();
            Log.Write("{0} Headers successfully initialized.", msgType.Information, Handlers.Count - 1);
        }

        /// <summary>
        /// Add handlers here, you can make one for each 'sort', as long as you use iPacketHandler as 'interface'
        /// </summary>
        void AddHandlers()
        {
            AddHandler((short)Framework.ClientOps.S_MSG_SEND_AUTH, ReceiveAuthentication);
            AddHandler((short)Framework.ClientOps.S_MSG_SEND_REQUEST_CHANNEL_LIST, ReceiveChannelListRequest);
            AddHandler((short)Framework.ClientOps.S_MSG_SEND_REQUEST_CHANNEL_CREATION, ProcessChannelCreationRequest);

        }
        void ReceiveAuthentication(Packet pPacket, Client pClient)
        {
            Packet mSendAuthPacket = new Packet((short)Framework.ServerOps.S_MSG_SEND_AUTH_RESULT);
            string mUsername = pPacket.ReadStringL();
            string mPassword = pPacket.ReadStringL();
            using (MySqlDataReader mReader = DatabaseManager.Query("SELECT password, salt, banned FROM account WHERE username ='" + mUsername + "'"))
            {
                if (mReader.HasRows)
                {
                    mReader.Read();
                    string _Password = (string)mReader["password"],
                           _PasswordSalt = (string)mReader["salt"];
                    byte banned = mReader.GetByte("banned");
                    if (banned != 0)
                    {
                        mSendAuthPacket.WriteByte((byte)Framework.ELoginState.Blocked);
                        mSendAuthPacket.WriteByte(banned);
                    }
                    else if (mPassword != _Password)
                    {
                        mSendAuthPacket.WriteByte((byte)Framework.ELoginState.IncorrectPassword);
                    }
                    else
                    {
                        mSendAuthPacket.WriteByte((byte)Framework.ELoginState.LoginStateOK);
                    }
                }
                else
                {
                    mSendAuthPacket.WriteByte((byte)Framework.ELoginState.IncorrectUsername);
                }
                pClient.SendPacket(mSendAuthPacket);
            }
        }
        void ReceiveChannelListRequest(Packet pPacket, Client pClient)
        {
            byte mCheck = pPacket.ReadByte();
            if (mCheck == 1)
            {
                Packet lSendChannelListPacket = new Packet((short)Framework.ServerOps.S_MSG_SEND_CHANNEL_LIST_RESULT);
                lSendChannelListPacket.WriteSByte(Convert.ToSByte(Program.lChannelHandler.mChannels.Count));
                foreach (Channel chan in Program.lChannelHandler.mChannels)
                {
                    lSendChannelListPacket.WriteStringL(chan.mChannelName);
                    lSendChannelListPacket.WriteStringL(chan.mChannelDescription);
                    lSendChannelListPacket.WriteUShort(Convert.ToUInt16(chan.mUsers.Count));
                }
                pClient.SendPacket(lSendChannelListPacket);
            }
        }
        void JoinChannelRequest(Packet pPacket, Client pClient)
        {
            string mChannelName = pPacket.ReadStringL();
            Channel channel = Program.lChannelHandler.mChannels.Find(c => c.mChannelName.ToLower() == mChannelName.ToLower());
            if (channel == null) return;



            Packet lSendChannelListPacket = new Packet((short)Framework.ServerOps.S_MSG_SEND_CHANNEL_LIST_RESULT);
            lSendChannelListPacket.WriteSByte(Convert.ToSByte(Program.lChannelHandler.mChannels.Count));
            lSendChannelListPacket.WriteStringL(channel.mChannelName);
            lSendChannelListPacket.WriteStringL(channel.mChannelDescription);
            lSendChannelListPacket.WriteUShort(Convert.ToUInt16(channel.mUsers.Count));
            foreach (User user in channel.mUsers)
            {
                lSendChannelListPacket.WriteStringL(user.mUsername);
            }
            pClient.SendPacket(lSendChannelListPacket);
        }
        void ProcessChannelCreationRequest(Packet packet, Client client)
        {
            string channelName = packet.ReadStringL();
        }
    }


    public delegate void HandlePacket(Packet packet, Client client);
    /// <summary>
    /// Base packet handler, don't touch
    /// </summary>
    public class BasePacketHandler
    {
        /// <summary>
        /// The OpCode of the packet handler.
        /// </summary>
        public short OpCode { get; private set; }
        /// <summary>
        /// The method executed when the opcode is received.
        /// </summary>
        public HandlePacket OnPacket { get; private set; }

        public BasePacketHandler(short opCode, HandlePacket onReceive)
        {
            this.OpCode = opCode;
            this.OnPacket = onReceive;
        }
    }

    public class mPacketHandler
    {
        public Dictionary<short, BasePacketHandler> Handlers;
        /// <summary>
        /// A constructor for the BasePacketHandler.
        /// </summary>
        /// <param name="player">Client to handle packets from</param>
        /// <param name="Reader">PacketReader to read the packet from.</param>
        public mPacketHandler()
        {
            Handlers = new Dictionary<short, BasePacketHandler>();
            Handlers.Add(short.MaxValue, new BasePacketHandler(short.MaxValue, new HandlePacket(NoOpHandler)));
        }
        /// <summary>
        /// Get a handler by opcode.
        /// </summary>
        /// <param name="opCode">RecvOpCode to get his handler</param>
        /// <returns>A packet handler.</returns>
        public BasePacketHandler GetHandler(short opCode)
        {
            try
            {
                return Handlers[opCode];
            }
            catch
            {
                return Handlers[short.MaxValue];
            }
        }
        /// <summary>
        /// Adds an handler to the handlers dictioanry the easy way.
        /// </summary>
        /// <param name="opCode">op code</param>
        /// <param name="handler">OnPacketReceive method</param>
        public void AddHandler(short opCode, HandlePacket handler)
        {
            Handlers.Add(opCode, new BasePacketHandler(opCode, handler));
        }
        /// <summary>
        /// Handler activated when the received opcode is unknown.
        /// </summary>
        /// <param name="player"></param>
        /// <param name="packet"></param>
        public void NoOpHandler(Packet packet, Client client)
        {
            Log.Write("Received unhandled Packet: " + packet.Opcode.ToString("X2"), msgType.Exception);
        }
    }
}