/* Copyright (C) 2006-2010  Joan Queralt Molina
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */
package biogenesis;

import java.net.InetAddress;
import java.util.Timer;
import java.util.TimerTask;
/**
 * This class implements an application level connection between two instances of biogenesis.
 * The connection will create the biological corridors with the other host when it connects and
 * will remove them when it disconnects.
 */
public class Connection {
	/**
	 * The IP address of the other host
	 */
	protected InetAddress remoteAddress;
	/**
	 * The port of the other host
	 */
	protected int remotePort;
	/**
	 * The state of the connection. Can be STATE_NOT_INITIALIZED for a new connection,
	 * STATE_CONNECTED for a working connection and STATE_DISCONNECTED for an
	 * already finished connection.
	 */
	protected int state;
	/**
	 * A number that identifies this connection to distinguish it from other connections
	 * to the same address. Useful to avoid confusion when connecting through NAT routers.
	 */
	protected int netCode;
	/**
	 * A reference to the main application in order to obtain some its information.
	 */
	protected MainWindow mainWindow;
	/**
	 * The time that the connection will wait without receiving any signal from the
	 * server on the other host before it tries to send a ping signal.
	 */
	private static final long CHECK_CONNECTION_TIME = 30000;
	/**
	 * The time when the last message from the server on the other host was received
	 */
	private long time;
	/**
	 * A timer used to activate ping message to the server on the other host when
	 * necessary
	 */
	private Timer timer;
	/**
	 * The biological corridor used to receive organism from the other host
	 */
	protected InCorridor inCorridor;
	/**
	 * The biological corridor used to send organism to the other host
	 */
	protected OutCorridor outCorridor;
	/**
	 * State of the connection that indicates that the connection has just been created
	 * and no attemp to connect to the other host has been done.
	 */
	public static final int STATE_DISCONNECTED = 50;
	/**
	 * State of the connection that indicates that the connection is active.
	 */
	public static final int STATE_CONNECTED = 51;
	/**
	 * State of the connection that indicates that the connection has been closed.
	 */
	public static final int STATE_NOT_INITIALIZED = 52;
	/**
	 * Return the IP address of the remote host
	 * 
	 * @return  the IP address of the remote host
	 */
	public InetAddress getRemoteAddress() {
		return remoteAddress;
	}
	/**
	 * Return the port of the remote host
	 * 
	 * @return  the port of the remote host
	 */
	public int getRemotePort() {
		return remotePort;
	}
	/**
	 * Create a new connection to the specified IP address and port
	 * 
	 * @param app  Reference to the main application window
	 * @param a  Address of the remote host
	 * @param p  Port of the remote host
	 */	
	public Connection(MainWindow app, InetAddress a, int p) {
		remotePort = p;
		remoteAddress = a;
		state = STATE_NOT_INITIALIZED;
		netCode = Utils.random.nextInt();
		mainWindow = app;
		createCorridors();
	}
	/**
	 * Create a new connection to the specified IP address and port using
	 * the specified netcode to identify the connection. Used to connect this client
	 * to the remote server when this server is already connected with the remote
	 * client.
	 * 
	 * @param app  Reference to the main application window
	 * @param a  Address of the remote host
	 * @param p  Port of the remote host
	 * @param nCode  Identifying code to use for this connection
	 */
	public Connection(MainWindow app, InetAddress a, int p, int nCode) {
		remotePort = p;
		remoteAddress = a;
		state = STATE_NOT_INITIALIZED;
		netCode = nCode;
		mainWindow = app;
		createCorridors();	
	}
	/**
	 * Create the pair of biological corridors, but don't add them to the world yet.
	 */
	private void createCorridors() {
		inCorridor = new InCorridor(mainWindow.getWorld());
		outCorridor = new OutCorridor(mainWindow.getWorld(), this);
	}
	/**
	 * Send a message to the remote host server. The message is send in a new thread and
	 * the method returns immidiately.
	 * 
	 * @param m  the message to send. See {@link NetServerThread} to see the possible
	 * messages to send. 
	 */
	public void send(int m) {
		NetSend n = new NetSend(this, m, null);
		n.start();
	}
	/**
	 * Send a genetic code to the remote host server. The code is send in a new thread
	 * and the method returns immidiately.
	 * 
	 * @param c  the genetic code to send.
	 */
	public void send(GeneticCode c) {
		NetSend n = new NetSend(this, NetServerThread.SEND_CODE, c);
		n.start();
	}
	/**
	 * Inform the connection that its state has changed. Used by {@link NetSend} and
	 * {@link NetServerThread}.
	 * 
	 * @param newState  STATE_CONNECTED if the connection has been stablished or 
	 * STATE_DISCONNECTED if the connection has been closed.
	 */
	public void setState(int newState) {
		if (state != newState) {
			if (newState == STATE_CONNECTED) {
				mainWindow.getWorld().addCorridors(inCorridor, outCorridor);
				keepAliveThread();
				mainWindow.setStatusMessage(Messages.getString("T_CONNECTION_STABLISHED", remoteAddress.toString())); //$NON-NLS-1$
			}
			if (newState == STATE_DISCONNECTED) {
				if (timer != null)
					timer.cancel();
				mainWindow.setStatusMessage(Messages.getString("T_CONNECTION_LOST", remoteAddress.toString())); //$NON-NLS-1$
				mainWindow.getWorld().removeCorridors(inCorridor, outCorridor);
				mainWindow.serverThread.removeConnection(this);
			}
		}
		state = newState;
	}
	/**
	 * Returns the state of the connection.
	 * 
	 * @return  the state of the connection
	 */
	public int getState() {
		return state;
	}
	/**
	 * Send a request connection message to the remote host. This is the same
	 * as calling {@code send(NetServerThread.CONNECT)}.
	 */
	public void connect() {
		// send a connection message
		NetSend n = new NetSend(this, NetServerThread.CONNECT, null);
		n.start();
	}
	/**
	 * Inform the connection that a message from the server has been received in
	 * order to avoid unnecessary ping messages.
	 */
	public void resetTime() {
		time = System.currentTimeMillis();
	}
	/**
	 * Start a new thread that will perform periodical pings to the remote
	 * server in order to keep the connection alive.
	 */
	private void keepAliveThread() {
		if (timer != null)
			timer.cancel();
		resetTime();
		timer = new Timer();
		TimerTask keepAliveTask = new TimerTask() {
		    @Override
			public void run() {
		    	keepAlive();
		    }
		};
		timer.schedule(keepAliveTask, CHECK_CONNECTION_TIME, CHECK_CONNECTION_TIME);
	}
	/**
	 * Make sure the connection is alive. If enough time has passed since the last
	 * message from the remote server, send a ping. This is done in a separated thread
	 * and this method returns immidiately.
	 */
	protected void keepAlive() {
		if (System.currentTimeMillis() - time > CHECK_CONNECTION_TIME) {
			NetSend n = new NetSend(this, NetServerThread.KEEP_ALIVE, null);
			n.start();
		}
	}
}