using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Net.NetworkInformation;

namespace DuckEmulator.HabboHotel.Inside.Licence
{
    enum LicenceState
    {
        Valid = 0,
        NotFound = 1,
        InUse = 2,
        ServerDead = 3
    }

    class LicenceManager
    {
        internal Socket Server;
        internal AsyncCallback Received;
        internal byte[] BUFFER = new byte[1024];

        internal LicenceManager()
        {
            Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            Console.Title = "Verfying Licence.";
            Console.WriteLine(" ");
            Console.WriteLine("   Connecting to Licence-Server..");

            try
            {
                Server.Connect(new IPEndPoint(IPAddress.Parse("178.251.196.151"), 1000));
            }
            catch
            {
                DuckEnvironment.LicenceState = LicenceState.ServerDead;
                return;
            }

            Received = new AsyncCallback(_recv);

            Server.Send(Encoding.ASCII.GetBytes(new Int32() + DuckEnvironment.DecodeHex("3a") + DuckEnvironment.ConfigManager.KeyVals["licence"]));

            Server.BeginReceive(BUFFER, 0, BUFFER.Length, SocketFlags.None, Received, null);
        }

        protected void _recv(IAsyncResult Result)
        {
            try
            {
                if (Result != null)
                {
                    ushort Bits = (ushort)Server.EndReceive(Result);

                    if (Bits <= 0)
                    {
                        Dispose();
                        return;
                    }
                    else
                    {
                        InvokePacket(Encoding.ASCII.GetString(BUFFER, 0, Bits));
                    }

                    Server.BeginReceive(BUFFER, 0, BUFFER.Length, SocketFlags.None, Received, null);
                }
            }
            catch
            {
                try { Server.BeginReceive(BUFFER, 0, BUFFER.Length, SocketFlags.None, Received, null); }
                catch { Dispose(); }
            }
        }

        internal void Dispose()
        {
            if (Server != null)
            {
                Server.Shutdown(SocketShutdown.Both);
                Server = null;
            }
        }

        protected void InvokePacket(string Packet)
        {
            var Data = Packet.Split(':');

            ushort Id = ushort.Parse(Data[0]);

            switch (Id)
            {
                case 0: // Validata Licence
                    {
                        if (Data[1] == "I")
                        {
                            DuckEnvironment.LicenceState = LicenceState.Valid;
                        }
                        else if (Data[1] == "K")
                        {
                            DuckEnvironment.LicenceState = LicenceState.InUse;
                        }
                        else
                        {
                            DuckEnvironment.LicenceState = LicenceState.NotFound;
                        }
                    }
                    break;
            }
        }
    }
}