using UnityEngine;
using System.Collections;
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;

class TCPListener
{

		public static string ip = "192.168.43.165";

		public static void Main ()
		{ 
				TcpListener server = null;   
				try {
						// Set the TcpListener on port 13000.
						Int32 port = 13000;
						IPAddress localAddr = IPAddress.Parse (ip);
			
						// TcpListener server = new TcpListener(port);
						server = new TcpListener (localAddr, port);
			
						// Start listening for client requests.
						server.Start ();
			
						// Buffer for reading data
						Byte[] bytes = new Byte[256];
						String data = null;

						Debug.Log (ip + port.ToString ());
			
						// Enter the listening loop. 
						while (true) {
								Debug.Log ("Waiting for a connection... ");
				
								// Perform a blocking call to accept requests. 
								// You could also user server.AcceptSocket() here.
								TcpClient client = server.AcceptTcpClient ();            
								Debug.Log ("Connected!");
				
								data = null;
				
								// Get a stream object for reading and writing
								NetworkStream stream = client.GetStream ();
				
								int i;
				
								// Loop to receive all the data sent by the client. 
								while ((i = stream.Read(bytes, 0, bytes.Length))!=0) {   
										// Translate data bytes to a ASCII string.
										data = System.Text.Encoding.ASCII.GetString (bytes, 0, i);
										Debug.Log ("Received: {0} " + data);
										lock (Server.position) {
												Server.isInitialized = true;
												Server.position.ToPosition (data);
										}
								}
						}
				} catch (SocketException e) {
						Debug.Log ("SocketException: {0}" + e.ToString ());
				} finally {
						// Stop listening for new clients.
						//server.Stop();
						// Shutdown and end connection
						//client.Close();
				}
		
		
				Debug.Log ("\nHit enter to continue...");
				//Console.Read();
		} 

		public static NetworkStream Connect (String server)
		{
				try {
						// Create a TcpClient. 
						// Note, for this client to work you need to have a TcpServer  
						// connected to the same address as specified by the server, port 
						// combination.
						Int32 port = 13000;
						TcpClient client = new TcpClient (server, port);
         	
						// Get a client stream for reading and writing. 
						//  Stream stream = client.GetStream();
						NetworkStream stream = client.GetStream ();

						return stream;        
				} catch (ArgumentNullException e) {
						Debug.Log ("ArgumentNullException: {0}" + e.ToString ());
				} catch (SocketException e) {
						Debug.Log ("SocketException: {0}" + e.ToString ());
				}

				Debug.Log ("\n Press Enter to continue...");
				//Console.Read();
				return null;		
		}

		public static void SendMessage (string message, NetworkStream stream)
		{
				try {
						// Translate the passed message into ASCII and store it as a Byte array.
						Byte[] data = System.Text.Encoding.ASCII.GetBytes (message); 

						// Send the message to the connected TcpServer. 
						stream.Write (data, 0, data.Length);
			
						Debug.Log ("Sent: {0}" + message);         
			
						// Receive the TcpServer.response. 
			
						/*
			// Buffer to store the response bytes.
			data = new Byte[256];
			
			// String to store the response ASCII representation.
			String responseData = String.Empty;
			
			// Read the first batch of the TcpServer response bytes.
			Int32 bytes = stream.Read(data, 0, data.Length);
			responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
			Debug.Log("Received: {0}" + responseData);    
			*/     
				} catch (ArgumentNullException e) {
						Debug.Log ("ArgumentNullException: {0}" + e.ToString ());
				} catch (SocketException e) {
						Debug.Log ("SocketException: {0}" + e.ToString ());
				} finally {
						// Close everything.
						//client.Close();  
						//stream.Close();         
				}		
		}
}

