package com.safemobile.services;
import java.io.*;
import java.net.*;
import java.nio.charset.Charset;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Timer;
import java.util.TimerTask;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;

import com.safemobile.lib.AppParams;
import com.safemobile.lib.SM;
import com.safemobile.lib.TCPmsg;


public class TCPhandler implements Runnable
{
	private boolean alive = true;
	
	public String serverHostname = new String ("10.120.1.114");//
	private int port = 13579;
	private Thread listenThread;
	private Socket soc =null;
	
	//private BufferedReader recv;
	//private PrintWriter writer;
	
	private DataInputStream input;
	private DataOutputStream output;
	private Timer timer;
	
	private String leftOver = "";
	
	public static LinkedList<TCPmsg> msgList;
	private volatile int n=0;
	
	public Boolean isConnectionUP = false;
	public Boolean previousConnectionWasUP = false;
	
	private Context context;
	private boolean isWiFiOn = true;
	
	public TCPhandler(Context context, String hostName, int p)
	{
		
		this.context = context;
		serverHostname=hostName;
		port=p;

		msgList = new LinkedList<TCPmsg>();
		SM.Debug("---TCPhandler constructor [" + hostName + "," + p + "] ---");
		listenThread = new Thread(this, "TCPlisten"); 		
		listenThread.start(); // (2) Start the thread.
	
		
		// create timer to check socket status
		timer = new Timer();
		timer.scheduleAtFixedRate(new TimerTask() {
		@Override
		public void run() {
			try {
				//Looper.prepare();
				//mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
				// get if is authenticated
				//Write("0.0", "d");
				previousConnectionWasUP = isConnectionUP;
				
				// try to send something 
				TCPmsgParser._fireonTCPConnectionStatusEvent(isConnectionUP, previousConnectionWasUP);
				} 
				catch (Exception e) {
					//e.printStackTrace();
					SM.Exception("TIMERException", e.toString());
				}
			}
		}, 0, 3000);
		
		// get WiFi state 
		ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
		if(mWifi.isConnectedOrConnecting())
			isWiFiOn = true;
		
		IntentFilter intentFilter = new IntentFilter();
		intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
		context.registerReceiver(mReceived, intentFilter);
	}
	
	@Override
	public void run() 
	{
			try 
			{		
				if(soc!=null)
					soc.close();
				
				soc = new Socket();
				soc.connect(new InetSocketAddress(serverHostname, port), 5000); 
				
				//soc.setSoTimeout(3000);
				//SM.Debug("Socket timeout:" + soc.getSoTimeout() );
				//soc.setSoTimeout(5000);
				
				input = new DataInputStream(soc.getInputStream());
				output = new DataOutputStream(soc.getOutputStream());
				
				//recv= new BufferedReader(new InputStreamReader(soc.getInputStream()));
				//writer =new PrintWriter(soc.getOutputStream()) ;
				
				
				if(soc !=null) {
					//previousConnectionWasUP = isConnectionUP;
					isConnectionUP = true;
					triggerTCPConnectionStateEvent();
				}
				
			} 
			catch (UnknownHostException e) 
			{
				SM.Debug("UnknownHostException", "TCPhandler break:"+e.toString()); 
			} 
			catch (IllegalArgumentException e) 
			{
				SM.Debug("IllegalArgumentException", "TCPhandler break:"+e.toString()); 
			} 
			catch (IOException e) 
			{
				SM.Debug("IOException", "TCPhandler break:"+e.toString());
			}
		
		while(alive)
		{
			//SM.Debug("Waiting for data...");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				SM.Debug("TCPhandler Crash1 on sleep:"+e.toString());
			}
			
			while(isConnectionUP)
			{
				try
				{
					Thread.sleep(100);	
					//SM.Debug("Waiting for data...");
				//process leftover 
				try
				{	
					boolean FinishLeftOver =true;
				while (FinishLeftOver)
				{
					// add this replacement if message length doesn't contain the last #
					// leftOver = leftOver.replace("##", "#");
			    	String[] tempArr2 = leftOver.split("#");
			        if (tempArr2.length > 1)
			        {			         
			        	int messLen;
			        	try 
			        	{
			        		messLen = Integer.parseInt(tempArr2[1]);
			        		
			        		//TODO talk to Gaby to fix this on Bridge
			        		
			        	} 
			        	catch (Exception e) 
			        	{
			        		SM.Debug("leftovers", "incorect msg len leftOver =" + tempArr2[1]);
			        		messLen =-1;
			        	} 
			        	
			        	  if(messLen>leftOver.length()) 
			        	  {
			        		  FinishLeftOver =false;
			        		  break;
			        	  }
			        	  else if(messLen==leftOver.length()) 
			        	  {
			        		  TCPmsg msg = new TCPmsg(leftOver.toCharArray());					
				        	  SM.Debug("leftovers", "RX from leftOver:"+msg.allData);
				        	  
				        	  if(msg.allData.contains("#92#"))
									prioritizePongReceived();
				        	  
				        	  msgList.add(msg);
				        	  leftOver ="";
			        		  FinishLeftOver =false;
			        		  break;
			        	  } 
			        	  else // we have more message in leftover 
			        	  {			        		  
			        		  TCPmsg msg = new TCPmsg(leftOver.substring(0,messLen).toCharArray());
			        		  SM.Debug("leftovers", "RX from leftOver:"+msg.allData);
			        		  
			        		  if(msg.allData.contains("#92#"))
									prioritizePongReceived();
			        		  
				        	  msgList.add(msg);
			        		  leftOver = leftOver.substring(messLen,leftOver.length());
			        	  }				        					        			        	
			        }
			        else FinishLeftOver = false;
				}
				}
				catch (Exception e) 
				{
					SM.Debug("leftovers", "Error on process leftover"+e.toString());
				}
					//end process leftover
					
					String data ="";
					n=0;
					//char[] buf = new char[1024];	
					//n  = recv.read(buf);
					
					byte[] buf = new byte[1024];
					// read data into buffer
					n = input.read(buf);
					//connection closed by server
					if(n==-1)
					{
						SM.Debug("TCP Client", "Connection closed by server!");
						soc.close();
						//previousConnectionWasUP = isConnectionUP;
						isConnectionUP = false;
						triggerTCPConnectionStateEvent();
						soc = null;
						break;
					}
					
					
					byte[] temp = new byte[n];
			    	for(int i=0;i<n;i++) temp[i] = buf[i];
			    	//String data =new String(temp);
			    	
			    	// decryptData 
			    	temp = decryptTEA(temp);
			    	
			    	data = new String(temp);

			        //if we have any leftovers from previous message add them
			    	if(leftOver.length()>1) // avoid case with only one #
			    	{
			    		data = leftOver+data;
			    		leftOver = "";
			    	}
			    	
			    	//search for overflow message
			    	String[] tempArr = data.split("#");
			        if ((tempArr.length == 0) || (tempArr.length == 1))
			        {
			            SM.Debug("TCP Client", "incorect messagebuss message=" + data);
			            continue;
			        }
			        //get msg len
			       // for(int i=0;i<tempArr.length;i++)
			       // 	SM.Debug("I:"+i+" tempArr[i]:"+tempArr[i]);
			        int messLen;
					try {
						messLen = Integer.parseInt(tempArr[1]);						
					} catch (Exception e) {
						SM.Debug("TCP Client", "incorect msg len =" + tempArr[1]);
						continue;
					} 					
			        //messLen not int
			        if(messLen == -1) 
		        	{
		        		//SM.Debug("messLen not int=" + messLen +" tempArr[1]:" +tempArr[1]);
		        		continue;
		        	}
			        char[] temMSG = data.toCharArray();
			        //SM.Debug("MessLen:"+messLen+" Data len:"+data.length()+"IF:"+(data.length() != messLen));
			        if (data.length() != messLen)			        
			        {
			        	//if expected string message is smaller then actual string then exit processing;
			        	if(messLen>data.length())
			        	//if(messLen>n)
		        		{
			        		//SM.Debug("duda","messLen=" + messLen +" data.length():" +data.length()+"n:"+n);
			        		leftOver = data; // Add by bigu 
		        			continue;		        		
		        		}
			        	//perform cut 
			        	//SM.Debug("We got leftover ....message length("+messLen+") != actual length("+data.length()+")");
			        	temMSG = data.substring(0,messLen).toCharArray();
			        	//SM.Debug("temMSG:"+temMSG.toString());
			        	leftOver = data.substring(messLen,data.length());
			        	//SM.Debug("leftOver:"+leftOver);
			        	//leftOver = data.substring(messLen,n);
			        	//SM.Debug("left over string:"+leftOver);
			        }
					//decode TCP msg
					TCPmsg msg = new TCPmsg(temMSG);
					
					SM.Debug("������� RX �������", msg.allData);
					
					if(msg.allData.contains("#92#"))
						prioritizePongReceived();
					
					msgList.add(msg);
					
				}
				catch(Exception ex)
				{
					SM.Debug("TCPHandler", "TCPhandler/run/break:"+ex.toString());
					//previousConnectionWasUP = isConnectionUP;
					isConnectionUP = false;
					triggerTCPConnectionStateEvent();
				}
			}//while(connOK)
			
			
			//
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				SM.Debug("TCPhandler Crash2 on sleep:"+e.toString());
				//previousConnectionWasUP = isConnectionUP;
			}
			
			//try to restart connection
			if(alive && isWiFiOn)
				RestartTCP();
			
		}//while(alive)
		SM.Debug("==================================");
		SM.Debug("TCP listenThread stoped!! alive = false");
		SM.Debug("==================================");
	}
	
	
	/**
	 * Create a bypass in order to trigger the ping received event 
	 */
	private void prioritizePongReceived() {
		TCPmsgParser._firePONGReceivedEvent();
	}
	
	
	/* Broadcast Received for WiFi Connect/Disconnect */
	public BroadcastReceiver mReceived = new BroadcastReceiver() {
		
		@Override
		public void onReceive(Context context, Intent intent) {
		    final String action = intent.getAction();
		    SM.Debug("WIFI STATE", action);
		    
		    if(action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)){
		        NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
		        // close socket if the wifi is disconnecting or disconnected 
		        if(!info.isConnectedOrConnecting()) {
		        	closeSocket();
		        	isWiFiOn = false;
		        }
		        else 
		        	isWiFiOn = true;
		    }      
		}
	};
	
	
	
	/** Send a message through the TCP Socket 
	 * @param seqID The messages's sequence ID (a number of order)
	 * @param msg The messages which will be sent
	 * @return True if the message was sent
	 */
	public boolean Write(String seqID, String msg)
	{
		
		try 
		{
			
			/*
			if(writer != null)
			{
				String cmdok = "#" + seqID + msg; 
				Integer tmp = cmdok.length() + 1; 
				//SM.Debug("tmp:"+tmp);
				
				tmp += Integer.toString(tmp).length();// tmp.ToString().Length; 
				if((tmp==10)||(tmp==100)||(tmp==1000)) tmp++;
				cmdok = "#" + Integer.toString(tmp) + cmdok;
				writer.write(encryptTEA(cmdok));
				writer.flush();
				SM.Debug("TX:"+encryptTEA(cmdok));
				return true;
			}*/
			
			if(output != null)
			{
				try {
					Thread.sleep(10);
					String cmdok = "#" + seqID + msg; 
					Integer tmp = cmdok.length() + 1; 
					//SM.Debug("tmp:"+tmp);

					tmp += Integer.toString(tmp).length();// tmp.ToString().Length; 
					if((tmp==10)||(tmp==100)||(tmp==1000)) tmp++;
					cmdok = "#" + Integer.toString(tmp) + cmdok;

					byte[] mess = encryptTEA(cmdok);
					
					
					output.write(mess);
					output.flush();
					
					// show only notACK messages
					//if(mess[3] != 0x0C)
					SM.Debug(" ", new String(mess));
					return true;
				}
			catch (IOException e) {
				//e.printStackTrace();
				SM.Exception("TCPClient[Send]", e.toString());
			} catch (InterruptedException e) {
				SM.Exception("TCPClient[Send]", e.toString());
			} catch (NoSuchElementException e) {
				SM.Exception("TCPClient[Send]", e.toString());
			}
			}
			else
			{
				return false;
			}
		} 
		catch (Exception e) 
		{
			SM.Debug("TCPhandler Write Procedure:"+e.toString());
		}
		return false;
	}
	
	
	public void setConnectionIsDown() {
		if(input != null) {
			try {
				input.close();
			} catch (IOException e) {
			}
			finally {
				input = null;
			}
		}
		
		isConnectionUP = false;
	}
	
	/* Encrypt a string using an encryption algorithm, 
	 * in this case TEA */
	public static byte[] encryptTEA(String toEncryptData) {
		byte[] encryptedByteArray = new byte[]{};
		
		/*
		//encrypt message using TEA
		try {
			encryptedByteArray = TEA.encrypt(toEncryptData);
		} catch (UnsupportedEncodingException e) {
			SM.Exception("encryptTEA Exception(UEE): " + e.toString());
		} catch (IndexOutOfBoundsException e) {
			SM.Exception("encryptTEA Exception(IOoBE): " + e.toString());
		} catch (NullPointerException e) {
			SM.Exception("encryptTEA Exception(NPE): " + e.toString());
		}
		//*/
		
		// no encryption
		encryptedByteArray = toEncryptData.getBytes();
		
		return encryptedByteArray;
	}
	
	/* Decrypt a string using an encryption algorithm, 
	 * in this case TEA */
	public static byte[] decryptTEA(byte[] toDecryptData) {
		byte[] decryptedByteArray = new byte[]{};

		/*
		String sm = "";
		for(int i=0; i<toDecryptData.length; i++)
			sm+=toDecryptData[i] + "  "; 
		
		SM.Debug("DDDDDD: " + sm);
		//*/
		/*
		//decrypt message using TEA
		try {
			decryptedByteArray = TEA.decrypt(toDecryptData);
		} catch (UnsupportedEncodingException e) {
			SM.Exception("encryptTEA Exception(UEE): " + e.toString());
		} catch (IndexOutOfBoundsException e) {
			SM.Exception("encryptTEA Exception(IOoBE): " + e.toString());
		} catch (NullPointerException e) {
			SM.Exception("encryptTEA Exception(NPE): " + e.toString());
		}
		
		String sm = "";
		for(int i=0; i<decryptedByteArray.length; i++)
			sm+= (int)decryptedByteArray[i] + " "; 
		//sm = new String(decryptedByteArray.toString());
		try {
			SM.Debug("##### " + new String(decryptedByteArray, "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		SM.Debug("DEcrypted: " + decryptedByteArray.toString());
		
		//*/
		
		// no decryption
		decryptedByteArray = toDecryptData;
		
		return decryptedByteArray;
	}
	
	
	public int getPort() {
		return port;
	}
	
	public void updateTCPparameters(String ip, String _port)
	{
		
		// stop socket
		try {
			if(soc != null)
				soc.close();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		
		serverHostname = ip;
		try
		{
			port = Integer.parseInt(_port);
		}
		catch (Exception e) {
			
		}
		finally
		{
			port = 13589;
		}
	}
	
	public void triggerTCPConnectionStateEvent() {
		if(!isConnectionUP)
			TCPmsgParser._fireTCPConnectionDownEvent(previousConnectionWasUP);
		else 
			TCPmsgParser._fireTCPConnectionUpEvent(previousConnectionWasUP);
	}
	
	private void RestartTCP()
	{
		try 
		{
			isConnectionUP = false;
			previousConnectionWasUP = false;
			
			SM.Debug("Restarting TCP...ip:"+serverHostname + ":" + port);
			soc = new Socket();
			soc.connect(new InetSocketAddress(serverHostname, port), 5000); 
			
			input = new DataInputStream(soc.getInputStream());
			//input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			//output stream
			output = new DataOutputStream(soc.getOutputStream());
			
			//recv= new BufferedReader(new InputStreamReader(soc.getInputStream()));
			//writer =new PrintWriter(soc.getOutputStream()) ;
			if(soc !=null)
			{
				//previousConnectionWasUP = isConnectionUP;
				isConnectionUP = true;
				//triggerTCPConnectionStateEvent();
				
				/*
				//init connection
				boolean res = Write("0.0", "#19#" + AppParams.crtRadio.ip + "&"
							+ AppParams.crtRadio.id + "#");
				if(res){
					SM.Debug("Message (AirPadInit) sent to controller");
				}else{
					SM.Debug("Could not send message(AirPadInit)!!");
				}
				
				//get 
				res = Write("0.0", "#30#104#0#0#0#0#");
				if(res){
					SM.Debug("Message (GetSetZoneAndChannel) sent to app server zoneNR:"+0+ " channelNR:"+0);
				}else{
					SM.Debug("Could not send message(GetSetZoneAndChannel)!!!");
				}
				*/
				//init audio 
				//AudioHandle.b_SendinitUDP = true;
			}
			
		} 
		catch (UnknownHostException e) 
		{
			SM.Exception("RestartTCP break:"+e.toString()); 
			isConnectionUP = false;
		
		} 
		catch (IllegalArgumentException e) 
		{
			SM.Debug("IllegalArgumentException", "RestartTCP break:"+e.toString()); 
		} 
		catch (IOException e) 
		{
			SM.Exception("RestartTCP break:"+e.toString());
			isConnectionUP = false;
		}
		catch (NullPointerException e) 
		{
			SM.Exception("RestartTCP break:"+e.toString());
			isConnectionUP = false;
		}
		
		triggerTCPConnectionStateEvent();
	}

	public boolean isAlive() {
		return alive;
	}

	public void setAlive(boolean alive) {
		this.alive = alive;
	}
	
	/** close Socket when unReachable */
	public void closeSocket() {
		
		try {
			input = null;
			output = null;
			if(soc!=null)
				soc.close();
			soc = null;
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	public void Stop()
	{	
		SM.Debug("Stopping TCP", "TCP Connection is stopping on " + AppParams.IP + ":" + port);
		alive = false;
		
		
		if(mReceived!= null)
			try{ context.unregisterReceiver(mReceived); } catch(Exception ex) {/* receiver not registered  //*/};
			
		// stop thread
		if(listenThread != null)
		{
			Thread moribund = listenThread;
			listenThread = null;
			moribund.interrupt();
		}

				 
		if(input!=null)
		{
			try {
				input.close();
				input = null;
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		if(output!=null)
		{
			try {
				output.close();
				output = null;
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		if(soc !=null)
		{
			try {
				soc.close();
				soc = null;
			} 
			catch (IOException e) {
				SM.Exception("TCPClient[STOP]", "Stop break:"+e.toString());
			}
		}
	}

}