package org.naftulin.configmgr;
   
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
  import java.util.Map.Entry;
  
  import org.apache.log4j.Logger;
  import org.naftulin.configmgr.parsers.ConfigurationRecordsToEntriesConverter;
  
  /***
   * Configuration Management provides a convinient way to manage configuration for your programs.
   * Alows to load and reload configurations, add configuration, list all the configurations and
   * returns configuration manager interface. Configuration manager interface returns configuration
   * based on the key.
   *  
   * @author Henry Naftulin
   * @since 1.0
   */
  public class ConfigurationManagementImpl implements ConfigurationManagement {
  	private final class ConfigurationManagerImpl implements ConfigurationManager {
  		/***
  		 * Returns the configuration based on the key. 
  		 * If the configuration is not found or is in error state throws an exception.
  		 * @param key configuration mapped under.
  		 * @return the configuration based on the key.
  		 * @throws ConfigurationManagerException if configuration is not found or in error state.
  		 */
  		public Object getConfiguration(final String key) throws ConfigurationManagerException {
  			ConfigurationManagementEntry entry;
  			synchronized (lock) {
  				if (configuration.containsKey(key)) {
  					entry = configuration.get(key);
  					if (! entry.isError()) {
  						return entry.getContent();
  					}
  					throw new ConfigurationManagerException("Entry was found, but it is in error state. " + entry.getContent());
  				}					
  			}
  			log.warn("no entry for " + key + " is found in the configuration manager");
  			throw new EntryNotFoundException("no entry for " + key + " is found.");
  		}
  
  		/***
  		 * Returns the configuration based on the key if found and not in error state. Otherwise
  		 * returns null.
  		 * @param key configuration mapped under.
  		 * @return conifguration if found and it does not countain errors, null otherwise
  		 */
  		public Object getConfigurationSilent(final String key) {
  			boolean entryFound = false;
  			ConfigurationManagementEntry entry = null;
  			Object retObject = null;
  			// minimal syncronized block
  			synchronized (lock) {
  				entryFound = configuration.containsKey(key);
  				if (entryFound) {
  					entry = configuration.get(key);
  					if (!entry.isError()) {
  						retObject = entry.getContent();
  					}
  				}
  			}
  
  			if (!entryFound) {
  				log.warn("no entry for " + key + " is found in the configuration manager");
  			}
  			return retObject;
  		}
  
  		
  	}
  
  	private static final Logger log = Logger.getLogger(ConfigurationManagementImpl.class);
  
  	/***
  	 * Anonymous private class that represents configuration manager interface.
  	 */
  	private final ConfigurationManager manager;
  	private final Object lock;
  	private String masterRecordFileName;
  	private Map<String, ConfigurationManagementEntry> configuration = new HashMap<String, ConfigurationManagementEntry>();
  	private boolean intialized;
  	
  	
  	/***
  	 * Creates a configuration manager without any configurations. Needed only for the unit testing.
  	 */
  	ConfigurationManagementImpl() {
  		lock = new Object();
  		manager = new ConfigurationManagerImpl();
  	}
  
  	/***
  	 * Creates a configuration management engine given a master configuration file.
 	 * @param masterRecordFileName a file that describes configuration for configuration manager
 	 * @throws ConfigurationManagerException if master configuration file cannot be read or contains an error.
 	 */
 	ConfigurationManagementImpl(String masterRecordFileName) throws ConfigurationManagerException {
 		this();
 		this.masterRecordFileName = masterRecordFileName;
 		//no reload necessary here, it is done on the factory level. More flexibe that way, which is
 		//if we were to create configuration manager we can control when to load the configurations...reload();
 	}
 	
 	/***
 	 * Reloades configurations stored in the configuration management engine. The
 	 * configurations are read again, parsed and stored.
 	 * @throws ConfigurationManagerException if a problem occurs while reading or parsing the configurations.
 	 */
 	public void reload() throws ConfigurationManagerException {
 		final Map<String, ConfigurationManagementEntry> newConfig = readConfiguration();
 		synchronized (lock) {
 			this.configuration = newConfig;
 			this.intialized = true;
 		}
 
 	}
 
 	/***
 	 * Returns {@link ConfigurationManagementEntry configuration management entry} based on the key passed.
 	 * @param key key the entry is stored under
 	 * @return configuration management entry based on the key passed
 	 * @throws ConfigurationManagerException if the entry is not found.
 	 */
 	public ConfigurationManagementEntry getConfigurationManagmentEntry(final String key) throws ConfigurationManagerException {
 		boolean entryFound = false;
 		ConfigurationManagementEntry entry = null;
 		synchronized (lock) {
 			entryFound = configuration.containsKey(key);
 			entry = configuration.get(key);
 		}
 		if (!entryFound) {
 			throw new EntryNotFoundException("Entry identified by key "+ key + " was not found");
 		}
 		return entry;
 	}
 
 	/***
 	 * Returns a list of {@link ConfigurationManagementEntry configuration management entries} managed by this configuration managment engine.
 	 * @return a list of {@link ConfigurationManagementEntry configuration management entries} managed by this configuration managment engine.
 	 */
 	public List<ConfigurationManagementEntry> getConfigurationManagmentEntries() {
 		final List<ConfigurationManagementEntry> entries = new LinkedList<ConfigurationManagementEntry>();
 		Set<Entry<String, ConfigurationManagementEntry>> set = null;
 		synchronized (lock) {
 			set = Collections.unmodifiableSet(this.configuration.entrySet());
 		}
 		if (set != null) {
 			Iterator<Entry<String, ConfigurationManagementEntry>> it = set.iterator();
 			while(it.hasNext()) {
 				Entry<String, ConfigurationManagementEntry> mapEntry = it.next();
 				entries.add((ConfigurationManagementEntry) mapEntry.getValue());
 			}
 		}
 		return Collections.unmodifiableList(entries);
 	}
 
 	/***
 	 * Returns true if configuration Management has loaded configurations. Returns false
 	 * before that point. After instantiation, we can confgure where configuration master
 	 * record is read from. Once the master record is configured, we will be able to reload
 	 * configuration manager. Reloading configuration manager will load all configurations,
 	 * and the flag will switch to initialized.  
 	 * @return true if configuration Management has loaded configurations.	
 	 */
 	public boolean isInitialized() {		
 		synchronized (lock) {
 			return intialized;
 		}		
 	}
 	
 	/***
 	 * Returns a map with {@link ConfigurationManagementEntry configuration management entries} keyed by confguration entry key. 
 	 * Reads and parses all configuration entries described in master confiuration file.
 	 * @return  a map with {@link ConfigurationManagementEntry configuration management entries} keyed by confguration entry key. 
 	 * @throws ConfigurationManagerException if a configuration cannot be read or parsed.
 	 */
 	private Map<String, ConfigurationManagementEntry> readConfiguration() throws ConfigurationManagerException {
 		final Map<String, ConfigurationManagementEntry> newConfiguration = new HashMap<String, ConfigurationManagementEntry>();
 		if (masterRecordFileName != null) {
 			final ConfigurationRecordsToEntriesConverter converter = new ConfigurationRecordsToEntriesConverter();
 			final ConfigurationManagementEntry[] entries = converter.createConfigurationEntriesFromConfigurationFile(masterRecordFileName);
 			for(int i=0; i < entries.length; ++i) {
 				addConfigurationManagmentEntry(newConfiguration, entries[i]);
 			}
 		}
 		return newConfiguration;
 	}
 
 	/***
 	 * Returns configuration manager created by the configuration management engine.
 	 * @return configuration manager.
 	 */
 	public ConfigurationManager getConfigurationManager() {
 		synchronized(lock) {
 			return this.manager;
 		}
 	}
 
 	/***
 	 * Adds a configuration entry to the configuration manager. Needed to add ad-hoc
 	 * configurations to the configuration manager. when adding a new configuration with the same key
 	 * old configuration should be replaced. Is overwritten flag for the new 
 	 * configuration should be set. Delegates to private method that takes
 	 * a map to which the configuration is added.
 	 * @param entry configuration entry
 	 * @exception if the entry is in error 
 	 */
 	public void addConfigurationManagmentEntry(final ConfigurationManagementEntry entry) throws EntryInErrorException {
 		addConfigurationManagmentEntry(this.configuration, entry);
 	}
 	
 	/***
 	 * Adds a configuration entry to the configuration manager. Needed to add ad-hoc
 	 * configurations to the configuration manager. when adding a new configuration with the same key
 	 * old configuration should be replaced. Is overwritten flag for the new 
 	 * configuration should be set. 
 	 * @param toConfiguration a configuration to which an entry is added
 	 * @param entry configuration entry
 	 * @exception if the entry is in error 
 	 */
 	private void addConfigurationManagmentEntry(final Map<String, ConfigurationManagementEntry> toConfiguration, 
 			final ConfigurationManagementEntry entry) throws EntryInErrorException {
 		if (entry.getKey() == null) {
 			throw new EntryInErrorException("Entry key should not be null. Entry is " + entry);
 		}
 		synchronized(lock) {
 			final Object obj = toConfiguration.put(entry.getKey(), entry);
 			entry.setOverwritten(obj != null);
 		}
 	}
 }