/* 
*  This file is part of the Unity networking tutorial by M2H (http://www.M2H.nl)
*  The original author of this code is Mike Hergaarden, even though some small parts 
*  are copied from the Unity tutorials/manuals.
*  Feel free to use this code for your own projects, drop us a line if you made something exciting! 
*/
#pragma strict

public var gameName = "Example2";
public var serverPort =  35001;

public var hostData : HostData[];

private var natCapable : ConnectionTesterStatus = ConnectionTesterStatus.Undetermined;
public var filterNATHosts = false;
private var probingPublicIP = false;
private var doneTestingNAT = false;
private var timer : float = 0.0;

private var hideTest = false;
private var testMessage = "Undetermined NAT capabilities";

private var tryingToConnectPlayNow : boolean = false;
public var tryingToConnectPlayNowNumber : int = 0;

private var remotePort : int[] = new int[3];
private var remoteIP : String[] = new String[3];
public var connectionInfo : String = "";

public var lastMSConnectionAttemptForcedNat : boolean= false;
private var NAToptionWasSwitchedForTesting : boolean = false;
private var officialNATstatus : boolean = Network.useNat;
public var errorMessage : String = "";
private var lastPlayNowConnectionTime : float;

public var nowConnecting : boolean = false;

function Awake ()
{
	sortedHostList = new Array ();
	
	// Start connection test
	natCapable = Network.TestConnection();
		
	// What kind of IP does this machine have? TestConnection also indicates this in the
	// test results
	if (Network.HavePublicAddress()){
		Debug.Log("This machine has a public IP address");
	}else{
		Debug.Log("This machine has a private IP address");
	}	
	
	/* //If you dont want to use the Unity masterserver..
	Network.natFacilitatorIP = myMasterServerIP;
	Network.natFacilitatorPort = 11111;//Change this
	MasterServer.ipAddress = myMasterServerIP;
	MasterServer.port = 22222;//Change this
	Network.connectionTesterIP = myMasterServerIP;
	Network.connectionTesterPort = 33333;//Change this
	*/
	
	
}

function Start(){//must be in start because of coroutine
		
	yield WaitForSeconds(0.5);
	var tries : int=0;
	while(tries<=10){		
		if(hostData && hostData.length>0){
			//Waiting for hostData
		}else{
			FetchHostList(true);
		}
		yield WaitForSeconds(0.5);
		tries++;
	}
}


function OnFailedToConnectToMasterServer(info: NetworkConnectionError)
{
	//Yikes
}

function OnFailedToConnect(info: NetworkConnectionError)
{
	Debug.Log("FailedToConnect info:"+info);
	FailedConnRetry(info);		
}

function Connect(ip : String, port : int, usenat : boolean){
	// Enable NAT functionality based on what the hosts if configured to do
	Network.useNat = usenat;
	lastMSConnectionAttemptForcedNat = usenat;
	
	Debug.Log("Connecting to "+ip+":"+port+" NAT:"+usenat);
	Network.Connect(ip, port);		
	nowConnecting=true;	
}

//This second definition of Connect can handle the ip string[] passed by the masterserver
function Connect(ip : String[], port : int, usenat : boolean){
	// Enable NAT functionality based on what the hosts if configured to do
	Network.useNat = usenat;
	lastMSConnectionAttemptForcedNat = usenat;
	
	Debug.Log("Connecting to "+ip[0]+":"+port+" NAT:"+usenat);
	Network.Connect(ip, port);		
	nowConnecting=true;	
}

function StartHost(players : int, port : int){
	if(players<=1){
		players=1;
	}
	//Network.InitializeSecurity();
	Network.InitializeServer(players, port);
}

function OnConnectedToServer(){
	//Stop communication until in the game
	Network.isMessageQueueRunning = false;

	//Save these details so we can use it in the next scene
	PlayerPrefs.SetString("connectIP", Network.connections[0].ipAddress);
	PlayerPrefs.SetInt("connectPort", Network.connections[0].port);
}

function FailedConnRetry(info: NetworkConnectionError){
	if(info == NetworkConnectionError.InvalidPassword){
		mayRetry=false;
	}
	
	
	nowConnecting=false;
	
	//Quickplay
	if(tryingToConnectPlayNow){
		//Try again without NAT if we used NAT
		if(mayRetry && Network.useNat && lastMSConnectionAttemptForcedNat){
			Debug.Log("Failed connect 1A: retry without NAT");
		
			remotePort[0]=serverPort;//Fall back to default server port
			Connect(remoteIP, remotePort[0], false);
			lastPlayNowConnectionTime=Time.time;
		}else{
			//We didn't use NAT and failed
			Debug.Log("Failed connect 1B: Don't retry");
		
			//Reset NAT to org. value
			Network.useNat=officialNATstatus;
						
			//Connect to next playnow/quickplay host
			tryingToConnectPlayNowNumber++;
			tryingToConnectPlayNow=false;
		}
	}else{
		//Direct connect or via host list manually
		connectionInfo="Failed to connect!";
		
		if(mayRetry && Network.useNat && lastMSConnectionAttemptForcedNat){
			//Since the last connect forced NAT usage,
			// let's try again without NAT.		
			Network.useNat=false;
			Network.Connect(remoteIP, remotePort[0]);
			nowConnecting=true;
			lastPlayNowConnectionTime=Time.time;
			
		}else{
			Debug.Log("Failed 2b");
		
			if(info == NetworkConnectionError.InvalidPassword){
				errorMessage="Failed to connect: Wrong password supplied";
			}else if(info == NetworkConnectionError.TooManyConnectedPlayers){
				errorMessage="Failed to connect: Server is full";
			}else{
				errorMessage="Failed to connect";
			}
			
			//reset to default port
			remotePort[0]=serverPort;
			
			//Reset nat to tested value
			Network.useNat=officialNATstatus;
			
		}
	}	
}

public var CONNECT_TIMEOUT : float = 0.75;
public var CONNECT_NAT_TIMEOUT : float = 5.00;

//Our quickplay function: Go trough the gameslist and try to connect to all games
function PlayNow(timeStarted : float ){
	
		var i : int=0;
		
		for (var myElement in sortedHostList)
		{
			var element=hostData[myElement];
		
			// Do not try NAT enabled games if we cannot do NAT punchthrough
			// Do not try connecting to password protected games
			if ( !(filterNATHosts && element.useNat) && !element.passwordProtected  )
			{
				aHost=1;
								
				if(element.connectedPlayers<element.playerLimit)
				{					
					if(tryingToConnectPlayNow){
						var natText;
						if(Network.useNat){
							natText=" with option 1/2";
						}else{
							natText=" with option 2/2";
						}
						if((!Network.useNat && lastPlayNowConnectionTime+CONNECT_TIMEOUT<=Time.time) || (Network.useNat  && lastPlayNowConnectionTime+CONNECT_NAT_TIMEOUT<=Time.time)){
							Debug.Log("Interrupted by timer, NAT:"+Network.useNat);
							FailedConnRetry(NetworkConnectionError.ConnectionFailed);							
						}
						return "Trying to connect to host "+(tryingToConnectPlayNowNumber+1)+"/"+sortedHostList.length+" "+natText;	
					}		
					if(!tryingToConnectPlayNow && tryingToConnectPlayNowNumber<=i){
						Debug.Log("Trying to connect to game NR "+i+" & "+tryingToConnectPlayNowNumber);
						tryingToConnectPlayNow=true;
						tryingToConnectPlayNowNumber=i;
						
						// Enable NAT functionality based on what the hosts if configured to do
						lastMSConnectionAttemptForcedNat=element.useNat;
						Network.useNat = element.useNat;
						var connectPort : int=element.port;
						if (Network.useNat){
							print("Using Nat punchthrough to connect");
						}else{
							//connectPort=serverPort; //bad idea!
							print("Connecting directly to host");
						}
						Debug.Log("connecting to "+element.gameName+" "+element.ip+":"+connectPort);
						Network.Connect(element.ip, connectPort);	
						lastPlayNowConnectionTime=Time.time;
					}
					i++;		
				}
			}			
		}
		
		//If we reach this point then either we've parsed the whole list OR the list is still empty
		
		//Dont give up yet: Give MS 7 seconds to feed the list
		if(Time.time<timeStarted+7){
			FetchHostList(true);	
			return "Waiting for masterserver..."+Mathf.Ceil((timeStarted+7)-Time.time);	
		}
		
		if(!tryingToConnectPlayNow){
			return "failed";
		}
		
	
}


function Update() {
	// If network test is undetermined, keep running
	if (!doneTestingNAT) {
		TestConnection();
	}
}

function TestConnection() {
	// Start/Poll the connection test, report the results in a label and react to the results accordingly
	natCapable = Network.TestConnection();
	switch (natCapable) {
		case ConnectionTesterStatus.Error: 
			testMessage = "Problem determining NAT capabilities";
			doneTestingNAT = true;
			break;
			
		case ConnectionTesterStatus.Undetermined: 
			testMessage = "Undetermined NAT capabilities";
			doneTestingNAT = false;
			break;
			
		case ConnectionTesterStatus.PrivateIPNoNATPunchthrough: 
			testMessage = "Cannot do NAT punchthrough, filtering NAT enabled hosts for client connections, local LAN games only.";
			filterNATHosts = true;
			Network.useNat = true;
			doneTestingNAT = true;
			break;
			
		case ConnectionTesterStatus.PrivateIPHasNATPunchThrough:
			if (probingPublicIP)
				testMessage = "Non-connectable public IP address (port "+ serverPort +" blocked), NAT punchthrough can circumvent the firewall.";
			else
				testMessage = "NAT punchthrough capable. Enabling NAT punchthrough functionality.";
			// NAT functionality is enabled in case a server is started,
			// clients should enable this based on if the host requires it
			Network.useNat = true;
			doneTestingNAT = true;
			break;
			
		case ConnectionTesterStatus.PublicIPIsConnectable:
			testMessage = "Directly connectable public IP address.";
			Network.useNat = false;
			doneTestingNAT = true;
			break;
			
		// This case is a bit special as we now need to check if we can 
		// cicrumvent the blocking by using NAT punchthrough
		case ConnectionTesterStatus.PublicIPPortBlocked:
			testMessage = "Non-connectble public IP address (port " + serverPort +" blocked), running a server is impossible.";
			Network.useNat = false;
			// If no NAT punchthrough test has been performed on this public IP, force a test
			if (!probingPublicIP)
			{
				Debug.Log("Testing if firewall can be circumnvented");
				natCapable = Network.TestConnectionNAT();
				probingPublicIP = true;
				timer = Time.time + 10;
			}
			// NAT punchthrough test was performed but we still get blocked
			else if (Time.time > timer)
			{
				probingPublicIP = false; 		// reset
				Network.useNat = true;
				doneTestingNAT = true;
			}
			break;
		case ConnectionTesterStatus.PublicIPNoServerStarted:
			testMessage = "Public IP address but server not initialized, it must be started to check server accessibility. Restart connection test when ready.";
			break;
		default: 
			testMessage = "Error in test routine, got " + natCapable;
	}
	officialNATstatus=Network.useNat;
	if(doneTestingNAT){
		Debug.Log("TestConn:"+testMessage);
		Debug.Log("TestConn:"+natCapable + " " + probingPublicIP + " " + doneTestingNAT);
	}
}

private var lastHostListRequest : float = 0;

//Request the host limit, but we limit these requests
//Max once every two minutes automatically, max once every 5 seconds when manually requested
function FetchHostList(manual : boolean){
	var timeout : int = 120;
	if(manual){
		timeout=5;
	}
	
	if(lastHostListRequest==0 || Time.realtimeSinceStartup > lastHostListRequest + timeout){
			lastHostListRequest = Time.realtimeSinceStartup;
			MasterServer.RequestHostList (gameName);			
			yield WaitForSeconds(1);//We gotta wait :/			
			hostData = MasterServer.PollHostList();
			yield WaitForSeconds(1);//We gotta wait :/	
			CreateSortedArray();
			Debug.Log("Requested new host list, got: "+hostData.length);
	}
	
	
		
}

//The code below is all about sorting the game list by playeramount

public var sortedHostList : Array;

function CreateSortedArray(){
	
	sortedHostList = new Array();	
	
	var i : int=0;
	var data : HostData[] = hostData;
	for (var element in data)
	{
		AddToArray(i);
		i++;		
	}			
}

function AddToArray(nr : int){
	sortedHostList.Add (nr);	
	SortLastItem();
}

function SortLastItem(){
	if(sortedHostList.length<=1){
		return;
	}
	for(var i=sortedHostList.length-1;i>0;i--){
	var value1 : int= hostData[sortedHostList[i-1]].connectedPlayers;
	var value2 : int = hostData[sortedHostList[i]].connectedPlayers;
		if(value1<value2){
			SwapArrayItem((i-1), i);
		}else{
			//Sorted!
			return;
		}
	}
}

function SwapArrayItem(nr1, nr2){
	var tmp=sortedHostList[nr1];
	sortedHostList[nr1]=sortedHostList[nr2];
	sortedHostList[nr2]=tmp;
}