using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;
using System.Net;
using UnityEngine.SceneManagement;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.IO;

namespace VelNet
{
	[AddComponentMenu("VelNet/VelNet Manager")]
	public class VelNetBinaryManager : MonoBehaviour
	{
		public enum MessageSendType
		{
			LOGIN = 0,
			GET_ROOMS = 1,
			JOIN_ROOM = 2,
			MESSAGE_OTHERS = 3,
			MESSAGE_ALL = 4,
			MESSAGE_GROUP = 5,
			FORM_GROUP = 6
		};
		public enum MessageReceiveType
		{
			LOGGED_IN = 0,
			ROOM_LIST = 1,
			CLIENT_JOINED = 2,
			MESSAGE = 3
		};

		public string host;
		public int port;

		public static VelNetBinaryManager instance;

		private TcpClient socketConnection;
		private Socket udpSocket;
		public bool udpConnected;
		private IPEndPoint RemoteEndPoint;
		private Thread clientReceiveThread;
		private Thread clientReceiveThreadUDP;
		public int userid = -1;
		public string room;
		private int messagesReceived = 0;

		public readonly Dictionary<int, VelNetPlayer> players = new Dictionary<int, VelNetPlayer>();

		/// <summary>
		/// We just joined a room
		/// string - the room name
		/// </summary>
		public static Action<string> OnJoinedRoom;

		/// <summary>
		/// We just left a room
		/// string - the room name we left
		/// </summary>
		public static Action<string> OnLeftRoom;

		/// <summary>
		/// Somebody else just joined our room
		/// </summary>
		public static Action<VelNetPlayer> OnPlayerJoined;

		/// <summary>
		/// Somebody else just left our room
		/// </summary>
		public static Action<VelNetPlayer> OnPlayerLeft;

		public static Action OnConnectedToServer;
		public static Action<Message> MessageReceived;
		public static Action LoggedIn;
		public static Action<string[], int> RoomsReceived;

		public bool connected;

		public List<NetworkObject> prefabs = new List<NetworkObject>();
		public NetworkObject[] sceneObjects;
		public List<string> deletedSceneObjects = new List<string>();

		/// <summary>
		/// Maintains a list of all known objects on the server (ones that have ids)
		/// </summary>
		public readonly Dictionary<string, NetworkObject> objects = new Dictionary<string, NetworkObject>();

		/// <summary>
		/// Maintains a list of all known groups on the server
		/// </summary>
		public readonly Dictionary<string, List<int>> groups = new Dictionary<string, List<int>>();

		private VelNetPlayer masterPlayer;
		public static VelNetPlayer LocalPlayer => instance.players.Where(p => p.Value.isLocal).Select(p => p.Value).FirstOrDefault();
		public static bool InRoom => LocalPlayer != null && LocalPlayer.room != "-1" && LocalPlayer.room != "";


		// Use this for initialization
		public class Message
		{
			public MessageReceiveType type;
			//public string text;
			public byte[] data;
			public int sender;
		}

		

		public readonly List<Message> receivedMessages = new List<Message>();

		private void Awake()
		{
			if (instance != null)
			{
				Debug.LogError("Multiple NetworkManagers detected! Bad!", this);
			}

			instance = this;

			SceneManager.sceneLoaded += (scene, mode) =>
			{
				// add all local network objects
				sceneObjects = FindObjectsOfType<NetworkObject>().Where(o => o.isSceneObject).ToArray();
			};
		}

		private IEnumerator Start()
		{
			ConnectToTcpServer();
			yield return null;

			try
			{
				OnConnectedToServer?.Invoke();
			}
			// prevent errors in subscribers from breaking our code
			catch (Exception e)
			{
				Debug.LogError(e);
			}
		}


		private void AddMessage(Message m)
		{
			lock (receivedMessages)
			{
				//Debug.Log(messagesReceived++);
				receivedMessages.Add(m);
			}
		}

		private void Update()
		{
			lock (receivedMessages)
			{
				//the main thread, which can do Unity stuff
				foreach (Message m in receivedMessages)
				{
					switch (m.type)
					{
						// when you join the server
						case 0:
							userid = m.sender;
							Debug.Log("joined server " + userid);

							try
							{
								LoggedIn?.Invoke();
							}
							// prevent errors in subscribers from breaking our code
							catch (Exception e)
							{
								Debug.LogError(e);
							}

							//start the udp thread 
							clientReceiveThreadUDP = new Thread(ListenForDataUDP);
							clientReceiveThreadUDP.IsBackground = true;
							clientReceiveThreadUDP.Start();
							break;
						/*
						// if this message is for me, that means I joined a new room...
						case 2 when userid == m.sender:
							{
								string oldRoom = LocalPlayer?.room;

								// we clear the list, but will recreate as we get messages from people in our room
								players.Clear();
								masterPlayer = null;

								if (m.text != "")
								{
									VelNetPlayer player = new VelNetPlayer
									{
										isLocal = true,
										userid = m.sender,
										room = m.text
									};

									players.Add(userid, player);
									if (m.text != "")
									{
										try
										{
											OnJoinedRoom?.Invoke(m.text);
										}
										// prevent errors in subscribers from breaking our code
										catch (Exception e)
										{
											Debug.LogError(e);
										}
									}
								}
								// we just left a room
								else
								{
									// delete all networkobjects that aren't sceneobjects or are null now
									objects
										.Where(kvp => kvp.Value == null || !kvp.Value.isSceneObject)
										.Select(o => o.Key)
										.ToList().ForEach(NetworkDestroy);

									// then remove references to the ones that are left
									objects.Clear();

									// empty all the groups
									foreach (string group in instance.groups.Keys)
									{
										SetupMessageGroup(group, new List<int>());
									}

									instance.groups.Clear();

									try
									{
										OnLeftRoom?.Invoke(oldRoom);
									}
									// prevent errors in subscribers from breaking our code
									catch (Exception e)
									{
										Debug.LogError(e);
									}
								}

								break;
							}
						// not for me, a player is joining or leaving
						case 2:
							{
								VelNetPlayer me = players[userid];

								if (me.room != m.text)
								{
									// we got a left message, kill it
									// change ownership of all objects to master
									List<string> deleteObjects = new List<string>();
									foreach (KeyValuePair<string, NetworkObject> kvp in objects)
									{
										if (kvp.Value.owner == players[m.sender]) // the owner is the player that left
										{
											// if this object has locked ownership, delete it
											if (kvp.Value.ownershipLocked)
											{
												deleteObjects.Add(kvp.Value.networkId);
											}
											// I'm the local master player, so can take ownership immediately
											else if (me.isLocal && me == masterPlayer)
											{
												TakeOwnership(kvp.Key);
											}
											// the master player left, so everyone should set the owner null (we should get a new master shortly)
											else if (players[m.sender] == masterPlayer)
											{
												kvp.Value.owner = null;
											}
										}
									}

									// TODO this may check for ownership in the future. We don't need ownership here
									deleteObjects.ForEach(NetworkDestroy);

									players.Remove(m.sender);
								}
								else
								{
									// we got a join message, create it
									VelNetPlayer player = new VelNetPlayer
									{
										isLocal = false,
										room = m.text,
										userid = m.sender
									};
									players.Add(m.sender, player);
									try
									{
										OnPlayerJoined?.Invoke(player);
									}
									// prevent errors in subscribers from breaking our code
									catch (Exception e)
									{
										Debug.LogError(e);
									}
								}

								break;
							}
						// generic message
						case 3:
							if (players.ContainsKey(m.sender))
							{
								players[m.sender]?.HandleMessage(m);
							}
							else
							{
								Debug.LogError("Received message from player that doesn't exist: " + m.text);
							}

							break;
						// change master player (this should only happen when the first player joins or if the master player leaves)
						case 4:
							{
								if (masterPlayer == null)
								{
									masterPlayer = players[m.sender];

									// no master player yet, add the scene objects

									for (int i = 0; i < sceneObjects.Length; i++)
									{
										sceneObjects[i].networkId = -1 + "-" + i;
										sceneObjects[i].owner = masterPlayer;
										sceneObjects[i].isSceneObject = true; // needed for special handling when deleted
										objects.Add(sceneObjects[i].networkId, sceneObjects[i]);
									}
								}
								else
								{
									masterPlayer = players[m.sender];
								}

								masterPlayer.SetAsMasterPlayer();

								// master player should take over any objects that do not have an owner
								foreach (KeyValuePair<string, NetworkObject> kvp in objects)
								{
									kvp.Value.owner ??= masterPlayer;
								}

								break;
							}
						*/
					}

					MessageReceived?.Invoke(m);
				}

				receivedMessages.Clear();
			}
		}

		private void OnApplicationQuit()
		{
			socketConnection.Close();
		}

		/// <summary> 	
		/// Setup socket connection. 	
		/// </summary> 	
		private void ConnectToTcpServer()
		{
			try
			{
				clientReceiveThread = new Thread(ListenForData);
				clientReceiveThread.IsBackground = true;
				clientReceiveThread.Start();
			}
			catch (Exception e)
			{
				Debug.Log("On client connect exception " + e);
			}
		}

		private void HandleMessage(string s) // this parses messages from the server, and adds them to a queue to be processed on the main thread
		{
			/*
			// Debug.Log("Received: " + s);
			Message m = new Message();
			string[] sections = s.Split(':');
			if (sections.Length <= 0) return;

			int type = int.Parse(sections[0]);

			switch (type)
			{
				case 0: // logged in message
					{
						if (sections.Length > 1)
						{
							m.type = type;
							m.sender = int.Parse(sections[1]);
							m.text = "";
							AddMessage(m);
						}

						break;
					}
				case 1: // room info message
					{
						break;
					}
				case 2: // joined room message
					{
						if (sections.Length > 2)
						{
							m.type = 2;
							int user_id = int.Parse(sections[1]);
							m.sender = user_id;
							string new_room = sections[2];
							m.text = new_room;

							AddMessage(m);
						}

						break;
					}
				case 3: // text message
					{
						if (sections.Length > 2)
						{
							m.type = 3;
							m.sender = int.Parse(sections[1]);
							m.text = sections[2];
							AddMessage(m);
						}

						break;
					}
				case 4: // change master client
					{
						if (sections.Length > 1)
						{
							m.type = 4;
							m.sender = int.Parse(sections[1]);
							AddMessage(m);
						}

						break;
					}
			}*/
		}

		/// <summary> 	
		/// Runs in background clientReceiveThread; Listens for incomming data. 	
		/// </summary>     
		/// 
		private byte[] ReadExact(NetworkStream stream, int N)
		{
			byte[] toReturn = new byte[N];

			int numRead = 0;
			int numLeft = N;
			while (numLeft > 0)
			{
				numRead += stream.Read(toReturn, numRead, numLeft);
				numLeft = N - numRead;
			}
			return toReturn;
		}

		private uint GetUintFromBytes(byte[] bytes)
		{
			if (BitConverter.IsLittleEndian)
			{
				return BitConverter.ToUInt32(bytes.Reverse().ToArray(),0);
			}
			else
			{
				return BitConverter.ToUInt32(bytes, 0);
			}
		}
		private void ListenForData()
		{
			connected = true;
			try
			{
				socketConnection = new TcpClient(host, port);
				socketConnection.NoDelay = true;
				byte[] bytes = new byte[1024];

				Login("Kyle", "Johnsen");
				//Join("MyRoom");
				//SendTo(MessageSendType.MESSAGE_OTHERS, Encoding.UTF8.GetBytes("Hello"));
				//FormGroup("close", new List<uint> { 1 });
				//SendToGroup("close", Encoding.UTF8.GetBytes("HelloGroup"));
				while (true)
				{
					
					// Get a stream object for reading 				
					using NetworkStream stream = socketConnection.GetStream();
					int length;

					//read a byte
					byte type = (byte)stream.ReadByte();

					if(type == 0)
					{
						//read the id (this is my network id)
						
						Message m = new Message();
						m.sender = (int)GetUintFromBytes(ReadExact(stream, 4));
						m.data = new byte[0]; //no data
						m.type = 0;
						AddMessage(m);
						
					}
					else if(type == 1)
					{
						//rooms message
					}else if(type == 2)
					{
						//join message
					}else if(type == 3)
					{
						//message from client over tcp
					}

					// Read incomming stream into byte arrary. 					
					while ((length = stream.Read(bytes, 0, bytes.Length)) != 0)
					{
						Debug.Log("read " + length + " bytes!");
						string t = "";
						for(int i = 0; i < length; i++)
						{
							t = t + "," + bytes[i];
						}
						Debug.Log(t);
						//byte[] incommingData = new byte[length];
						//Array.Copy(bytes, 0, incommingData, 0, length);
						//// Convert byte array to string message. 						
						//string serverMessage = Encoding.ASCII.GetString(incommingData);
						//string[] sections = serverMessage.Split('\n');
						//if (sections.Length > 1)
						//{
						//	lock (receivedMessages)
						//	{
						//		for (int i = 0; i < sections.Length - 1; i++)
						//		{
						//			if (i == 0)
						//			{
						//				HandleMessage(partialMessage + sections[0]);
						//				partialMessage = "";
						//			}
						//			else
						//			{
						//				HandleMessage(sections[i]);
						//			}
						//		}
						//	}
						//}

						//partialMessage = partialMessage + sections[sections.Length - 1];
					}
				}
			}


			catch (Exception socketException)
			{
				Debug.Log("Socket exception: " + socketException);
			}

			connected = false;
		}

		private void ListenForDataUDP()
		{
			//I don't yet have a UDP connection
			try
			{
				IPAddress[] addresses = Dns.GetHostAddresses(host);
				Debug.Assert(addresses.Length > 0);
				RemoteEndPoint = new IPEndPoint(addresses[0], port);


				udpSocket = new Socket(AddressFamily.InterNetwork,
					SocketType.Dgram, ProtocolType.Udp);


				udpConnected = false;
				byte[] buffer = new byte[1024];
				while (true)
				{
					buffer[0] = 0;
					Array.Copy(get_be_bytes((uint)userid), 0, buffer, 1, 4);
					udpSocket.SendTo(buffer, 5, SocketFlags.None, RemoteEndPoint);

					if (udpSocket.Available == 0)
					{
						Thread.Sleep(100);
						Debug.Log("Waiting for UDP response");
					}
					else
					{
						break;
					}
				}

				udpConnected = true;
				while (true)
				{
					int numReceived = udpSocket.Receive(buffer);

					
					if (buffer[0] == 0)
					{
						Debug.Log("UDP connected");
					}else if (buffer[0] == 3)
					{
						//we should get the sender address
						byte[] senderBytes = new byte[4];
						Array.Copy(buffer, 1, senderBytes, 0, 4);
						uint senderId = GetUintFromBytes(senderBytes);
						byte[] messageBytes = new byte[numReceived - 5];
						Array.Copy(buffer, 5, messageBytes, 0, messageBytes.Length);
						Message m = new Message();
						m.sender = (int)senderId;
						m.data = messageBytes;
						m.type = MessageReceiveType.MESSAGE;
					}

					

					
				}
			}
			catch (Exception socketException)
			{
				Debug.Log("Socket exception: " + socketException);
			}
		}

		private static void SendUdpMessage(string message)
		{
			if (instance.udpSocket == null || !instance.udpConnected)
			{
				return;
			}

			byte[] data = Encoding.UTF8.GetBytes(message);
			//Debug.Log("Attempting to send: " + message);
			instance.udpSocket.SendTo(data, data.Length, SocketFlags.None, instance.RemoteEndPoint);
		}

		/// <summary> 	
		/// Send message to server using socket connection. 	
		/// </summary> 	
		private static void SendNetworkMessage(byte[] message)
		{
			// Debug.Log("Sent: " + clientMessage);
			if (instance.socketConnection == null)
			{
				return;
			}

			try
			{
				// Get a stream object for writing. 			
				NetworkStream stream = instance.socketConnection.GetStream();
				if (stream.CanWrite)
				{
					
					stream.Write(message,0,message.Length);
				}
			}
			catch (SocketException socketException)
			{
				Debug.Log("Socket exception: " + socketException);
			}
		}

		/// <summary>
		/// Connects to the server with a username
		/// </summary>
		/// 
		public static byte[] get_be_bytes(uint n)
		{
			return BitConverter.GetBytes(n).Reverse().ToArray();
		}
		public static void Login(string username, string password)
		{
			
			MemoryStream stream = new MemoryStream();
			BinaryWriter writer = new BinaryWriter(stream);
			
			byte[] uB = Encoding.UTF8.GetBytes(username);
			byte[] pB = Encoding.UTF8.GetBytes(password);
			writer.Write((byte)MessageSendType.LOGIN);
			writer.Write((byte)uB.Length);
			writer.Write(uB);
			writer.Write((byte)pB.Length);
			writer.Write(pB);

			SendNetworkMessage(stream.ToArray());
			

		}

		/// <summary>
		/// Joins a room by name
		/// </summary>
		/// <param name="roomname">The name of the room to join</param>
		public static void Join(string roomname)
		{
			MemoryStream stream = new MemoryStream();
			BinaryWriter writer = new BinaryWriter(stream);

			byte[] R = Encoding.UTF8.GetBytes(roomname);
			writer.Write((byte)MessageSendType.JOIN_ROOM);
			writer.Write((byte)R.Length);
			writer.Write(R);
			SendNetworkMessage(stream.ToArray());


			
			
		}

		public static void FormGroup(string groupname, List<uint> client_ids)
		{
			MemoryStream stream = new MemoryStream();
			BinaryWriter writer = new BinaryWriter(stream);
			byte[] R = Encoding.UTF8.GetBytes(groupname);
			writer.Write((byte)MessageSendType.FORM_GROUP);
			writer.Write((byte)R.Length);
			writer.Write(R);
			writer.Write(get_be_bytes((uint)client_ids.Count*4));
			for(int i = 0; i < client_ids.Count; i++)
			{
				writer.Write(get_be_bytes(client_ids[i]));
			}
			SendNetworkMessage(stream.ToArray());
		}

		/// <summary>
		/// Leaves a room if we're in one
		/// </summary>
		public static void Leave()
		{
			//if (InRoom) SendNetworkMessage("2:-1");
		}

		public static void SendTo(MessageSendType type, byte[] message, bool reliable = true)
		{
			MemoryStream stream = new MemoryStream();
			BinaryWriter writer = new BinaryWriter(stream);

			writer.Write((byte)3);
			writer.Write(get_be_bytes((uint)message.Length));
			writer.Write(message);

			if (reliable)
			{
				SendNetworkMessage(stream.ToArray());

				//SendNetworkMessage("3:" + (int)type + ":" + message);
			}
			else
			{
				SendUdpMessage(instance.userid + ":3:" + (int)type + ":" + message);
			}
		}

		public static void SendTo(MessageSendType type, string message, bool reliable = true)
		{
			if (reliable)
			{
				//SendNetworkMessage("3:" + (int)type + ":" + message);
			}
			else
			{
				SendUdpMessage(instance.userid + ":3:" + (int)type + ":" + message);
			}
		}

		public static void SendToGroup(string group, byte[] message, bool reliable = true)
		{
			MemoryStream stream = new MemoryStream();
			BinaryWriter writer = new BinaryWriter(stream);

			writer.Write((byte)MessageSendType.MESSAGE_GROUP);
			writer.Write(get_be_bytes((uint)message.Length));
			writer.Write(message);
			writer.Write((byte)group.Length);
			writer.Write(Encoding.UTF8.GetBytes(group));

			if (reliable)
			{
				SendNetworkMessage(stream.ToArray());

				//SendNetworkMessage("3:" + (int)type + ":" + message);
			}
			else
			{
				//SendUdpMessage(instance.userid + ":3:" + (int)type + ":" + message);
			}
		}

		public static void SendToGroup(string group, string message, bool reliable = true)
		{
			if (reliable)
			{
				//SendNetworkMessage("4:" + group + ":" + message);
			}
			else
			{
				SendUdpMessage(instance.userid + ":4:" + group + ":" + message);
			}
		}

		/// <summary>
		/// changes the designated group that sendto(4) will go to
		/// </summary>
		public static void SetupMessageGroup(string groupName, List<int> userIds)
		{
			if (userIds.Count > 0)
			{
				instance.groups[groupName] = userIds.ToList();
			}

			//SendNetworkMessage($"5:{groupName}:{string.Join(":", userIds)}");
		}


		public static NetworkObject InstantiateNetworkObject(string prefabName)
		{
			VelNetPlayer localPlayer = LocalPlayer;
			NetworkObject prefab = instance.prefabs.Find(p => p.name == prefabName);
			if (prefab == null)
			{
				Debug.LogError("Couldn't find a prefab with that name: " + prefabName);
				return null;
			}

			string networkId = localPlayer.userid + "-" + localPlayer.lastObjectId++;
			if (instance.objects.ContainsKey(networkId))
			{
				Debug.LogError("Can't instantiate object. Obj with that network ID was already instantiated.", instance.objects[networkId]);
				return null;
			}
			NetworkObject newObject = Instantiate(prefab);
			newObject.networkId = networkId;
			newObject.prefabName = prefabName;
			newObject.owner = localPlayer;
			instance.objects.Add(newObject.networkId, newObject);

			// only sent to others, as I already instantiated this.  Nice that it happens immediately.
			SendTo(MessageSendType.MESSAGE_OTHERS, "7," + newObject.networkId + "," + prefabName);

			return newObject;
		}

		public static void SomebodyInstantiatedNetworkObject(string networkId, string prefabName, VelNetPlayer owner)
		{
			NetworkObject prefab = instance.prefabs.Find(p => p.name == prefabName);
			if (prefab == null) return;
			NetworkObject newObject = Instantiate(prefab);
			newObject.networkId = networkId;
			newObject.prefabName = prefabName;
			newObject.owner = owner;
			instance.objects.Add(newObject.networkId, newObject);
		}

		public static void NetworkDestroy(NetworkObject obj)
		{
			NetworkDestroy(obj.networkId);
		}

		public static void NetworkDestroy(string networkId)
		{
			if (!instance.objects.ContainsKey(networkId)) return;
			NetworkObject obj = instance.objects[networkId];
			if (obj == null)
			{
				instance.objects.Remove(networkId);
				return;
			}
			if (obj.isSceneObject)
			{
				instance.deletedSceneObjects.Add(networkId);
			}

			Destroy(obj.gameObject);
			instance.objects.Remove(networkId);
		}

		/// <summary>
		/// Takes local ownership of an object by id.
		/// </summary>
		/// <param name="networkId">Network ID of the object to transfer</param>
		/// <returns>True if successfully transferred, False if transfer message not sent</returns>
		public static bool TakeOwnership(string networkId)
		{
			// local player must exist
			if (LocalPlayer == null) return false;

			// obj must exist
			if (!instance.objects.ContainsKey(networkId)) return false;

			// if the ownership is locked, fail
			if (instance.objects[networkId].ownershipLocked) return false;

			// immediately successful
			instance.objects[networkId].owner = LocalPlayer;

			// must be ordered, so that ownership transfers are not confused.  Also sent to all players, so that multiple simultaneous requests will result in the same outcome.
			SendTo(MessageSendType.MESSAGE_ALL, "6," + networkId);

			return true;
		}
	}
}