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

// Network Sync

namespace Mistox.Client {
    public class mUDPClient : IDisposable {

        Socket udpClient;
        IPEndPoint remoteHost;

        public mUDPClient( long RemoteIP, int Port ) {
            remoteHost = new IPEndPoint( RemoteIP, Port );
            udpClient = new Socket( AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp );
            udpClient.SetSocketOption( SocketOptionLevel.IP, SocketOptionName.ReuseAddress, true );
            udpClient.SetSocketOption( SocketOptionLevel.IP, SocketOptionName.IpTimeToLive, 128 );
            udpClient.Bind( new IPEndPoint( IPAddress.Any, Port ) );
            ClientInterface.ServerClientInstance.Alive = true;
            Thread Client = new Thread(async() => { await ReceiveThread(); });
            Client.Start();
        }

        async Task ReceiveThread() {
            byte[] buffer = new byte[65535];
            while( ClientInterface.ServerClientInstance.Alive ) {
                try {

                    // Read the data out of the UDP packet with a buffer that has the maximum possible UDP packet size
                    // As UDP reads the whole next packet then drops. Im guaranteed to receive 1 packet at a time
                    int bytesRead = await udpClient.ReceiveAsync( buffer );

                    // Create the data readers
                    ReadOnlyMemory<byte> dataMemory = buffer.AsMemory(0, bytesRead);
                    ReadOnlySpan<byte> dataPacket = dataMemory.Span;

                    // Split apart the packet
                    byte dataType = dataPacket[0];
                    ushort DataLength = (ushort)((dataPacket[1] << 8) | dataPacket[2]);
                    ReadOnlyMemory<byte> data = dataMemory.Slice(DataPacket.HeaderLength, DataLength);

                    // Extract the object
                    dynamic buildObj = DataPacket.Deserialize( dataType, DataLength, data );

                    // Return the object
                    ClientInterface.ServerClientInstance.InvokeOnReceived( buildObj );

                } catch( Exception e ) {
                    Console.WriteLine( "UDP Receive exception : " + e.Message );
                }
            }
        }

        public async Task Send<T>( T Data ) {
            byte[] byteData = DataPacket.Serialize( Data );
            await udpClient.SendToAsync( byteData, SocketFlags.None, remoteHost );
        }

        public void Dispose() {
            ClientInterface.ServerClientInstance.Alive = false;
            udpClient.Close();
            udpClient = null;
        }
    }
}