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

using System.Net;
using System.Net.Sockets;
using System.Threading.Tasks;

using Blizzard.HabboHotel.Users;

namespace Blizzard.Connections
{
    class UserConnection
    {
        public GameClientConnection GetClient;

        public int ConnectionID;
        public Socket ConnectionSock;
        private Task Thread;
        private AsyncCallback Callback;
        private byte[] dataBuffer = new byte[200];

        public UserConnection(int ID, Socket Sock)
        {
            this.ConnectionID = ID;
            this.ConnectionSock = Sock;

            Callback = new AsyncCallback(RequestData);

            Thread = new Task(StartListenAndResponse);
            Thread.Start();
        }

        private void StartListenAndResponse()
        {
            WaitForData();
        }

        private void WaitForData()
        {
            if (ConnectionSock == null)
                return;

            try
            {
                if (ConnectionSock.Connected)
                    this.ConnectionSock.BeginReceive(dataBuffer, 0, dataBuffer.Length, SocketFlags.None, Callback, null);
            }
            catch
            {
                OnDisconnect();
            }
        }

        public void OnDisconnect()
        {
            if (ConnectionSock == null)
                return;

            if (ConnectionSock.Connected)
                @ConnectionSock.Close();
            if (GetClient != null)
            {
                //?
            }
            ConnectionSock.Dispose();
            ConnectionSock = null;
            try { Thread.Dispose(); }
            catch { }
        }

        private void RequestData(IAsyncResult iAr)
        {
            try
            {
                int Bytes = ConnectionSock.EndReceive(iAr);

                if (Bytes == 0)
                {
                    OnDisconnect();
                    return;
                }

                string ReceiveData = System.Text.Encoding.Default.GetString(dataBuffer, 0, Bytes);

                if (ReceiveData.StartsWith("<policy-file-request/>"))
                {
                    SenddData("<?xml version=\"1.0\"?>" + "\r\n" + "<!DOCTYPE cross-domain-policy SYSTEM \"/xml/dtds/cross-domain-policy.dtd\">" + "\r\n" + "<cross-domain-policy>" + "\r\n" + "   <allow-access-from domain=\"*\" to-ports=\"1-65535\" />" + "\r\n" + "</cross-domain-policy>");
                }
                else
                {
                    if (GetClient == null)
                        GetClient = new GameClientConnection(ConnectionID);
                    GetClient.HandleData(ReceiveData);
                }
            }
            catch
            {
                OnDisconnect();
            }
            finally
            {
                Thread = new Task(StartListenAndResponse);
                Thread.Start();
            }
        }
        public void SenddData(string Data)
        {
            if (ConnectionSock == null)
                return;

            Data += Convert.ToChar(0);
            byte[] dataBytes = System.Text.Encoding.Default.GetBytes(Data);
            ConnectionSock.Send(dataBytes);
        }

        public void SendPacket(string Data)
        {
            if (ConnectionSock == null)
                return;

            Data += Convert.ToChar(1);
            byte[] dataBytes = System.Text.Encoding.Default.GetBytes(Data);
            ConnectionSock.Send(dataBytes);
        }

        public void SendPackets(string Data)
        {
            if (ConnectionSock == null)
                return;

            byte[] dataBytes = System.Text.Encoding.Default.GetBytes(Data);
            ConnectionSock.Send(dataBytes);
        }
    }
    class GameClientConnection
    {
        public int ID = 0;
        public ClientMessage Request;
        public RequestMessages Requests;
        public Habbo User;

        public UserConnection GetConnection()
        {
            return BlizzardSystem.Net.UsersConnections[ID];
        }

        public void SendPacket(string Message)
        {
            GetConnection().SendPacket(Message);
        }

        public void SendPackets(string Message)
        {
            GetConnection().SendPackets(Message);
        }

        public GameClientConnection(int ID)
        {
            this.ID = ID;
            Requests = new RequestMessages(ID);
            Habbo User = new Habbo(GetConnection(), ID);
            Requests.GetClasses(User);
        }

        public void HandleData(string Data)
        {
            StringBuilder Buffer = new StringBuilder(Data);

            while (Buffer.Length > 0)
            {
                int v = HabboEncode.decodeB64(Buffer.ToString().Substring(1, 2));
                Requests.ProcessPackets(Buffer.ToString().Substring(3, v));
                Buffer.Remove(0, 3 + v);
            }
        }
    }
}