package org.openslx.imagemaster.serverconnection;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;

import org.apache.log4j.Logger;
import org.openslx.filetransfer.Downloader;
import org.openslx.filetransfer.FileRange;
import org.openslx.filetransfer.IncomingEvent;
import org.openslx.filetransfer.Listener;
import org.openslx.filetransfer.Uploader;
import org.openslx.filetransfer.WantRangeCallback;
import org.openslx.imagemaster.Globals;

/**
 * Class to handle all incoming and outgoing connections.
 * Also handles the authentication and the saving/delivering of images.
 */
public class ConnectionHandler implements IncomingEvent
{

	private static Logger log = Logger.getLogger( ConnectionHandler.class );
	private static SSLContext sslContext;

	private static Map<String, Connection> connections = new ConcurrentHashMap<>();
	private static IncomingEvent eventHandler = new ConnectionHandler();

	private static Listener listener;

	static {
		log.debug( "Starting listener on port " + Globals.getSslSocketPort() );
		try {
			String pathToKeyStore = Globals.getSslKeystoreFile();
			char[] passphrase = Globals.getSslKeystorePassword().toCharArray();
			KeyStore keystore = KeyStore.getInstance( "JKS" );
			keystore.load( new FileInputStream( pathToKeyStore ), passphrase );
			KeyManagerFactory kmf = KeyManagerFactory.getInstance( KeyManagerFactory.getDefaultAlgorithm() );
			kmf.init( keystore, passphrase );
			sslContext = SSLContext.getInstance( "SSLv3" );
			KeyManager[] keyManagers = kmf.getKeyManagers();
			sslContext.init( keyManagers, null, null );
			listener = new Listener( eventHandler, sslContext, Globals.getSslSocketPort() );
			listener.start();
		} catch ( FileNotFoundException e ) {
			log.error( "Could not find keystore." );
			System.exit( 2 );
		} catch ( KeyStoreException e ) {
			log.error( "KeyStore implemenation not supported." );
			System.exit( 2 );
		} catch ( NoSuchAlgorithmException e ) {
			log.error( "Could not find such Algorithm" );
			System.exit( 2 );
		} catch ( CertificateException e ) {
			log.error( "Certificate unvalid." );
			System.exit( 2 );
		} catch ( IOException e ) {
			log.error( "Could not read keyfile" );
			System.exit( 2 );
		} catch ( UnrecoverableKeyException e ) {
			log.error( "Key in keystore is not valid" );
			System.exit( 2 );
		} catch ( KeyManagementException e ) {
			log.error( "Context initialization failed." );
			System.exit( 2 );
		}
	}

	/**
	 * Add a new connection with a unique token.
	 * To up- or download the file in file path.
	 * 
	 * @param token The unique token
	 * @param filepath The file to up- or download
	 * @param type True if upload or false if download
	 * @return The created connection
	 */
	public static Connection addConnection( String token, String filepath, boolean type )
	{
		log.debug( "Added connection (" + ( ( type ) ? "uploading" : "downloading" ) + ") with token: '" + token + "'" );

		Connection connection = new Connection( filepath, type );
		synchronized ( connections ) {
			connections.put( token, connection );
		}
		return connection;
	}

	public static boolean hasConnection( String token )
	{
		return connections.containsKey( token );
	}

	public static void removeConnection( String token )
	{
		synchronized ( connections ) {
			connections.remove( token );	// token is remove, so connections are rejected
		}
	}

	/**
	 * Server is uploading - client is downloading!
	 */
	@Override
	public void incomingUploader( Uploader uploader ) throws IOException
	{
		String token = uploader.getToken();
		log.debug( "Got token :'" + token + "'" );
		// check token to identify the client
		if (token == null)
		{
			uploader.sendErrorCode( "No token available." );
			uploader.close(null);
			return;
		}
		if ( !connections.containsKey( token ) ) {
			uploader.sendErrorCode( "Token not accepted." );
			uploader.close(null);
			return;
		}

		// check if he was a downloading client
		if ( connections.get( token ).type == Connection.UPLOADING ) {
			uploader.sendErrorCode( "You can not download, if you are uploading." );
			uploader.close(null);
			return;
		}

		String fileName = connections.get( token ).filepath;
		uploader.upload(fileName);
	}

	/**
	 * Server is downloading - client is uploading!
	 */
	@Override
	public void incomingDownloader( Downloader downloader ) throws IOException
	{
		log.debug( "Client wants to upload" );
		String token = downloader.getToken();
		if (token == null)
		{
			downloader.sendErrorCode( "No token available." );
		    downloader.close(null);
			return;
		}
		// Check token to identify the client.
		if ( !connections.containsKey( token ) ) {
			downloader.sendErrorCode( "Token not accepted." );
			downloader.close(null);
			return;
		}
		
		// check if he was a uploading client
		if ( connections.get( token ).type == Connection.DOWNLOADING ) {
			downloader.sendErrorCode( "You can not upload, if you are downloading." );
			downloader.close(null);
			return;
		}
		
		String destinationFileName = connections.get( token ).filepath;
		final UploadingImage image = connections.get( token ).image;
		downloader.download( destinationFileName, new WantRangeCallback() {
			
			@Override
			public FileRange get() {
				// get start of range.
				int blockNumber = image.getNextMissingBlock();
				if (blockNumber == -1)
					return null;
				
				image.setNeedsCheck( blockNumber );
				image.increaseTransmittedTimes( blockNumber );
				log.debug( "Block " + blockNumber + " was transmitted " + image.getTimesTransmitted( blockNumber ) + " time(s)." );
				
				long startOfRange =  image.getNextMissingBlock() * Globals.blockSize;
				long endOfRange = Math.min(startOfRange + Globals.blockSize, image.getImageFile().length());
				FileRange range = new FileRange(startOfRange, endOfRange);
				return range;
			}
		});
//		long startOfRange = 0;
//		String token = "";
//		// try to read meta data
//		while ( downloader.readMetaData() ) {
//			// check token to identify the client
//			token = downloader.getToken();
//			if ( !connections.containsKey( token ) ) {
//				downloader.sendErrorCode( "Token not accepted." );
//				downloader.close(null);
//				return;
//			}
//
//			startOfRange = downloader.getStartOfRange();
//
//			if ( downloader.getDiffOfRange() <= 0 ) {
//				return;
//			}
//
//			// check if he was a uploading client
//			if ( connections.get( token ).type == Connection.DOWNLOADING ) {
//				downloader.sendErrorCode( "You can not upload, if you are downloading." );
//				downloader.close(null);
//				return;
//			}
//
//		
//			int blockNumber = (int) ( startOfRange / Globals.blockSize );
//			UploadingImage image = connections.get( token ).image;
//			image.setNeedsCheck( blockNumber );
//			image.increaseTransmittedTimes( blockNumber );
//			log.debug( "Block " + blockNumber + " was transmitted " + image.getTimesTransmitted( blockNumber ) + " time(s)." );
//
//			downloader.setOutputFilename( connections.get( token ).filepath );
//			downloader.receiveBinary();
//		}
		downloader.close(null);
	}
}