package org.openslx.imagemaster.util;

import java.io.File;
import java.math.BigInteger;
import java.security.Key;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.Arrays;
import java.util.Random;
import java.util.UUID;

import org.apache.log4j.Logger;

/**
 * Some utilities to make our lives easier.
 */
public class Util
{

	private static Logger LOGGER = Logger.getLogger( Util.class );

	/**
	 * Check if the given object is null, abort program if true.
	 * An optional message to be printed can be passed. A stack trace
	 * will be printed, too. Finally the application terminates with
	 * exit code 2.
	 * 
	 * This comes in handy if something must not be null, and you want
	 * user friendly output. A perfect example would be reading settings
	 * from a config file. You can use this on mandatory fields.
	 * 
	 * @param something the object to compare to null
	 * @param message the message to be printed if something is null
	 */
	public static void notNullFatal( Object something, String message )
	{
		if ( something == null ) {
			if ( message != null )
				LOGGER.fatal( "[NOTNULL] " + message, new NullPointerException() );
			System.exit( 2 );
		}
	}

	/**
	 * Check if the given object is null, abort program if true.
	 * An optional message to be printed can be passed. A stack trace
	 * will be printed, too. Finally the application terminates with
	 * exit code 2.
	 * 
	 * This comes in handy if something must not be null, and you want
	 * user friendly output. A perfect example would be reading settings
	 * from a config file. You can use this on mandatory fields.
	 * 
	 * @param something the object to compare to null
	 * @param message the message to be printed if something is null
	 */
	public static void notNullFatal( int number, String message )
	{
		if ( number == 0 ) {
			if ( message != null )
				LOGGER.fatal( "[NOTNULL] " + message, new NullPointerException() );
			System.exit( 2 );
		}
	}

	/**
	 * Check if String is null or empty, abort program if so.
	 * An optional message to be printed can be passed. A stack trace
	 * will be printed, too. Finally the application terminates with
	 * exit code 2.
	 * 
	 * @param something The string you want to check
	 * @param message The message to be printed if "something" is null or empty
	 */
	public static void notNullOrEmptyFatal( String something, String message )
	{
		if ( something == null || something.isEmpty() ) {
			if ( message != null )
				LOGGER.fatal( "[NOTNULL] " + message, new NullPointerException() );
			System.exit( 2 );
		}
	}

	/**
	 * Static {@link Random} instance.
	 */
	private static final Random random = new Random();

	/**
	 * Return a random integer in the range of 0 (inclusive) and
	 * n (exclusive). Uses the internal static instance of {@link Random},
	 * so you don't have to deal with instances everywhere.
	 * 
	 * @param n the upper bound (exclusive)
	 * @return number between 0 (inclusive) and n (exclusive)
	 */
	public static int randomInt( int n )
	{
		return random.nextInt( n );
	}

	/**
	 * Remove a folder and all contents
	 * 
	 * @param folder
	 */
	public static void deleteFolder( File folder )
	{
		File[] files = folder.listFiles();
		if ( files != null ) {
			for ( File f : files ) {
				if ( f.isDirectory() ) {
					deleteFolder( f );
				} else {
					f.delete();
				}
			}
		}
		folder.delete();
	}

	public static boolean isEmpty( String str )
	{
		return str == null || str.isEmpty();
	}

	public static boolean isEmpty( String str, String message, Logger logger )
	{
		if ( str != null && !str.isEmpty() )
			return false;
		logger.debug( message );
		return true;
	}

	/**
	 * Tries to parse an int. Returns 0 on error.
	 * 
	 * @param s The strig to parse
	 * @return The parsed int or 0 on error
	 */
	public static int tryToParseInt( String s )
	{
		return tryToParseInt( s, 0 );
	}

	/**
	 * Tries to parse an int. Returns defaultValue on error.
	 * 
	 * @param s The strig to parse
	 * @param defaultValue value to be returned if s is not parsable
	 * @return The parsed int
	 */
	public static int tryToParseInt( String s, int defaultValue )
	{
		try {
			return Integer.parseInt( s );
		} catch ( NumberFormatException e ) {
			return defaultValue;
		}
	}

	/**
	 * Tries to parse a bigint. Returns null on error.
	 * 
	 * @param s The strig to parse
	 * @return The parsed bigint
	 */
	public static BigInteger tryToParseBigInt( String s )
	{
		try {
			return new BigInteger( s );
		} catch ( NumberFormatException e ) {
			return null;
		}
	}

	public static int getNumberOfBlocks( long fileSize, int blockSize )
	{
		int blocks = (int) ( fileSize / blockSize );
		if ( fileSize % blockSize != 0 )
			blocks++;
		return blocks;
	}

	public static String sanitizeFileName( String fileName )
	{
		fileName = fileName.replaceAll( "[^a-zA-Z0-9_\\-]+", "_" );
		if ( fileName.length() > 40 )
			fileName = fileName.substring( 0, 40 );
		return fileName;
	}

	/**
	 * Checks whether the two given keys are equal. Works for
	 * public and private keys.
	 * 
	 * @param k1 first key
	 * @param k2 second key
	 * @return true if equal
	 */
	public static boolean keysEqual( Key k1, Key k2 )
	{
		if ( k1 instanceof RSAPublicKey && k2 instanceof RSAPublicKey )
		{
			RSAPublicKey rsa1 = (RSAPublicKey)k1;
			RSAPublicKey rsa2 = (RSAPublicKey)k2;
			return rsa1.getModulus().equals( rsa2.getModulus() )
					&& rsa1.getPublicExponent().equals( rsa2.getPublicExponent() );
		}

		if ( k1 instanceof RSAPrivateKey && k2 instanceof RSAPrivateKey )
		{
			RSAPrivateKey rsa1 = (RSAPrivateKey)k1;
			RSAPrivateKey rsa2 = (RSAPrivateKey)k2;
			return rsa1.getModulus().equals( rsa2.getModulus() )
					&& rsa1.getPrivateExponent().equals( rsa2.getPrivateExponent() );
		}
		return Arrays.equals( k1.getEncoded(), k2.getEncoded() );
	}

	public static String getRelativePath( File absolutePath, File parentDir )
	{
		String file;
		String dir;
		try {
			file = absolutePath.getCanonicalPath();
			dir = parentDir.getCanonicalPath() + File.separator;
		} catch ( Exception e ) {
			LOGGER.error( "Could not get relative path for " + absolutePath.toString(), e );
			return null;
		}
		if ( !file.startsWith( dir ) )
			return null;
		return file.substring( dir.length() );
	}

	public static boolean isUUID( String id )
	{
		try {
			UUID.fromString( id );
		} catch ( Exception e ) {
			return false;
		}
		return true;
	}

}