using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Net.Sockets;

namespace KiDS_Projekat
{


    public class Program
    {
        static void Main(string[] args)
        {
            Native native = new Native();


            native.Listen(8080);

            Console.ReadLine();

        }
    }

    // Enums from Microsofts website (#defined in C++)
    public enum AddressFamily : int
    {
        Unknown = 0,
        InterNetworkv4 = 2,
        Ipx = 4,
        AppleTalk = 17,
        NetBios = 17,
        InterNetworkv6 = 23,
        Irda = 26,
        BlueTooth = 32
    }
    public enum SocketType : int
    {
        Unknown = 0,
        Stream = 1,
        DGram = 2,
        Raw = 3,
        Rdm = 4,
        SeqPacket = 5
    }
    public enum ProtocolType : int
    {
        BlueTooth = 3,
        Tcp = 6,
        Udp = 17,
        ReliableMulticast = 113
    }

    // Equivilent to C++s "SOCKET"
    public unsafe struct SOCKET
    {
        private void* handle;
        private SOCKET(int _handle)
        {
            handle = (void*)_handle;
        }
        public static bool operator ==(SOCKET s, int i)
        {
            return ((int)s.handle == i);
        }
        public static bool operator !=(SOCKET s, int i)
        {
            return ((int)s.handle != i);
        }
        public static implicit operator SOCKET(int i)
        {
            return new SOCKET(i);
        }
        public static implicit operator uint(SOCKET s)
        {
            return (uint)s.handle;
        }
        public override bool Equals(object obj)
        {
            return (obj is SOCKET) ? (((SOCKET)obj).handle == this.handle) : base.Equals(obj);
        }
        public override int GetHashCode()
        {
            return (int)handle;
        }
    }


    public struct timeval
    {
        public long tv_sec;
        public long tv_usec;
    }


    // fd_set used in 'select' method
    public unsafe struct fd_set
    {
        public const int FD_SETSIZE = 64;
        public uint fd_count;
        public fixed uint fd_array[FD_SETSIZE];
    }

    // C# equivilent to C++'s sockaddr_in / SOCKADDR_IN
    [StructLayout(LayoutKind.Sequential, Size = 16)]
    public struct sockaddr_in
    {
        public const int Size = 16;

        public short sin_family;
        public ushort sin_port;
        public struct in_addr
        {
            public uint S_addr;
            public struct _S_un_b
            {
                public byte s_b1, s_b2, s_b3, s_b4;
            }
            public _S_un_b S_un_b;
            public struct _S_un_w
            {
                public ushort s_w1, s_w2;
            }
            public _S_un_w S_un_w;
        }
        public in_addr sin_addr;
    }

    // WSAData structure, used in WSAStarutp
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public unsafe struct WSAData
    {
        public ushort Version;
        public ushort HighVersion;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 257)]
        public string Description;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
        public string SystemStatus;
        public ushort MaxSockets;
        public ushort MaxUdpDg;
        sbyte* lpVendorInfo;
    }

    // Interface to ws2_32.dll
    public unsafe partial class Native
    {
        public const int AF_INET = 2;
        public const int SOCK_STREAM = 1;
        public const int PPROTO_TCP = 6;

        public const long FIONBIO    = 0x8004667E;
        public const string INADDR_ANY = "0.0.0.0";

        public const int SOCKET_ERROR = -1;
        public const int INVALID_SOCKET = ~0;


        [DllImport("Ws2_32.dll")]
        public static extern int WSAStartup(ushort Version, out WSAData Data);

        [DllImport("Ws2_32.dll")]
        public static extern SocketError WSAGetLastError();

        [DllImport("Ws2_32.dll")]
        public static extern SOCKET socket(AddressFamily af, SocketType type,
                                            ProtocolType protocol);

        [DllImport("Ws2_32.dll")]
        public static extern int send(SOCKET s, char* buf, int len, int flags);

        [DllImport("Ws2_32.dll")]
        public static extern int recv(SOCKET s, char* buf, int len, int flags);

        [DllImport("Ws2_32.dll")]
        public static extern SOCKET accept(SOCKET s, void* addr, int* addrsize);

        [DllImport("Ws2_32.dll")]
        public static extern int listen(SOCKET s, int backlog);

        [DllImport("Ws2_32.dll", CharSet = CharSet.Ansi)]
        public static extern uint inet_addr(string cp);

        [DllImport("Ws2_32.dll")]
        public static extern ushort htons(ushort hostshort);

        [DllImport("Ws2_32.dll")]
        public static extern int connect(SOCKET s, sockaddr_in* addr, int addrsize);

        [DllImport("Ws2_32.dll")]
        public static extern int ioctlsocket(SOCKET s, long cmd, ulong* argp);

        [DllImport("Ws2_32.dll")]
        public static extern int closesocket(SOCKET s);

        [DllImport("Ws2_32.dll")]
        public static extern int bind(SOCKET s, sockaddr_in* addr, int addrsize);

        [DllImport("Ws2_32.dll")]
        public static extern int select(int ndfs, fd_set* readfds, fd_set* writefds,
                                         fd_set* exceptfds, timeval* timeout);

        [DllImport("Ws2_32.dll")]
        public static extern sbyte* inet_ntoa(sockaddr_in.in_addr _in);

        [DllImport("Ws2_32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern Int32 WSACleanup();

        public SOCKET clientSocket;
        public SOCKET serverSocket;

        public bool Listen(ushort port)
        {
            WSAData wsaData = new WSAData();
            int startupResult = Native.WSAStartup(/*MAKEWORD(2, 2)*/514, out wsaData);
            if (startupResult == Native.SOCKET_ERROR)
            {
                Console.WriteLine("WSA start-up error code: " + wsaData.ToString());
                return false;
            }

            // [ 1 ] Set-up socket
            serverSocket = Native.socket(AddressFamily.InterNetworkv4, SocketType.Stream,
                            ProtocolType.Tcp);
            if (serverSocket == INVALID_SOCKET)
            {
                Console.WriteLine("Creating socket: " + Native.WSAGetLastError().ToString());
                return false;
            }

            // [ 2 ] Bind socket to ip adress and port of the server
            sockaddr_in sockaddr = new sockaddr_in();

            sockaddr.sin_family = AF_INET;
            sockaddr.sin_addr.S_addr = Native.inet_addr(INADDR_ANY);
            sockaddr.sin_port = Native.htons(port);

            int bindResult = Native.bind(serverSocket, &sockaddr, Marshal.SizeOf(sockaddr));
            if (bindResult == SOCKET_ERROR)
            {
                Console.WriteLine("Bind: " + Native.WSAGetLastError().ToString());
                return false;
            }

            // [ 3 ] Try to listen
            int listenResult = Native.listen(serverSocket, 1);
            if (listenResult == SOCKET_ERROR)
            {
                Console.WriteLine("Listen: " + Native.WSAGetLastError().ToString());
                return false;
            }


            while (true) {

                // [ 4 ] Accept connection
                SOCKET tempSocket = SOCKET_ERROR;
                sockaddr_in temp_sockaddr = new sockaddr_in();
                int temp_len = Marshal.SizeOf(temp_sockaddr);

                while (tempSocket == SOCKET_ERROR)
                {
                    tempSocket = Native.accept(serverSocket, &temp_sockaddr, &temp_len);
                    if (tempSocket == -1)
                        continue;
                    RecieveMessage(tempSocket);
                    SendMessage("toi toi", tempSocket);
                }
                serverSocket = tempSocket;
            }
        }

        private bool Client(string address, ushort port)
        {
            WSAData wsaData = new WSAData();
            int startupResult = Native.WSAStartup(/*MAKEWORD(2, 2)*/514, out wsaData);
            if (startupResult == Native.SOCKET_ERROR)
            {
                Console.WriteLine("WSA start-up error code: " + wsaData.ToString());
                return false;
            }

            // [ 1 ] Set-up socket
            serverSocket = Native.socket(AddressFamily.InterNetworkv4, SocketType.Stream,
                            ProtocolType.Tcp);
            if (serverSocket == INVALID_SOCKET)
            {
                Console.WriteLine("Creating socket: " + Native.WSAGetLastError().ToString());
                return false;
            }

            // [ 2 ] Connect
            sockaddr_in sockaddr = new sockaddr_in();

            sockaddr.sin_family = AF_INET;
            sockaddr.sin_addr.S_addr = Native.inet_addr(address);
            sockaddr.sin_port = Native.htons(port);

            int connectResult = Native.connect(clientSocket, &sockaddr, Marshal.SizeOf(sockaddr));
            if (connectResult == SOCKET_ERROR)
            {
                Console.WriteLine("Connecting to server: " + Native.WSAGetLastError().ToString());
                return false;
            }

            return true;
        }


        private unsafe string RecieveMessage(SOCKET socket)
        {
            char[] recvArr = new char[8];
            int recvResult = -2; // -2 точно не сможет вернуть recv
            string message;

            fixed (char* recvBuf = recvArr)
            {
                recvResult = Native.recv(socket, recvBuf, 8, 0);
                message = new string(recvBuf);
                if (recvResult == SOCKET_ERROR)
                {
                    Console.WriteLine("Recive: " + Native.WSAGetLastError().ToString());
                    Native.closesocket(socket);
                    return "R";
                }
            }
            if (message.Length > 0)
                return message;
            else
                return "R";
        }

        private unsafe bool SendMessage(string message, SOCKET socket)
        {
            fixed (char* pbuf = message)
            {
                int sendResult = Native.send(socket, pbuf, 8, 0);
                if (sendResult == SOCKET_ERROR)
                {
                    Console.WriteLine("Sending: " + Native.WSAGetLastError().ToString());
                    Native.closesocket(socket);
                    return false;
                }
            }
            return true;
        }

    }
}