using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;

using Blizzard.HabboHotel.Users;

namespace Blizzard.Connections
{
    public class Game
    {
        private Socket ClientSock;
        private int GameID;
        private Habbo NewHabbo = null;
        private AsyncCallback CallBack;
        private byte[] dataBuffer = new byte[1024];
        private Thread sTheard;
        private RequestMessages Requests;
        internal Game(Socket NewSocket, int ClientID)
        {
            try
            {
                this.ClientSock = NewSocket;
                this.GameID = ClientID;
                this.NewHabbo = new Habbo(this, ClientID);
                this.CallBack = new AsyncCallback(GetResponse);
                this.Requests = new RequestMessages(this);
                Requests.GetClasses(NewHabbo);
                if (StaticGame.TheardSystem.ContainsKey(ClientID))
                {
                    Thread t = StaticGame.TheardSystem[NewHabbo.GameId];
                    t.Abort();
                    t = new Thread(new ThreadStart(WaitForaResponse));
                    t.Start();
                }
                else
                {
                    Thread t = new Thread(new ThreadStart(WaitForaResponse));
                    StaticGame.TheardSystem.Add(NewHabbo.GameId, t);
                    t.Start();
                }
            }
            catch (Exception e) { BlizzardSystem.WriteLine(e.ToString()); }
        }

        private void WaitForDataTask()
        {
            this.WaitForaResponse();
        }

        private void WaitForaResponse()
        {
            try
            {
                if (NewHabbo == null)
                    return;
                this.CallBack = new AsyncCallback(GetResponse);
                ClientSock.BeginReceive(dataBuffer, 0, dataBuffer.Length, SocketFlags.None, CallBack, null); // Linea 44
            }
            catch (Exception e)
            {
                if (NewHabbo == null)
                    return;
                NewHabbo.DisconnectMe();
               // BlizzardSystem.WriteLine("Error on packet system: " + e.Message);
            }
        }

        internal void Disconnect()
        {
            try
            {
                Thread t = StaticGame.TheardSystem[NewHabbo.GameId];
                NewHabbo = null;
                try
                {
                    ClientSock.Dispose();
                    ClientSock.Close();
                }
                catch { }
                try { t.Abort(); }
                catch { }
            }
            catch { }
        }

        private void GetResponse(IAsyncResult Async)
        {
            try
            {
                if (NewHabbo == null)
                    return;

                Thread t = StaticGame.TheardSystem[NewHabbo.GameId];
                int bytesBuffer = ClientSock.EndReceive(Async);
                StringBuilder Data = new StringBuilder();
                Data.Append(Encoding.Default.GetString(dataBuffer, 0, bytesBuffer));
                if (Data.Length <= 0)
                {
                   // Console.WriteLine("Invalid Packet!");
                    return;
                }

                // Initial Packet
                if (Data.ToString() == "<policy-file-request/>" + Convert.ToChar(0))
                {
                    SendData("<?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>");
                    NewHabbo = null;
                    StaticGame.TheardSystem.Remove(GameID);
                    t.Abort();
                    return;
                }

                // Process All packets
                while (Data.Length > 1)
                {
                    int v = HabboEncode.decodeB64(Data.ToString().Substring(1, 2));
                    Requests.ProcessPackets(Data.ToString().Substring(3, v));
                    Data.Remove(0, 3 + v);
                }
            }
            catch (Exception e)
            {
                if (NewHabbo == null)
                    return;
                //BlizzardSystem.WriteLine("Packetlog fail: " + e.ToString());
                NewHabbo.DisconnectMe();
            }
            finally
            {
                try
                {
                    if (NewHabbo != null)
                    {
                        if (StaticGame.TheardSystem.ContainsKey(NewHabbo.GameId))
                        {
                            Thread t = StaticGame.TheardSystem[NewHabbo.GameId];
                            Thread tu = new Thread(new ThreadStart(WaitForaResponse));
                            StaticGame.TheardSystem.Remove(NewHabbo.GameId);
                            tu.Start();
                            StaticGame.TheardSystem.Add(NewHabbo.GameId, tu);
                            t.Abort();
                        }
                        else
                        {
                            // Nothing?
                        }
                    }
                }
                catch (Exception e)
                {
                    BlizzardSystem.WriteLine("multi-threading system fail!!: " + e.ToString());
                    NewHabbo.DisconnectMe();
                }
            }

        }

        internal void SendData(string Data)
        {
            try
            {
                Data = Data + Convert.ToChar(0);
                byte[] dataBytes = Encoding.Default.GetBytes(Data);
                ClientSock.BeginSend(dataBytes, 0, dataBytes.Length, 0, new AsyncCallback(sentData), null);
            }
            catch (Exception e)
            {
                BlizzardSystem.WriteLine(e.ToString());
            }
        }

        internal void SendPacket(string Data)
        {
            try
            {
                if (Data.Length > 0)
                {
                    Data = Data + Convert.ToChar(1);
                    byte[] dataBytes = Encoding.Default.GetBytes(Data);
                    ClientSock.BeginSend(dataBytes, 0, dataBytes.Length, 0, new AsyncCallback(sentData), null);
                }
            }
            catch (Exception e)
            {
                BlizzardSystem.WriteLine(e.ToString());
            }
        }

        internal void SendPackets(string Data)
        {
            try
            {
                byte[] dataBytes = Encoding.Default.GetBytes(Data);
                ClientSock.BeginSend(dataBytes, 0, dataBytes.Length, 0, new AsyncCallback(sentData), null);
            }
            catch (Exception e)
            {
                BlizzardSystem.WriteLine(e.ToString());
            }
        }

        internal void SendMessage(ServerMessage Message)
        {
            SendPacket(Message.ToString());
        }

        private void sentData(IAsyncResult iAr)
        {
            try
            {
                ClientSock.EndSend(iAr);
            }
            catch
            {
                Disconnect();
            }
        }

        internal bool SocketsActive
        {
            get
            {
                try
                {
                    return ClientSock.Connected;
                }
                catch
                {
                    return false;
                }
            }
        }
    }
}