/* ------------------------------------
    * © Kaamelot - 2006
    * ------------------------------------
    * Projet  : projectName
    * Fichier : AUpgradeManager.java
    * $Id$ 
    * $Date$ 
    * $Log$
    * 
   */
  package com.atlassian.jira.upgrade;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.SortedMap;
  import java.util.SortedSet;
  import java.util.TreeMap;
  import java.util.TreeSet;
  
  import org.apache.commons.lang.exception.ExceptionUtils;
  import org.apache.log4j.Category;
  import org.ofbiz.core.entity.GenericEntityException;
  import org.ofbiz.core.entity.GenericValue;
  
  import com.atlassian.core.ofbiz.CoreFactory;
  import com.atlassian.core.util.ClassLoaderUtils;
  import com.atlassian.jira.ComponentManager;
  import com.atlassian.jira.ManagerFactory;
  import com.atlassian.jira.config.properties.ApplicationProperties;
  import com.atlassian.jira.upgrade.BuildNumComparator;
  import com.atlassian.jira.upgrade.UpgradeManager;
  import com.atlassian.jira.upgrade.UpgradeTask;
  import com.atlassian.jira.util.JiraUtils;
  
  import electric.xml.Document;
  import electric.xml.Element;
  import electric.xml.Elements;
  import electric.xml.ParseException;
  
  /**
   * @author BNP Paribas - SIG/CGI/SFRI - 2005
   * <b>Description :</b>
   * @version $Id$
   * @history <ul>
   * <li/>Date    		- UserId - Observations
   * <li/>22 juin 2005 - 139611 - Initialisation de la classe.
   * </ul>
   * 
   */
  public abstract class AAddOnUpgradeManager implements IAddOnUpgradeManager {
  
  	private static Category log = Category.getInstance(AAddOnUpgradeManager.class);
  	private Comparator buildNumberComp = new BuildNumComparator();
  
  	//These maps hold the standard, professional and enterprise upgrades
  	private SortedMap allAddOnUpgrades = new TreeMap(buildNumberComp);
  
  	//This map holds a list of all upgrades that have been done previously
  	private HashMap upgradeHistoryMap;
  	
  //	private String keyParameter;
  
  //	private static IAddOnUpgradeManager instance;
  
     /**
      * 
      */
     protected AAddOnUpgradeManager() {
  		addAllUpgrades(getAllAddOnUpgrades(), getAddOnFileName());
     }
     
  	/**
  	 */
  	protected AAddOnUpgradeManager(Collection addOnUpgrades) {
  
  		for (Iterator iterator = addOnUpgrades.iterator(); iterator.hasNext();)
  		{
  			UpgradeTask upgradeTask = (UpgradeTask) iterator.next();
  			allAddOnUpgrades.put(upgradeTask.getBuildNumber(), upgradeTask);
  		}
  	}
  
  	public AAddOnUpgradeManager(String addOnFileName)
  	{
  		//add all the upgrade tasks in here.
  		addAllUpgrades(allAddOnUpgrades, addOnFileName);
  
  	}
  
  	/**
  	 * Reads an upgrade XML file to get a list of all the upgrades specified in this file and adds these upgrades the upgradeSet accordingly
 	 * <p/>
 	 * For every <i>upgrade</i> element, load the class specified by the <i>class</i> element.
 	 * Put this class into the upgradeSet Map with the <i>build</i> attribute as the key.
 	 * <p/>
 	 */
 	protected void addAllUpgrades(Map upgradeSet, String fileName)
 	{
 		InputStream is = ClassLoaderUtils.getResourceAsStream(fileName, this.getClass());
 		try
 		{
 			Document doc = new Document(is);
 			Element root = doc.getRoot();
 			Elements actions = root.getElements("upgrade");
 
 			while (actions.hasMoreElements())
 			{
 				Element action = (Element) actions.nextElement();
 				String className = action.getElement("class").getTextString();
 				try
 				{
 					UpgradeTask task = (UpgradeTask) JiraUtils.loadComponent(className, this.getClass());
 
 					upgradeSet.put(action.getAttribute("build"), task);
 
 					//if this task is to be done on setup as well then add it to the setup set as well
 					if ("true".equals(action.getAttribute("setup")))
 					{
 						log.warn("Setup is not supported for AddOn ..." + className);
 					}
 				}
 				catch (Exception e)
 				{
 					log.error("Exception loading type: " + className, e);
 				}
 			}
 		}
 		catch (ParseException e)
 		{
 			log.error("Exception: ", e);
 		}
 
 		try
 		{
 			is.close();
 		}
 		catch (IOException e)
 		{
 			log.warn("Could not close " + fileName + " inputStream");
 		}
 	}
 
 
 
 	/**	
 	 * Gets a set of all the build numbers for which upgrade tasks must be performed. It will
 	 * only return numbers which are greater than the current JIRA build number
 	 * <p/>
 	 * The set will be sorted by ascending build number
 	 */
 	private SortedSet getAllRelevantUpgradeBuildNumbers()
 	{
 		SortedSet numbers = new TreeSet(buildNumberComp);
 
 		Map addOnUpgardes = getRelevantUpgradesFromList(allAddOnUpgrades);
 
 		addUpgradeNumbersFromMap(numbers, addOnUpgardes);
 
 		return numbers;
 	}
 
 	/**
 	 * Gets a set of upgrade build numbers for a specified Map of upgradeTasks.
 	 *
 	 * @param numbers    This set may be already populated with numbers.
 	 *                   Any additional numbers from the Map of upgradeTasks will be added to this set
 	 * @param upgradeMap This is the map of upgradeTasks that the build numbers will be retrieved from
 	 */
 	private void addUpgradeNumbersFromMap(SortedSet numbers, Map upgradeMap)
 	{
 		Collection upgrades = upgradeMap.entrySet();
 
 		for (Iterator iterator = upgrades.iterator(); iterator.hasNext();)
 		{
 			Map.Entry entry = (Map.Entry) iterator.next();
 
 			numbers.add(entry.getKey());
 		}
 		return;
 	}
 
 	/**
 	 * For each upgrade in the upgradeMap, test whether it is needed (ie upgrade version is greater
 	 * than the version in the database), and then add to set.
 	 *
 	 * @return set of UpgradeTasks that need to be run.
 	 */
 	public SortedMap getRelevantUpgradesFromList(Map upgradeMap)
 	{
 		try
 		{
 			SortedMap unAppliedUpgrades = new TreeMap(buildNumberComp);
 
 			for (Iterator iterator = upgradeMap.entrySet().iterator(); iterator.hasNext();)
 			{
 				Map.Entry entry = (Map.Entry) iterator.next();
 
 				if (needUpgrade((String) entry.getKey()))
 				{
 					UpgradeTask upgradeTask = (UpgradeTask) entry.getValue();
 					unAppliedUpgrades.put(upgradeTask.getBuildNumber(), upgradeTask);
 				}
 			}
 			return unAppliedUpgrades;
 		}
 		catch (Throwable e)
 		{
 			log.error("Exception getting upgrades " + e.getMessage(), e);
 			return new TreeMap();
 		}
 	}
 
 	/** @see com.atlassian.jira.upgrade.AAddOnUpgradeManager#doUpgradeIfNeeded()
 	 */
 	public Collection doUpgradeIfNeeded() {
 	   String msg;
 		Collection errors = new ArrayList();
 		if (needUpgrade()) {
 			if (isUpgradable()) {
 				log.info("Detected that an upgrade is needed; existing data at build " + getAddOnBuildNumber());
 				errors = doUpgrade();
 			} else {
 			   msg = "Detected that an upgrade is needed, but upgradable due to insufficient Jira Build";
 				log.debug(msg);
 				errors.add(msg);
 			}
 		} else {
 		   msg = "Detected that no upgrade is neccessary";
 			log.debug(msg);
 			errors.add(msg);
 		}
 
 		return errors;
 	}
 
 	/**
 	 * Gets all the upgrades (AddOn) that need to be run from the build number stored in the database to the current build number
 	 * <p/>
 	 * Get the set of upgradeNumbers which are to be performed for this upgrade.
 	 * <p/>
 	 * Get the Maps of relevant upgrades for the AddOn using {@link #getRelevantUpgradesFromList}
 	 * <p/>
 	 * <p/>
 	 * Iterate over these numbers and if either of the AddOn maps contains an
 	 * upgradetask with this number then do the upgrade
 	 * <p/>
 	 * If errors are found, it will cancel the upgrade, and list errors to the console.
 	 * <p/>
 	 * For each upgrade that happens successfully, it will increment the build number in the
 	 * database, so that if one fails, you do not have to repeat all the upgrades that have
 	 * already run.
 	 * <p/>
 	 * If there are no errors from the upgrade, the build number in the database is
 	 * incremented to the current build number.  This is because there may be no upgrades
 	 * for a particular version & needUpgrade() checks build no in database.
 	 */
 	private Collection doUpgrade()
 	{
 		log.info("Doing Upgrade...");
 
 		Collection errors = new ArrayList();
 
 		try
 		{
 			Set upgradeNumbers = getAllRelevantUpgradeBuildNumbers();
 
 			// get all the relevant upgrades
 			Map addOnUpgrades = getRelevantUpgradesFromList(allAddOnUpgrades);
 
 			errors = runUpgradeTasks(upgradeNumbers, addOnUpgrades);
 
 			//if there were no errors then set the build number to the current number
 			if (errors.isEmpty())
 			{
 				// there may not be any patches for this version, so increment to latest build number.
 				log.info("Upgrade succeeded! Setting data build number to " + getCurrentAddOnBuildNumber());
 				setAddOnBuildNumber(getCurrentAddOnBuildNumber());
 			}
 			else
 			{
 				log.error("Errors occurred during upgrade:");
 				printErrors(errors);
 			}
 		}
 		catch (Throwable e)
 		{
 			log.error("Exception thrown during upgrade: " + e.getMessage(), e);
 			errors.add("Exception thrown during upgrade: " + e.getMessage() + "\n" + ExceptionUtils.getStackTrace(e));
 		}
 
 		ManagerFactory.globalRefresh();
 //		ManagerFactory.getCacheManager().flushAll();
 
 		return errors;
 	}
 
 	/**
 	 * Runs the given upgarde tasks for the given build numbers.
 	 * <p/>
 	 * The method iterates over the given build numbers and for each runs an upgarde tasks according to the currently installed
 	 * license.
 	 * <p/>
 	 * After all upgrade tasks are run for a build number JIRA's build number is set to its value.
 	 *
 	 * @param upgradeNumbers       the build numbers ofr which upgrade tasks need to be run
 	 * @param addOnUpgrades     standard upgardes to run with build number as key
 	 * @return a collection of errors that occurred during upgrade (empty collection if no errors occurred)
 	 * @throws Exception
 	 */
 	private Collection runUpgradeTasks(Collection upgradeNumbers, Map addOnUpgrades) throws Exception
 	{
 		Collection errors = new ArrayList();
 
 		//get a list of any previosly run upgrades so that they are not run again
 		Map upgradeHistoryMap = getPreviouslyRunUpgrades();
 
 		for (Iterator iterator = upgradeNumbers.iterator(); iterator.hasNext();)
 		{
 			//get the next upgrade build number
 			String number = (String) iterator.next();
 
 			//if there is a AddOn ugrade for this build then perform it
 			UpgradeTask addOnUpgradeTask = (UpgradeTask) addOnUpgrades.get(number);
 
 			if (!doUpgradeTaskSucess(upgradeHistoryMap, addOnUpgradeTask, errors))
 			{
 				break;
 			}
 
 			//if the number of the upgrade is greater than the current build number then set the build number to this number
 			if (buildNumberComp.compare(number, getAddOnBuildNumber()) > 0)
 			{
 				log.info("Setting current build number on to " + number);
 				setAddOnBuildNumber(number);
 			}
 //			ManagerFactory.globalRefresh();
 
 		}
 
 		return errors;
 	}
 
 	/**
 	 * Performs an upgrade by executing an Upgrade Task.
 	 *
 	 * @return True if the upgrade was performed without errors. False if the upgrade has errors
 	 * @throws Exception
 	 */
 	private boolean doUpgradeTaskSucess(Map upgradeHistoryMap, UpgradeTask upgradeTask, Collection errors) throws Exception
 	{
 		if (upgradeTask != null)
 		{
 			//if the upgrade has not been run then
 			if (upgradeHistoryMap.get(upgradeTask.getClass().getName()) == null)
 			{
 				log.info("Performing Upgrade Task: " + upgradeTask.getShortDescription());
 				upgradeTask.doUpgrade();
 
 				try
 				{
 					addToUpgradeHistory(upgradeTask.getClass());
 				}
 				catch (GenericEntityException e)
 				{
 					errors.add("There was a problem adding Upgrade Task " + upgradeTask.getShortDescription() + " to the Upgrade History");
 				}
 
 				if (!upgradeTask.getErrors().isEmpty())
 				{
 					log.error("Errors during Upgrade Task: " + upgradeTask.getShortDescription());
 					errors.addAll(upgradeTask.getErrors());
 					return false;
 				}
 
 				log.info("Upgrade Task: '" + upgradeTask.getShortDescription() + "' succeeded");
 			}
 			else
 				log.info("Upgrade Task: '" + upgradeTask.getShortDescription() + "' has already been run before");
 		}
 		return true;
 	}
 
 
 	public void addToUpgradeHistory(Class upgradeClass) throws GenericEntityException
 	{
 //		EntityUtils.createValue("UpgradeHistory", UtilMisc.toMap("upgradeclass", upgradeClass.getName()));
 	}
 
 
 	/** @see com.atlassian.jira.upgrade.AAddOnUpgradeManager#getAllAddOnUpgrades()
 	 */
 	public SortedMap getAllAddOnUpgrades()
 	{
 		return allAddOnUpgrades;
 	}
 
 	/**
 	 * Returns true if the current build number is not equal to the build number in the database.
 	 * NB - There may not be any upgrades to run.  However, you will need to run doUpgrade() to
 	 * increment the build number in the database.
 	 */
 	public boolean isUpgradable()
 	{
 		UpgradeManager manager = (UpgradeManager) ComponentManager.getInstance().getContainer().getComponentInstanceOfType(UpgradeManager.class);
 		return patchBuildGreaterOrEqualThanCurrent(getRequiredJiraBuildNumber(),manager.getJiraBuildNumber());
 	}
 
 	/**
 	 * Returns true if the current build number is not equal to the build number in the database.
 	 * NB - There may not be any upgrades to run.  However, you will need to run doUpgrade() to
 	 * increment the build number in the database.
 	 */
 	public boolean needUpgrade()
 	{
 		return !getCurrentAddOnBuildNumber().equals(getAddOnBuildNumber());
 	}
 
 	/**
 	 * If the patch version is greater than the current version, then return true.  Else return false.
 	 *
 	 * @param buildNumber
 	 * @return
 	 */
 	private boolean needUpgrade(String buildNumber)
 	{
 		return patchBuildGreaterThanCurrent(getAddOnBuildNumber(), buildNumber);
 	}
 	
 	/**
 	 * If the patch version is greater than current version, return true.  Else return false
 	 *
 	 * @param currentBuild
 	 * @param patchBuild
 	 * @return
 	 */
 	private boolean patchBuildGreaterThanCurrent(String currentBuild, String patchBuild)
 	{
 		return (buildNumberComp.compare(currentBuild, patchBuild) < 0);
 	}
 
 	/**
 	 * If the patch version is greater than current version, return true.  Else return false
 	 *
 	 * @param currentBuild
 	 * @param patchBuild
 	 * @return
 	 */
 	private boolean patchBuildGreaterOrEqualThanCurrent(String currentBuild, String patchBuild)
 	{
 		return (buildNumberComp.compare(currentBuild, patchBuild) <= 0);
 	}
 
 	/**
 	 * Get the current build number from the database.  This represents the level that this application
 	 * is patched to.  This may be different to the current version if there are patches waiting to be
 	 * applied.
 	 *
 	 * @return The version information from the database
 	 */
 	public String getAddOnBuildNumber()
 	{
 		//if null in the database, we need to set to '0' so that it can be compared with
 		//other versions.
 		if (ManagerFactory.getApplicationProperties().getString(getKeyParameter()) == null)
 			setAddOnBuildNumber("0");
 		return ManagerFactory.getApplicationProperties().getString(getKeyParameter());
 	}
 	
 	public void setAddOnBuildNumber(String version)
 	{
 		ApplicationProperties ap = ManagerFactory.getApplicationProperties();
 		ap.setString(getKeyParameter(), version);
 	}
 	
 	/** Get Current AddOn Build Number provided by release */
 	public abstract String getCurrentAddOnBuildNumber();
 
 	/** Get the Required JIRA Build Number to perform provided Upgrades */
 	public abstract String getRequiredJiraBuildNumber();
 
 	/**
 	 * Get a list of the Upgrades that have been previously run
 	 */
 	private Map getPreviouslyRunUpgrades() throws GenericEntityException
 	{
 		//if this list of upgrades has not been retrived then retrieve it otherwise return it
 		if (upgradeHistoryMap == null)
 		{
 			List upgradeHistoryList = CoreFactory.getGenericDelegator().findAll("UpgradeHistory");
 
 			upgradeHistoryMap = new HashMap();
 
 			for (Iterator it = upgradeHistoryList.iterator(); it.hasNext();)
 			{
 				GenericValue upgradeHist = (GenericValue) it.next();
 				upgradeHistoryMap.put(upgradeHist.getString("upgradeclass"), upgradeHist);
 			}
 		}
 		return upgradeHistoryMap;
 	}
 
 	/**
 	 * Print errors to log4j at error level
 	 * @see com.atlassian.jira.upgrade.AAddOnUpgradeManager#printErrors(java.util.Collection)
 	 * @param errors A collection of strings, describing all the errors that occurred.
 	 */
 	public void printErrors(Collection errors)
 	{
 		for (Iterator iterator = errors.iterator(); iterator.hasNext();)
 		{
 			String s = (String) iterator.next();
 			log.error("Upgrade Error: " + s);
 		}
 	}
 
 	/** @return	 */
 	public abstract String getKeyParameter();
 	
 //	protected static Collection logDebug(Collection _errors, final String _msg) {
 //		log.debug(_msg);
 //		_errors.add(_msg);
 //		return _errors;
 //	}
 //
 //	protected static Collection logInfo(Collection _errors, final String _msg) {
 //		log.info(_msg);
 //		_errors.add(_msg);
 //		return _errors;
 //	}
 //
 //	protected static Collection logError(Collection _errors, final String _msg) {
 //		log.error(_msg);
 //		_errors.add(_msg);
 //		return _errors;
 //	}
 //
 //	protected static Collection logWarn(Collection _errors, final String _msg) {
 //		log.warn(_msg);
 //		_errors.add(_msg);
 //		return _errors;
 //	}
 
 }