/* Copyright (c) 2002-2011 by XMLVM.org
 *
 * Project Info:  http://www.xmlvm.org
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 */

package org.xmlvm.proc.lib;

import java.io.File;
import java.util.List;

import org.xmlvm.Log;
import org.xmlvm.main.Arguments;
import org.xmlvm.main.Targets;
import org.xmlvm.util.universalfile.UniversalFile;
import org.xmlvm.util.universalfile.UniversalFileCreator;

/**
 * A library that can included into the compilation process.
 */
public abstract class Library
{
	private static final String TAG= Library.class.getSimpleName();
	private static final String CACHE_PATH= ".cache/";

	private UniversalFile[] resource= null;

	/**
	 * Returns whether this library should be used in the current process.
	 */
	public boolean isEnabled(Arguments arguments)
	{
		// Don't enable, if the target is amongst the excluded ones.
		List<Targets> excludedTargets= excludedTargets();
		if (excludedTargets != null)
		{
			if (excludedTargets.contains(arguments.option_target()))
			{
				return false;
			}
		}

		// If there are no included targets, the library is enabled for all
		// targets. Otherwise it's only enabled, if the target is amonst the
		// included ones.
		List<Targets> includedTargets= includedTargets();
		if (includedTargets != null)
		{
			return includedTargets.contains(arguments.option_target());
		}
		else
		{
			return true;
		}
	}

	/**
	 * Returns the library as a {@link UniversalFile} resource.
	 */
	public UniversalFile[] getLibrary()
	{
		if (resource == null)
		{
			resource= getLibraryUncached();
		}
		return resource;
	}

	/**
	 * This determines whether a library should be copied over completely, or
	 * whether it should be offered for the dependency analysis.
	 * <p>
	 * If this returns <code>true</code>, the complete library will be copied.
	 * <p>
	 * If this returns <code>false</code>, the library will be included in the
	 * dynamic dependency loading process.
	 */
	public abstract boolean isMonolithic();

	/**
	 * Returns the library resource. The implementation doesn't need to cache,
	 * as this method is only called once.
	 */
	protected abstract UniversalFile[] getLibraryUncached();

	/**
	 * Returns the targets for which this library should be activated. Returns
	 * <code>null</code>, if this library should be included in all targets.
	 */
	protected abstract List<Targets> includedTargets();

	/**
	 * Returns a list of targets for which this library should not be included.
	 */
	protected abstract List<Targets> excludedTargets();

	/**
	 * In order to easily load libraries that are already compiled, we put them
	 * in a JAR file. This method makes sure that the files in the given path
	 * are in the given destination JAR file.
	 * <p>
	 * TODO: The JAR file Should be stored alongside with timestamp information
	 * so that the JAR file will be re-created, if one of the source files
	 * changes. Right now it is re-created every time.
	 * 
	 * @param path
	 *            the directory that contains the resources to be archived
	 * @param pathPrefix
	 *            the path inside the archive, where the files are put into
	 * @return The path to the JAR file or null, if and error occurred or the
	 *         path was not found.
	 */
	protected String prepareTempJar(String path, String pathPrefix)
	{

		UniversalFile source= UniversalFileCreator.createDirectory(path);
		if (source == null || !source.exists())
		{
			Log.debug(TAG, "Couldn't find library path: " + path);
			return null;
		}
		long lastModified= lastModifiedRecursive(source);
		String tempFileName= createTempFileName(path, lastModified);

		// Check whether the temp jar already exists with the given time stamp.
		if (exists(tempFileName))
		{
			return tempFileName;
		}

		Log.debug(TAG, "Preparing temp JAR for '" + path + "' at '" + tempFileName + "'.");
		source.archiveTo(tempFileName, pathPrefix);
		return tempFileName;
	}

	private long lastModifiedRecursive(UniversalFile directory)
	{
		long lastModified= 0;
		for (UniversalFile file : directory.listFilesRecursively())
		{
			if (file.getLastModified() > lastModified)
			{
				lastModified= file.getLastModified();
			}
		}
		return lastModified;
	}

	private static String createTempFileName(String path, long lastModified)
	{
		return CACHE_PATH + path.replace("/", "_").replace("\\", "_") + "." + lastModified + ".jar";
	}

	private static boolean exists(String fileName)
	{
		return (new File(fileName)).exists();
	}
}