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);

                 }

         }

 }