using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Security.Cryptography;
using System.Net.Sockets;
using System.Net;
using System.Collections;
using System.Threading;

namespace sockerv4
{


    class Program
    {
        private static byte[] _buffer = new byte[2048];
        private static IDictionary<string, Socket> clients = new Dictionary<string, Socket>();

        private static IList socket_list = new ArrayList();

        static void Main()
        {
            Console.WriteLine("Program Start");

            Socket socket = open_main_socket();


            Console.ReadKey();
        }

        private static Socket open_main_socket()
        {

            try
            {

                IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse("192.168.0.7"), 100);
                Console.WriteLine("Opening Main Socket...");
                Socket main_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                main_socket.Bind(endpoint);
                listen_new(main_socket);
                clients.Add("main_socket", main_socket);
                return main_socket;
            }
            catch (SocketException e)
            {
                Console.WriteLine("Socket Error Occured (Main Socket):" + e.Message);
                return null;
            }

        }
        private static void listen_new(Socket sock)
        {

            try
            {
                Console.WriteLine("Listening Incoming Connnection...");
                sock.Listen(5);
                sock.BeginAccept(new AsyncCallback(start_accept_new), sock);
            }
            catch (SocketException e)
            {
                Console.WriteLine("Socket Error Occured (Listen New):" + e.Message);
            }
        }
        private static void start_accept_new(IAsyncResult AR)
        {
            try {
                Console.WriteLine("Accepting New Connection....");
                Socket sock = ((Socket)AR.AsyncState).EndAccept(AR);
                listen_new((Socket)AR.AsyncState);
                sock.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(begin_handshake), sock);
            } catch (SocketException e)
            {
                Console.WriteLine("Socket Error Occured(Start Accept New):" + e.Message);
            }

        }
        private static void begin_handshake(IAsyncResult AR)
        {
            Console.WriteLine("Shaking Hands");
            Socket sock = ((Socket)AR.AsyncState);
            int Data = sock.EndReceive(AR);
            byte[] databyte = new byte[Data];
            Array.Copy(_buffer, databyte, Data);

            String text = Encoding.ASCII.GetString(databyte);
            List<string> headers = retriveheaders(text);
            acceptuser(headers, sock);

        }
        private static void acceptuser(List<string> headers, Socket sock) {

            ICollection<string> keys = (clients.Keys);
            IList user_list = new ArrayList();
            user_list = keys.ToList();

            if (user_list.Contains(headers[0])) {

                Console.Write("User Already Connectedn");
                Socket currentsock;
                bool check = clients.TryGetValue(headers[0], out currentsock);


                close_frame(currentsock);
                clients.Remove(headers[0]);


                string handshake;
                string Key = headers[4].Trim() + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
                SHA1 sha = new SHA1CryptoServiceProvider();
                clients.Add(headers[0], sock);
                byte[] hash = sha.ComputeHash(Encoding.ASCII.GetBytes(Key));
                handshake = Convert.ToBase64String(hash);
                string AcceptKey = "HTTP/1.1 101 Switching ProtocolsrnUpgrade: websocketrnConnection: UpgradernSec-WebSocket-Protocol: " + headers[5].Trim() + "rnSec-WebSocket-Accept: " + handshake.Trim() + "rnrn";
                send_handshake(AcceptKey, sock);
                message_listener(sock);

            }
            else
            {

                string handshake;
                string Key = headers[4].Trim() + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
                SHA1 sha = new SHA1CryptoServiceProvider();
                clients.Add(headers[0], sock);
                byte[] hash = sha.ComputeHash(Encoding.ASCII.GetBytes(Key));
                handshake = Convert.ToBase64String(hash);
                string AcceptKey = "HTTP/1.1 101 Switching ProtocolsrnUpgrade: websocketrnConnection: UpgradernSec-WebSocket-Protocol: " + headers[5].Trim() + "rnSec-WebSocket-Accept: " + handshake.Trim() + "rnrn";
                send_handshake(AcceptKey, sock);
                message_listener(sock);
            }

        }

        private static void close_frame(Socket sock)
        {

            Byte[] frame = new Byte[2];
            frame[0] = (Byte)136;
            frame[1] = 0;
            try
            {
                sock.Send(frame);

            }
            catch (SocketException e)
            {
                Console.Write("Error Occured" + e.Message);
            }


        }
        private static void message_listener(Socket insock)
        {
            start(insock);

            void start(Socket sock) {
                Console.WriteLine("Looping Handle: " + sock.Handle);
                byte[] m_buffer = new byte[5000];
                try
                {
                    sock.BeginReceive(m_buffer, 0, m_buffer.Length, SocketFlags.None, ar => { int dat = sock.EndReceive(ar); processdata(m_buffer, dat, ar); }, sock);

                }
                catch (Exception e) {

                    Console.WriteLine("Error Occured Begin Receive: "+ e.Message);
                }


            }

                void processdata(byte[] r_buffer, int size,IAsyncResult AR)
                {

                    Socket sockp = ((Socket)AR.AsyncState);

                    Console.WriteLine("Data Received: " + size);
                    Console.WriteLine("IAsync Result: " + AR.AsyncState);
                    Console.WriteLine("Opcode"+ (r_buffer[0] & 81));
                        switch (r_buffer[0]&81) {
                            case 1:
                           datadecode(r_buffer);
                           start(sockp);
                                break;
                        case 0:
                        if (size==6) {
                            string myKey = clients.FirstOrDefault(x => x.Value == sockp).Key;
                            if (myKey!=null) {
                                close_frame(sockp);
                                sockp.Shutdown(SocketShutdown.Both);
                                sockp.Close();
                                sockp.Dispose();
                                clients.Remove(myKey);
                            }
                            else {

                                sockp.Shutdown(SocketShutdown.Both);
                                sockp.Close();
                                sockp.Dispose();

                            }

                        }
                        else {
                            sockp.Shutdown(SocketShutdown.Both);
                            sockp.Close();
                            sockp.Dispose();
                            string myKey = clients.FirstOrDefault(x => x.Value == sockp).Key;
                            clients.Remove(myKey);
                        }
                        break;
                            default:
                                Console.WriteLine("Default Switch");
                            break;

                        }

                }

        }

        private static void send_data(String data, Socket socket)
        {
            byte[] r_data = EncodeMessageToSend(data);
            try
            {
                Console.Write("Sending Handshake:n");
                socket.BeginSend(r_data, 0, r_data.Length, SocketFlags.None, new AsyncCallback(sent), socket);
            }
            catch (SocketException e)
            {
                Console.WriteLine("Socket Error Occured When sending data 1: " + e.Message);
            }
        }


        private static void send_handshake(String data, Socket socket)
        {
            byte[] send_key = Encoding.UTF8.GetBytes(data);
            try {
                Console.Write("Sending Handshake:n");
                socket.BeginSend(send_key, 0, send_key.Length, SocketFlags.None, new AsyncCallback(sent), socket);
            } catch (SocketException e) {
                Console.WriteLine("Socket Error Occured When sending data 1: " + e.Message);
            }
        }

        private static void sent(IAsyncResult AR)
        {
            Socket sock = (Socket)AR.AsyncState;
            try {
                sock.EndSend(AR);

            }
            catch (SocketException e){

                Console.WriteLine("Socket Error Occured When sending data 2: " + e.Message);
            }
        }


        private static List<string> retriveheaders(String Data)
        {
            Console.Write("Retriveing Headersn");

            List<string> headers = new List<string>();

            headers.Add(Regex.Match(Data, "(?<=GET /)(.*)(?= HTTP)").ToString());
            headers.Add(Regex.Match(Data, "(?<=Host: )(.*)[?=rn*]").ToString());
            headers.Add(Regex.Match(Data, "(?<=Upgrade: )(.*)[?=rn]").ToString());
            headers.Add(Regex.Match(Data, "(?<=Connection: )(.*)[?=rn]").ToString());
            headers.Add(Regex.Match(Data, "(?<=Sec-WebSocket-Key: )(.*)[?=rn]").ToString());
            headers.Add(Regex.Match(Data, "(?<=Sec-WebSocket-Protocol: )(.*)[?=rn]").ToString());
            headers.Add(Regex.Match(Data, "(?<=Sec-WebSocket-Version: )(.*)[?=rn]").ToString());
            headers.Add(Regex.Match(Data, "(?<=Origin: )(.*)rn").ToString());
            headers.Add(Regex.Match(Data, "rn(.*)$").ToString());

            return headers;

        }
        private static Byte[] EncodeMessageToSend(String message)
        {
            Byte[] response;
            Byte[] bytesRaw = Encoding.UTF8.GetBytes(message);
            Byte[] frame = new Byte[10];

            Int32 indexStartRawData = -1;
            Int32 length = bytesRaw.Length;

            frame[0] = (Byte)129;
            if (length <= 125)
            {
                frame[1] = (Byte)length;
                indexStartRawData = 2;
            }
            else if (length >= 126 && length <= 65535)
            {
                frame[1] = (Byte)126;
                frame[2] = (Byte)((length >> 8) & 255);
                frame[3] = (Byte)(length & 255);
                indexStartRawData = 4;
            }
            else
            {
                frame[1] = (Byte)127;
                frame[2] = (Byte)((length >> 56) & 255);
                frame[3] = (Byte)((length >> 48) & 255);
                frame[4] = (Byte)((length >> 40) & 255);
                frame[5] = (Byte)((length >> 32) & 255);
                frame[6] = (Byte)((length >> 24) & 255);
                frame[7] = (Byte)((length >> 16) & 255);
                frame[8] = (Byte)((length >> 8) & 255);
                frame[9] = (Byte)(length & 255);

                indexStartRawData = 10;
            }

            response = new Byte[indexStartRawData + length];

            Int32 i, reponseIdx = 0;

            //Add the frame bytes to the reponse
            for (i = 0; i < indexStartRawData; i++)
            {
                response[reponseIdx] = frame[i];
                reponseIdx++;
            }

            //Add the data bytes to the response
            for (i = 0; i < length; i++)
            {
                response[reponseIdx] = bytesRaw[i];
                reponseIdx++;
            }

            return response;
        }

        private static void datadecode(byte[] rawdata)
        {
            Console.WriteLine("Message Unmaskingn");

            Thread.Sleep(10000);

            var fin = rawdata[0] & 0x81;

            bool res = fin != 129;
            Console.WriteLine("Opcode:" + res);
            var Lenght = rawdata[1] & 127;
            byte b = rawdata[1];
            int totalLength = 0;
            int keyIndex = 0;
            int dataLength = 0;


            if (Lenght <= 125)
            {

                keyIndex = 2;
                totalLength = Lenght + 6;
                dataLength = Lenght;

            }

            if (Lenght == 126)
            {

                dataLength = (int)BitConverter.ToUInt16(new byte[] { rawdata[3], rawdata[2] }, 0);
                keyIndex = 4;
                totalLength = dataLength + 8;

            }
            if (Lenght == 127)
            {

                dataLength = (int)BitConverter.ToInt64(new byte[] { rawdata[9], rawdata[8], rawdata[7], rawdata[6], rawdata[5], rawdata[4], rawdata[3], rawdata[2] }, 0);
                keyIndex = 10;
                totalLength = dataLength + 14;

            }

            byte[] key = new byte[] { rawdata[keyIndex], rawdata[keyIndex + 1], rawdata[keyIndex + 2], rawdata[keyIndex + 3] };

            int dataIndex = keyIndex + 4;
            int count = 0;


            for (int i = dataIndex; i < totalLength; i++)
            {
                rawdata[i] = (byte)(rawdata[i] ^ key[count % 4]);
                count++;
            }

            string message = Encoding.ASCII.GetString(rawdata, dataIndex, dataLength);

            Console.WriteLine("Message Recieved:" + message);


        }

    }
}