/*
    * $Id: Configuration.java,v 1.19 2006/01/12 17:10:29 tymoteusz Exp $
    *
    */ 
   
   package net.sourceforge.jdbdump.connect;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.Serializable;
  import java.util.Hashtable;
  import java.util.Properties;
  
  import org.apache.log4j.Logger;
  
  /***
   * This class is a Singleton, which purpose is to manage system's configuration data such as:
   * <ul>
   * <li> authorization data of users allowed to use the system,
   * <li> configured connections to databases
   * </ul>
   * Data is passed to/from a subclass of ConfigurationIO class, which gives great flexibility in choose of 
   * configuration data storage place and access methods.
   * 
   * @author tymoteusz
   *
   */
  public class Configuration {
  
  	private static Hashtable<String, DatabaseConnectionData> connections = new Hashtable<String, DatabaseConnectionData>(); 
  	private static Hashtable<String, DatabaseBackupData> backups = new Hashtable<String, DatabaseBackupData>(); 
  	private static Hashtable<String, User> users = new Hashtable<String, User>();
  	private static String email = new String();
  	private static Configuration ref;
  	private static Logger logger = Logger.getLogger(Configuration.class);
  	private static ConfigurationIO confIO;
  	private static Properties props = new Properties();
  	private static String backupDir = new String();
  	private static Hashtable<String, Serializable> confData = new Hashtable<String, Serializable>();
  	/***
  	 * Value of his variable determines if data should be implicitly saved after every use of put*() method.
  	 * The default value set to true assumes that access to storage place is not expencieve (in time, or other units),
  	 * and therefore data is saved automatically to free developer from remembering about commiting changes.
  	 * Change this setting with setAutosave() method if connection to storage place is expencieve for you,
  	 * and remember then to save() your changes!
  	 * @see #setAutosave(boolean)
  	 */
  	private boolean autosave = true;
  
  	/***
  	 * Value of his variable determines if data should be implicitly loaded for every use of get*() method.
  	 * The default value set to false assumes that data at storage place is not versatile, and we don't expect 
  	 * changes of data during execution of the application. Change this setting with setAutoload() method if you 
  	 * need to be sure that configuration data you retrieve is most current.  
  	 * @see #setAutoload(boolean)
  	 */
  	private boolean autoload = false;	
  
  	/***
  	 * Creates configuration with one default user. Make sure class defined in system property 
  	 * "Configuration.configurationIOsubclass", or the default FilesystemConfigurationIO exist in classpath,
  	 * or constructor will throw an Exception and fail
  	 * 
  	 * @throws ClassNotFoundException if the initialization of ConfigurationIOprovoked by this method fails.
  	 * @throws IllegalAccessException if the class or its nullary constructor is not accessible
  	 * @throws InstantiationException if this class set in system properties as Configuration.configurationIOsubclass represents an abstract class, an interface, an array class, a primitive type, or void; or if the class has no nullary constructor; or if the instantiation fails for some other reason.
  	 * @throws IOException if an I/O error occered when tried to fetch configuration
  	 *
  	 */
  	private Configuration() throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException{
  		props.load(new FileInputStream("app.properties"));// if it doesn't work, use: src/resources/app.properties
  		confIO = (ConfigurationIO) Class.forName(
  				props.getProperty("Configuration.configurationIOsubclass", "net.sourceforge.jdbdump.connect.FilesystemConfigurationIO")
  				).newInstance();
  		confData = confIO.load();
  		setVariables();
  		autoload = confIO.getDefaultAutoload();
  		autosave = confIO.getDefaultAutosave();
  		backupDir = props.getProperty("Configuration.backupDir");
  	}
  
  	/***
  	 * This method is the only possibility to get an instance of class Configuration. Aim for this limitation is to
  	 * keep control on object creation. 
  	 * @return the Singleton Configuration object;
  	 * @throws ClassNotFoundException 
  	 * @throws IllegalAccessException 
  	 * @throws InstantiationException 
  	 * @throws IOException 
  	 */
  	public static synchronized Configuration getInstance() throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException{
  		if (ref == null)
  			ref = new Configuration();		
  		return ref;
  	}
  
  	/***
  	 * Prevents cloning the Configuration object, and therefore reduces the possibility of creating 
  	 * more than one object - we are avoiding such situations, becouse Configuration is implementing 
  	 * Singleton design pattern 
 	 * 
 	 * @throws CloneNotSupportedException if one tries to clone a Configuration object 
 	 */
 	public Object clone() throws CloneNotSupportedException{
 		throw new CloneNotSupportedException(); 
 	}
 	
 	@SuppressWarnings("unchecked")
 	private void setVariables(){
 		if(confData.containsKey("connections")){
 			connections = (Hashtable<String, DatabaseConnectionData>) confData.get("connections");
 		}
 		if(confData.containsKey("backups")){
 			backups = (Hashtable<String, DatabaseBackupData>) confData.get("backups");
 		}
 		if(confData.containsKey("email")){
 			email = (String) confData.get("email");
 		}
 	}
 	
 	@SuppressWarnings("unchecked")
 	private void putVariables(){
 		confData.put("connections", connections);
 		confData.put("backups", backups);
 		confData.put("users", users);
 		confData.put("email", email);
 	}
 	
 	/***
 	 * Changes value of autosave setting.
 	 * @param value new setting of the autosave flag. 
 	 * @return old value
 	 * @see #autosave
 	 * @see #save()
 	 */
 	public boolean setAutosave(boolean value){
 		boolean old = autosave;
 		autosave = value;
 		return old;
 	}
 	
 	/***
 	 * Changes value of autoload setting.
 	 * @param value new setting of the autoload flag.
 	 * @return old value
 	 * @see #autoload
 	 * @see #reload()
 	 */
 	public boolean setAutoload(boolean value){
 		boolean old = autoload;
 		autoload = value;
 		return old;
 	}
 
 	private void smartReload(){
 		if(autoload){// || users == null || connections == null){	// modify when users are thrown away
 			try {
 				confData = confIO.load();
 			} catch (IOException e) {
 				//  has to be handled!
 			}
 			setVariables();
 		}
 	}
 
 	private void smartSave(){
 		if(autosave){
 			putVariables();
 			try {
 				confIO.save(confData);
 			} catch (IOException e) {
 				//  has to be handled!
 			}
 		}
 	}
 	
 	/***
 	 * Adds data about database connection to current configuration.
 	 *  
 	 * @param dcd database connection to be added
 	 */
 	public void addDatabase(DatabaseConnectionData dcd){
 		connections.put(dcd.getTitle(), dcd);
 		smartSave();
 	}
 	
 	/***
 	 * Removes data about database connection from current configuration.
 	 * 
 	 * @param title name of database connection to be removed
 	 */
 	public void removeDatabase(String title){
 		DatabaseConnectionData dbc = connections.get(title);
 		if(dbc!=null){
 			connections.remove(title);
 		}
 		smartSave();
 	}
 
 	/*** Removes data about database connection from current configuration.
 	 * 
 	 * @param dcd database connection to be removed
 	 */
 	public void removeDatabase(DatabaseConnectionData dbc){
 		String dbTitle = dbc.getTitle();
 		DatabaseConnectionData database = connections.get(dbTitle);
 		if(database!=null)
 			connections.remove(dbTitle);
 		smartSave();
 	}
 
 	/***
 	 * Adds data about database backup to current configuration.
 	 * 
 	 * @param dcd database backup info to be added
 	 */
 	public void addBackup(DatabaseBackupData dbd){
 		backups.put(dbd.getDate()+"|"+dbd.getTitle(), dbd);
 		smartSave();
 	}	
 	/***
 	 * Removes data about database backup from current configuration.
 	 * 
 	 * @param title name of database backup info to be removed
 	 * @param date date of database backup info to be removed
 	 */
 	public void removeBackup(String title, String date){
 		DatabaseBackupData dbc = backups.get(title);
 		if(dbc!=null)
 			backups.remove(dbc);
 		smartSave();
 	}
 
 	/*** Removes data about database backup from current configuration.
 	 * 
 	 * @param dbd database backup info to be removed
 	 */
 	public void removeBackup(DatabaseBackupData dbd){
 		DatabaseConnectionData backup = backups.get(dbd.getDate()+"|"+dbd.getTitle());
 		if(dbd!=null)
 			backups.remove(backup);
 		smartSave();
 	}
 
 	/***
 	 * Returns list of configured database connections
 	 *  
 	 * @return list of configured database connections
 	 */
 	public Hashtable<String, DatabaseConnectionData> getConnections(){
 		smartReload();
 		return connections;
 	}
 	
 	/***
 	 * Returns list of backuped databases
 	 *  
 	 * @return list of backuped databases
 	 */
 	public Hashtable<String, DatabaseBackupData> getBackups(){
 		smartReload();
 		return backups;
 	}
 	
 	public String getEmail(){
 		smartReload();
 		return email;
 	}
 	
 	public void setEmail(String e){
 		email = e;
 		smartSave();
 	}
 	
 	/***
 	 * Saves configuration storred in the Configuration object. 
 	 * 
 	 */
 	public void saveData() throws IOException{
 		putVariables();
 		confIO.save(confData);
 	}
 	
 	/***
 	 * Loads configuration data to the Configuration object
 	 * 
 	 */
 	public void loadData() throws IOException, ClassNotFoundException{
 		confData = confIO.load();
 		setVariables();
 	}
 	
 	
 	public String getBackupDir(){
 		return backupDir; 
 	}
 }