package com.explosion.utilities.preferences.groups;
   
   /*
    * =============================================================================
    * 
    * Copyright 2004 Stephen Cowx
    * 
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   * 
   * http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   * 
   * =============================================================================
   */
  
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.Hashtable;
  import java.util.Vector;
  
  import com.explosion.utilities.preferences.Preference;
  
  /***
   * Author: Stephen Cowx Date: Jan 25, 2003 Time: 14:29:26 PM
   * <p>
   * This class provides a useful mechanism for maintaining a list of
   * PersistentObjects.
   * 
   * The only method which needs overriding is the loadusing method. Which will
   * load the objects from whatever persistent store has been used.
   * </p>
   */
  public abstract class PreferenceGroupManager
  {
  
      private Hashtable groups = new Hashtable(0);
      private Vector identifiers = new Vector();
      private Object referenceToStore;
  
      public PreferenceGroupManager(Object referenceToStore) throws Exception
      {
          this.referenceToStore = referenceToStore;
      }
      
      /***
       * Method getGroup.
       * 
       * @param identifier
       * @return PreferenceGroup
       */
      public PreferenceGroup getGroup(String identifier)
      {
          return (PreferenceGroup) groups.get(identifier);
      }
  
      /***
       * Method setGroup.
       * 
       * @param identifier
       * @param instance
       */
      public void setGroup(String identifier, PreferenceGroup instance) throws Exception
      {
          if (groups.get(identifier) == null)
              addGroup(identifier, instance);
          else
              groups.put(identifier, instance);
      }
  
      /***
       * Method removeGroup.
       * 
       * @param identifier
       */
      public void deleteGroup(String identifier) throws Exception
      {
          if (groups.get(identifier) != null) ((PreferenceGroup) groups.get(identifier)).delete();
  
          groups.remove(identifier);
          identifiers.remove(identifier);
      }
  
      /***
       * Method addGroup.
       * 
       * @param instance
       */
      public void addGroup(String identifier, PreferenceGroup instance) throws Exception
      {
          if (groups.get(identifier) != null)
              throw new Exception("Cannot add '" + identifier + "' because this name is already being used.");
          else
         {
             groups.put(identifier, instance);
             identifiers.addElement(identifier);
             instance.setReferenceToStore(getReferenceForGroup(identifier));
             instance.commit();
         }
     }
 
     /***
      * Method loadUsing. Loads all of these persistent objects from their
      * persistent store.
      * 
      * @param uri
      */
     public abstract void loadUsing(Object referenceToStore) throws Exception;
     
     /***
      * Returns an empty PreferenceGroup.  IMplementors must provide this method 
      * for creating new groups
      * 
      * @param uri
      */
     public abstract PreferenceGroup createGroup(String identifier) throws Exception;
 
     /***
      * Return the correct node for the group with the given identifier
      * @param identifier
      * @return
      */
     public abstract Object getReferenceForGroup(String identifier);
     
     /***
      * Method saveAll. Saves all of the PersistentObjects to their persistent
      * store
      */
     public void saveAll() throws Exception
     {
         Enumeration en = groups.elements();
         while (en.hasMoreElements())
         {
             PreferenceGroup object = (PreferenceGroup) en.nextElement();
             object.commit();
         }
     }
 
     /***
      * Method removeAll. Removes all of these Persistent Objects from the
      * Manager as well as from their persistent store. Non-reversible
      */
     public void removeAll() throws Exception
     {
         Enumeration en = groups.elements();
         while (en.hasMoreElements())
         {
             PreferenceGroup object = (PreferenceGroup) en.nextElement();
             object.delete();
         }
         groups = new Hashtable();
         identifiers = new Vector();
     }
 
     /***
      * Method sort.
      */
     public void sort()
     {
         Collections.sort(identifiers);
     }
 
     /***
      * Returns the groups.
      * 
      * @return Hashtable
      */
     public Hashtable getGroups()
     {
         return groups;
     }
 
     /***
      * Returns the identifiers.
      * 
      * @return Vector
      */
     public Vector getIdentifiers()
     {
         return identifiers;
     }
 
     /***
      * Sets the groups.
      * 
      * @param groups The groups to set
      */
     public void setGroups(Hashtable objectsHash)
     {
         this.groups = objectsHash;
     }
 
     /***
      * Sets the identifiers.
      * 
      * @param identifiers The identifiers to set
      */
     public void setObjectsVector(Vector objectsVector)
     {
         this.identifiers = objectsVector;
     }
 
     /***
      * Renames the instance and makes it available from it's new location
      * 
      * @param oldName The old name ofthe instance
      * @param newName The new name ofthe instance
      */
     public void renameGroup(String oldName, String newName) throws Exception
     {
         if (groups.get(oldName) != null)
         {
             PreferenceGroup object = ((PreferenceGroup) groups.get(oldName));
             object.setIdentifier(newName);
 
             groups.put(newName, object);
             identifiers.addElement(newName);
 
             groups.remove(oldName);
             identifiers.remove(oldName);
         }
 
     }
 
     public void duplicateGroup(String nameOfOriginal, String nameOfCopy) throws Exception
     {
         //@TODO FIX this method so that it handles duplicating collections
     	if (nameOfOriginal.equalsIgnoreCase(nameOfCopy)) throw new IllegalArgumentException("Name of original may not be the same as the name of the copy.");
 
     	PreferenceGroup group = (PreferenceGroup) groups.get(nameOfOriginal);
     	if ( group != null)
         {
             PreferenceGroup original = ((PreferenceGroup) groups.get(nameOfOriginal));
             PreferenceGroup copy = new PreferenceGroup(original.getReferenceToStore(), nameOfCopy);
             Enumeration en = original.getPreferencesHash().keys();
             while (en.hasMoreElements())
             {
                 String preferenceName = (String) en.nextElement();
                 Preference pref = original.getPreference(preferenceName);
                 Preference duplicate = (Preference) pref.clone();
                 copy.addPreference(duplicate.getUniqueIdentifier(), duplicate);
             }
             
             addGroup(nameOfCopy, group);
         }
     }
 
     /***
      * @return Returns the referenceToStore.
      */
     public Object getReferenceToStore()
     {
         return referenceToStore;
     }
     
     /***
      * @param referenceToStore The referenceToStore to set.
      */
     public void setReferenceToStore(Object referenceToStore)
     {
         this.referenceToStore = referenceToStore;
     }
 }