using System.Net;
using System.Net.Sockets;

namespace DroneSimulator
{
    internal class NetClient
    {
        public class ConnectData
        {
            public bool Connect;

            public Socket? Server;
        }

        public class ReceiveData
        {
            public byte[]? Buffer;
            public int Size;

            public Socket? Server;
        }

        private class ServerData
        {
            public const int size = 1024;
            public byte[] buffer = new byte[size];
        }

        private bool Connected = false;
        private Socket? ServerSocket = null;
        private ServerData DataServer = new ServerData();

        public delegate void ClientCallback(object o);

        private ClientCallback? ConnectionCallback;
        private ClientCallback? ReceiveCallback;

        public enum ClientState { Error, Connected, Stop };

        public ClientState Connect(string Addr, int Port, ClientCallback Connection, ClientCallback Receive)
        {
            if (Connected)
            {
                try { ServerSocket?.Shutdown(SocketShutdown.Both); } catch { }
                ServerSocket?.Close();
                Connected = false;
                return ClientState.Stop;
            }

            ConnectionCallback = Connection;
            ReceiveCallback = Receive;

            IPEndPoint ep = new IPEndPoint(IPAddress.Parse(Addr), Port);
            ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try { ServerSocket.Connect(ep); }
            catch { ServerSocket.Close(); return ClientState.Error; }

            Connected = true;

            ConnectionCallback(new ConnectData { Connect = true, Server = ServerSocket });

            ReceiveData receiveData = new ReceiveData { Buffer = DataServer.buffer, Size = ServerData.size, Server = ServerSocket };

            try { ServerSocket.BeginReceive(DataServer.buffer, 0, ServerData.size, 0, new AsyncCallback(ReadCallback), receiveData); }
            catch { }

            return ClientState.Connected;
        }

        public void Close()
        {
            try { ServerSocket?.Shutdown(SocketShutdown.Both); } catch { }
            ServerSocket?.Close();
            Connected = false;
        }

        public void ReadCallback(IAsyncResult ar)
        {
            ReceiveData cd = (ReceiveData)ar.AsyncState;
            if (cd == null) return;

            int bytes = 0;
            try { bytes = ServerSocket.EndReceive(ar); } catch { }

            if (bytes == 0)
            {
                ServerSocket?.Close();

                Connected = false;

                if (ServerSocket != null) ConnectionCallback(new ConnectData { Connect = false, Server = null });

                return;
            }

            ReceiveCallback(new ReceiveData { Buffer = cd.Buffer, Size = bytes, Server = ServerSocket });

            try { ServerSocket?.BeginReceive(cd.Buffer, 0, ServerData.size, 0, new AsyncCallback(ReadCallback), cd); }
            catch { }
        }
    }
}