//Client Connection Code


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;
using UnityEngine;
using System.Collections;

namespace Axiom_ClientConnection_0_01
{
    public class Connector
    {
        const int READ_BUFFER_SIZE = 255;
        const int TCP_PORT_NUMBER = 65000;
        const int UDP_PORT_NUMBER = 65002;
        private TcpClient connectionClient;
        public Hashtable MultiLocations = new Hashtable();

        public struct PlayerLocations
        {
            public Vector3 Position;
            public Quaternion Rotation;
        };

        //UdpClient transmissionClient;
        private byte[] readbuffer = new byte[READ_BUFFER_SIZE];
        public string message = "";
        public string result = "";
        private string username;
        IPAddress ipAddress;
        IPEndPoint servIP, listenUDP;
        Thread UDPListenerThread;
        int portNum = new int();
        Socket server = new Socket(AddressFamily.InterNetwork,
                     SocketType.Dgram, ProtocolType.Udp);
        public bool CONNECTED = false;
        public int x = 0;

        public Connector() { }

        public string ConnectionAttempt(string ServeIP, string PlayUsername)
        {
            username = PlayUsername;

            try
            {
                
                connectionClient = new TcpClient(ServeIP,TCP_PORT_NUMBER);
                connectionClient.GetStream().BeginRead(readbuffer, 0, READ_BUFFER_SIZE, new AsyncCallback(DoRead), null);
                
                Login(username);
                ipAddress = IPAddress.Parse(((IPEndPoint)connectionClient.Client.RemoteEndPoint).Address.ToString());
                servIP = new IPEndPoint(ipAddress,65002);
                listenUDP = new IPEndPoint(ipAddress, 0);
                
                UDPListenerThread = new Thread(receiveUDP);
                UDPListenerThread.IsBackground = true;
                UDPListenerThread.Start();
                return "Connection Succeeded";
            }
            catch(Exception ex) {
                return (ex.Message.ToString() + "Connection Failed");
            }
        }

        private void receiveUDP()
        {
            System.Net.IPEndPoint test = new System.Net.IPEndPoint(System.Net.IPAddress.Any,UDP_PORT_NUMBER);
            System.Net.EndPoint serverIP = (System.Net.EndPoint)test;
            server.Bind(serverIP);
          

            EndPoint RemoteServ = (EndPoint)listenUDP;
            do
            {
                byte[] content = new byte[1024];
                int data = server.ReceiveFrom(content, ref RemoteServ);

                string message = Encoding.ASCII.GetString(content);
               

                ProcessCommands(message);


            } while (true);
        }

        public void Login(string username)
        {
            StreamWriter writer = new StreamWriter(connectionClient.GetStream());
            writer.Write("CONNECT|" + username);
            writer.Flush();
            //connectionClient.GetStream().BeginRead(readbuffer, 0, READ_BUFFER_SIZE, new AsyncCallback(DoRead), null);
        }

        public void SendChat(string data)
        {
            SendData(username + "|CHAT|" + data);
        }

        public void SendUpdateLocation(string data)
        {
            SendData(username + "|UPDATEPOS|" + data);
        }

        public void Disconnect()
        {
            SendData(username + "|DISCONNECT|");
            
            //StreamWriter writer = new StreamWriter(connectionClient.GetStream());
            //writer.Write("DISCONNECT");
            //writer.Flush();
            server.Close();
            UDPListenerThread.Abort();
            
            connectionClient.Close();
            
        }


        private void DoRead(IAsyncResult ar)
        {
            int BytesRead;
            try
            {
                BytesRead = connectionClient.GetStream().EndRead(ar);
                if (BytesRead < 1)
                {
                    result = "DISCONNECTED";
                    return;
                }

                string message = Encoding.ASCII.GetString(readbuffer, 0, BytesRead);
                ProcessCommands(message);

                connectionClient.GetStream().BeginRead(readbuffer, 0, READ_BUFFER_SIZE, new AsyncCallback(DoRead), null);
            }
            catch { }
        }


        private void SendData(string data)
        {
            //result = data;
            byte[] dataArr = Encoding.ASCII.GetBytes(data);
            try
            {
                EndPoint servEnd = (EndPoint)servIP;
                //UDPListenerThread.Suspend();
                server.SendTo(dataArr, dataArr.Length,SocketFlags.None, servEnd);
                //UDPListenerThread.Resume();
            }
            catch (Exception e)
            {
            }
        }

        private void ProcessCommands(string data)
        {
            string[] dataArr;

            dataArr = data.Split((char)124);

            switch (dataArr[0])
            {
                case "JOIN":
                    result = "You have joined the chat!";
                    CONNECTED = true;
                    break;
                case "CHAT":
                    result = dataArr[1].ToString();
                    break;
                case "REFUSE":
                    Login(username);
                    result = "Connection refused.  Attempting another login.";
                    break;
                case "BROAD":
                    result = "SERVER MESSAGE: " + dataArr[1].ToString();
                    break;
                case "UPDATEPOS":
                    UpdateLoc(dataArr);
                    //x++;
                    break;
                default:
                    result = "Server sent bad message waiting for retry";
                    break;
            }
        }

        private void UpdateLoc(string [] data)
        {
            //result = x.ToString();
            string [] playerLoc;
            for (int i = 1; i < data.Length; i++)
            {
                playerLoc = data[i].Split(',');

                PlayerLocations PlayerCoord = new PlayerLocations();
                Vector3 trans1;
                Quaternion trans2 = new Quaternion();
                trans1.x = float.Parse(playerLoc[1]);
                trans1.y = float.Parse(playerLoc[2]);
                trans1.z = float.Parse(playerLoc[3]);
                trans2.x = float.Parse(playerLoc[4]);
                trans2.y = float.Parse(playerLoc[5]);
                trans2.z = float.Parse(playerLoc[6]);

                PlayerCoord.Position = trans1;
                PlayerCoord.Rotation = trans2;


                if(MultiLocations.ContainsKey(playerLoc[0]))
                {
                    MultiLocations[playerLoc[0]] = PlayerCoord;
                }
                else
                    MultiLocations.Add(playerLoc[0], PlayerCoord);
            }
        }


    }
}


//Server Code


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Collections;
using System.Net.Sockets;
//using MySql.Data.MySqlClient;

namespace AxiomTestServer_Alpha_0_02
{
    public partial class mainForm : Form
    {
        static void Main()
        {
            Application.Run(new mainForm());
        }

        public mainForm()
        {
            InitializeComponent();
        }
        delegate void SetTextCallback(string text);


        const int PORT_NUM = 65000;
        const int UDP_PORT = 65002;
        private Hashtable clients = new Hashtable();
        private TcpListener listener;
        private Thread listenerThread;
        //private UdpClient transmitter = new UdpClient(65002);
        private Thread transThread;
        Socket trans = new Socket(AddressFamily.InterNetwork,
                    SocketType.Dgram, ProtocolType.Udp);
        int LocCount = 0;
        
        private void ConnectUser(string userName, UserConnection sender)
        {
            if (clients.Contains(userName))
            {
                ReplyToSender("REFUSE", sender);
            }

            else
            {
                sender.Name = userName;
                UpdateStatus(sender.Name + " has joined the chat");
                clients.Add(userName, sender);
                JoinSender(sender);
                SendToClients("CHAT|" + sender.Name + " has joined the chat.", sender);
            }
        }

        private void JoinSender(UserConnection sender)
        {
            sender.Join();
        }
        private void DisconnectUser(UserConnection sender)
        {
            UpdateStatus(sender.Name + " has left the chat.");
            SendToClients("CHAT|" + sender.Name + " has left the chat.", sender);
            clients.Remove(sender.Name);
        }

        private void ConnectionListen()
        {
            try
            {
                listener = new TcpListener(System.Net.IPAddress.Any, PORT_NUM);
                listener.Start();

                do
                {
                    UserConnection client = new UserConnection(listener.AcceptTcpClient());
                    client.LineRecieved += new LineRecieve(OnLineRecieved);
                    UpdateStatus("Someone is attempting a login");

                } while (true);
            }
            catch
            {
            }
        }

        private void OnLineRecieved(UserConnection sender, string data)
        {
            string[] dataArray;

            dataArray = data.Split((char)124);

            switch (dataArray[0])
            {
                case "CONNECT":
                    ConnectUser(dataArray[1], sender);
                    break;
                case "CHAT":
                    SendChat(dataArray[1], sender);
                    break;
                case "DISCONNECT":
                    DisconnectUser(sender);
                    break;
                case "UPDATEPOS":
                    UpdateStatus("Client is updating the position");
                    UpdatePos(sender, dataArray[1]);
                    break;
                 default:
                    //let the users know this message was sent wrong
                    break;
            }
        
        }

        
        private void UpdatePos(UserConnection sender, string data)
        {
            string[] dataArr = data.Split(',');

            sender.UpdateLocation(dataArr);

            if(LocCount == 3)
            {
                string message = "UPDATEPOS|";
                UserConnection client;
                foreach (DictionaryEntry entry in clients)
                {
                    client = (UserConnection)entry.Value;
                    message += client.Name + "," + client.Location.PosX + "," + client.Location.PosY + "," + client.Location.PosZ + "," + client.Location.RotX + "," +
                        client.Location.RotY + "," + client.Location.RotZ + "|";
                }

                foreach (DictionaryEntry entry in clients)
                {
                    client = (UserConnection)entry.Value;

                    client.SendData(message,trans);
                }
                LocCount = 0;
               
            }
            LocCount++;
        }

        private void receiveUDP()
        {
            System.Net.IPEndPoint test = new System.Net.IPEndPoint(System.Net.IPAddress.Any,UDP_PORT);
            System.Net.EndPoint serverIP = (System.Net.EndPoint)test;
            trans.ExclusiveAddressUse = true;
            trans.Bind(serverIP);
            System.Net.IPEndPoint ipep = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0);
            System.Net.EndPoint Remote = (System.Net.EndPoint)ipep;
            
            while (true)
            {
                
                byte[] content = new byte[1024];
                
                int recv = trans.ReceiveFrom(content,ref Remote);

                int portNum = ((System.Net.IPEndPoint)Remote).Port;
                string message = Encoding.ASCII.GetString(content);
                string[] data = message.Split((char)124);
                //UpdateStatus(data[0] + data[1]);

                UserConnection sender = (UserConnection)clients[data[0]];
                if (sender.PortNumber != portNum)
                    sender.PortNumber = portNum;
                
                sender.RemoteEnd = Remote;
                
                if (data.Length > 2)
                {
                    OnLineRecieved(sender, data[1] + "|" + data[2]);
                }
                else
                {
                    OnLineRecieved(sender, data[1]);
                }
            }
        }

        private void mainForm_Load(object sender, EventArgs e)
        {
            listenerThread = new Thread(ConnectionListen);
            listenerThread.IsBackground = true;
            listenerThread.Start();

            transThread = new Thread(receiveUDP);
            transThread.IsBackground = true;
            transThread.Start();
            UpdateStatus("Server Started");

        }

        private void SendToClients(string message, UserConnection sender)
        {
            UserConnection client;

            foreach (DictionaryEntry entry in clients)
            {
                client = (UserConnection)entry.Value;

                if (client.Name != sender.Name)
                {
                    client.SendData(message,trans);
                }
            }
        }

        private void SendChat(string message, UserConnection sender)
        {
            SendToClients("CHAT|" + sender.Name + ": " + message, sender);
            UpdateStatus(sender.Name + ": " + message);
        }

        private void ReplyToSender(string message, UserConnection sender)
        {
            sender.SendData(message,trans);
        }

        private void Broadcast(string message)
        {
            UserConnection client;

            foreach (DictionaryEntry entry in clients)
            {
                client = (UserConnection)entry.Value;
                client.SendData("BROAD|" + message,trans);
            }
        }

        private void mainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            transThread.Abort();
            listenerThread.Abort();
            //transmitter.Close();
            listener.Stop();
            clients.Clear(); 
        }

        public void UpdateStatus(string message)
        {
            if (this.textBox1.InvokeRequired)
            {
                SetTextCallback d = new SetTextCallback(UpdateStatus);
                this.Invoke(d, new object[] { message });
            }
            else
            {
                this.textBox1.AppendText(message);
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (textBox2.TextLength > 0)
            {
                Broadcast(textBox2.Text.ToString());
                textBox2.Clear();
            }
        }
        
    }
}


//UserConnection Class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Windows.Forms;

namespace AxiomTestServer_Alpha_0_02
{
        public struct PlayerLoc 
        {
            public string PosX;
            public string PosY;
            public string PosZ;
            public string RotX;
            public string RotY;
            public string RotZ;
        };

    public delegate void LineRecieve(UserConnection sender, string data);

    public class UserConnection
    {
        const int READ_BUFFER_SIZE = 255;
        private TcpClient client;
        private byte[] readBuffer = new byte[READ_BUFFER_SIZE];
        private string strName;
        public EndPoint RemoteEnd;
        public IPEndPoint ipep;
        public int PortNumber;
        IPAddress ipAdd;
        //Socket trans = new Socket(AddressFamily.InterNetwork,
                     //SocketType.Dgram, ProtocolType.Udp);
        
        public PlayerLoc Location = new PlayerLoc();

        public UserConnection(TcpClient client)
        {
            this.client = client;
            ipAdd = IPAddress.Parse(((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString());
            
            this.client.GetStream().BeginRead(readBuffer, 0, READ_BUFFER_SIZE, new AsyncCallback(StreamReciever), null);
        }
        
        public string Name
        {
            get
            {
                return strName;
            }

            set
            {
                strName = value;
            }
        }

        public event LineRecieve LineRecieved;


        public void Join()
        {
            StreamWriter writer = new StreamWriter(client.GetStream());
            writer.Write("JOIN");
            writer.Flush();
        }
        public void SendData(string data, Socket trans)
        {
            if (PortNumber != null)
            {
                //ipep = new IPEndPoint(IPAddress.Any, PortNumber);
                
                byte[] dataArr = Encoding.ASCII.GetBytes(data);

                trans.SendTo(dataArr, dataArr.Length, SocketFlags.None, RemoteEnd);
            }
        }

       public void UpdateLocation(string[] data)
       {
           if (data.Length > 6)
               return;
           else
           {
               Location.PosX = data[0];
               Location.PosY = data[1];
               Location.PosZ = data[2];
               Location.RotX = data[3];
               Location.RotY = data[4];
               Location.RotZ = data[5];
           }

       }    
            

       public void StreamReciever(IAsyncResult ar)
       {
           int bytesRead;
           string strMessage;

           try
           {
               lock (client.GetStream())
               {
                   bytesRead = client.GetStream().EndRead(ar);
               }

               strMessage = Encoding.ASCII.GetString(readBuffer, 0, bytesRead);
               LineRecieved(this, strMessage);

               lock (client.GetStream())
               {
                   client.GetStream().BeginRead(readBuffer, 0, READ_BUFFER_SIZE, new AsyncCallback(StreamReciever), null);
               }
           }
           catch (Exception e)
           {
               MessageBox.Show(e.Message.ToString());
           }
       }
	
      
    }
}