package com.melloware.jukes.gui.tool;
   
   import java.util.Enumeration;
   import java.util.prefs.Preferences;
   
   import javax.swing.event.TreeSelectionEvent;
   import javax.swing.event.TreeSelectionListener;
   import javax.swing.tree.DefaultMutableTreeNode;
   import javax.swing.tree.DefaultTreeModel;
  import javax.swing.tree.DefaultTreeSelectionModel;
  import javax.swing.tree.TreeModel;
  import javax.swing.tree.TreeNode;
  import javax.swing.tree.TreePath;
  import javax.swing.tree.TreeSelectionModel;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.jgoodies.binding.beans.Model;
  import com.jgoodies.uif.application.Application;
  import com.jgoodies.uifextras.convenience.SetupManager;
  import com.melloware.jukes.db.orm.AbstractJukesObject;
  import com.melloware.jukes.db.orm.Artist;
  import com.melloware.jukes.db.orm.Catalog;
  import com.melloware.jukes.db.orm.Disc;
  import com.melloware.jukes.db.orm.Track;
  import com.melloware.jukes.gui.view.node.AbstractTreeNode;
  import com.melloware.jukes.gui.view.node.ArtistNode;
  import com.melloware.jukes.gui.view.node.DiscNode;
  import com.melloware.jukes.gui.view.node.NavigationNode;
  import com.melloware.jukes.gui.view.node.RootNode;
  import com.melloware.jukes.gui.view.node.TrackNode;
  
  /**
   * Provides bound bean properties for the catalog, navigation tree,
   * navigation tree selection, selection type. Refers to the
   * presentation settings and a submodule for the dynamic help.
   * <p>
   * Copyright (c) 1999-2007 Melloware, Inc. <http://www.melloware.com>
   * @author Emil A. Lefkof III <info@melloware.com>
   * @version 4.0
   *
   * @see Settings
   * @see DynamicHelpModule
   */
  public final class MainModule
      extends Model {
  
      private static final Log LOG = LogFactory.getLog(MainModule.class);
  
      public static final String PROPERTYNAME_CATALOG = "catalog";
      public static final String PROPERTYNAME_HIGHLIGHT = "highlight";
      public static final String PROPERTYNAME_SELECTION = "selection";
      public static final String PROPERTYNAME_SELECTION_TYPE = "selectionType";
      public static final String PROPERTYNAME_NAVIGATION_TREE_MODEL = "navigationTreeModel";
  
      /**
       * Refers to the submodule for the UI-related settings.
       *
       * @see #getSettings()
       */
      public static final Settings SETTINGS = new Settings();
  
      /**
       * Holds the current catalog.
       *
       * @see #getCatalog()
       * @see #setCatalog(Catalog)
       */
      private Catalog catalog;
  
      /**
       * Holds the class of the current selection.
       *
       * @see #getSelection()
       * @see #getSelectionType()
       */
      private Class selectionType;
  
      /**
       * Holds the node that refers to the current selection.
       * Used to report a potential change to its hosting tree model
       * when the selection changes. This is because the node's label
       * may have changed as part of the editor change.<p>
       *
       * This is a poor workaround that is based on the weak assumumption
       * that this class's tree selection listener is the first to know
       * about the node change.<p>
       */
      private NavigationNode selectedNode;
  
      /**
       * Holds the current selection, an instance of Model.
       *
       * @see #getSelection()
       * @see #getSelectionType()
       */
      private Object selection;
 
     /**
      * Holds the model for the navigation tree.
      * It changes everytime this module's catalog changes.
      *
      * @see #getNavigationTreeModel()
      * @see #getNavigationTreeSelectionModel()
      */
     private TreeModel navigationTreeModel;
 
     /**
      * Refers to the single selection model for the navigation tree.
      * The selection is reset if the navigation tree model changes.
      *
      * @see #getNavigationTreeSelectionModel()
      * @see #getNavigationTreeModel()
      */
     private final TreeSelectionModel navigationTreeSelectionModel = new DefaultTreeSelectionModel();
 
     /**
      * Constructs a <code>MainModule</code> that has no catalog set,
      * no selection and no tree model.
      */
     public MainModule() {
         LOG.debug("MainModule created.");
         restoreState();
     }
 
     /**
      * Returns the current catalog.
      *
      * @return the current catalog.
      */
     public Catalog getCatalog() {
         return catalog;
     }
 
     /**
      * Returns the tree model for the navigation tree.
      *
      * @return the tree model for the navigation tree.
      */
     public TreeModel getNavigationTreeModel() {
         return navigationTreeModel;
     }
 
     /**
      * Returns the fixed selection model for the navigation tree.
      *
      * @return the fixed selection model for the navigation tree.
      */
     public TreeSelectionModel getNavigationTreeSelectionModel() {
         return navigationTreeSelectionModel;
     }
 
     /**
      * Gets the selectedNode.
      * <p>
      * @return Returns the selectedNode.
      */
     public NavigationNode getSelectedNode() {
         return this.selectedNode;
     }
 
     /**
      * Returns the current selection, a domain object. This selection
      * will be updated if the selection in the navigation tree changes.
      * During the transition from one tree selection to another this
      * value may hold the old or new selection.
      *
      * @return the domain object selected in the navigation tree.
      *
      * @see #getSelectionType()
      */
     public Object getSelection() {
         return selection;
     }
 
     /**
      * Returns the class of the selected domain object.
      *
      * @return the class of the selected domain object.
      *
      * @see #getSelection()
      */
     public Class getSelectionType() {
         return selectionType;
     }
 
     /**
      * Sets a new catalog.
      *
      * @param newCatalog   the catalog to set
      *
      * @throws NullPointerException if the new catalog is null
      */
     public void setCatalog(final Catalog newCatalog) {
         if (newCatalog == null) {
             throw new IllegalArgumentException("The catalog must not be null.");
         }
 
         final Catalog oldCatalog = getCatalog();
         catalog = newCatalog;
         firePropertyChange(PROPERTYNAME_CATALOG, oldCatalog, newCatalog);
         setNavigationTreeModel(createNavigationTreeModel(newCatalog));
 
     }
 
     /**
      * Checks and answers whether the catalog's file path is valid.
      *
      * @return true if the catalog's file path is valid.
      */
     public boolean isCatalogFilePathValid() {
         return false;
     }
 
     /**
      * Checks and answers if a catalog is loaded.
      *
      * @return true if a catalog is loaded.
      */
     public boolean hasCatalog() {
         return getCatalog() != null;
     }
 
     /**
      * Refreshes the currently selected tree node.
      * <p>
      * @param domainObject the domain object may be useful
      * @param operation NODE_INSERTED, NODE_DELETED, NODE_CHANGED
      */
     public void refreshSelection(final Object domainObject, final String operation) {
         if (selectedNode == null) {
             return;
         }
         final DefaultTreeModel treeModel = ((DefaultTreeModel)getNavigationTreeModel());
         if (Resources.NODE_CHANGED.equals(operation)) {
             treeModel.nodeChanged(selectedNode);
             LOG.debug("Tree Node changed.");
         } else if (Resources.NODE_DELETED.equals(operation)) {
         	final TreeNode parent = selectedNode.getParent();
             if (parent != null) {
                 LOG.debug("Tree Node Deleted");
                 treeModel.removeNodeFromParent((DefaultMutableTreeNode)selectedNode);
                 setSelectedNode((AbstractTreeNode)parent);
             }
         }
     }
 
     /**
      * Refreshes the tree node from the database.
      * <p>
      * @throws NullPointerException if the new catalog is null
      */
     public void refreshTree() {
         setCatalog(new Catalog(SETTINGS.getFilter()));
         firePropertyChange(PROPERTYNAME_SELECTION, selection, null);
     }
 
     /**
      * Restores the application state from the user preferences.
      */
     public void restoreState() {
         SETTINGS.restoreFrom(Application.getUserPreferences());
     }
 
     /**
      * Finds the selection in the tree and expands the node and sets the editor.
      *
      * @param newSelection   the selection to set
      *
      * @see #getSelection()
      */
     public void selectNodeInTree(final Object newSelection) {
         final AbstractJukesObject selection = (AbstractJukesObject)newSelection;
         AbstractTreeNode node = null;
         String artistName = null;
         String discName = null;
         String trackName = null;
 
         if (selection instanceof Artist) {
             artistName = selection.getName();
         } else if (selection instanceof Disc) {
             final Disc disc = (Disc)selection;
             artistName = disc.getArtist().getName();
             discName = selection.getName();
         } else if (selection instanceof Track) {
             final Track track = (Track)selection;
             artistName = track.getDisc().getArtist().getName();
             discName = track.getDisc().getName();
             trackName = selection.getName();
         }
 
         final DefaultTreeModel treeModel = ((DefaultTreeModel)navigationTreeModel);
         final AbstractTreeNode root = (AbstractTreeNode)treeModel.getRoot();
 
         // loop through the artists
         ArtistNode artistNode = null;
         if (StringUtils.isNotBlank(artistName)) {
             final Enumeration artistEnum = root.children();
             while (artistEnum.hasMoreElements()) {
                 artistNode = (ArtistNode)artistEnum.nextElement();
                 if (StringUtils.equalsIgnoreCase(artistNode.toString(), artistName)) {
                     node = artistNode;
                     break;    // found it
                 }
             }
         }
 
         // now get the disc
         DiscNode discNode = null;
         if ((StringUtils.isNotBlank(discName)) && (artistNode != null)) {
             final Enumeration discEnum = artistNode.children();
             while (discEnum.hasMoreElements()) {
                 discNode = (DiscNode)discEnum.nextElement();
                 if (StringUtils.equalsIgnoreCase(discNode.toString(), discName)) {
                     node = discNode;
                     break;    // found it
                 }
             }
         }
 
         // now get the track
         TrackNode trackNode = null;
         if ((StringUtils.isNotBlank(trackName)) && (discNode != null)) {
             final Enumeration trackEnum = discNode.children();
             while (trackEnum.hasMoreElements()) {
                 trackNode = (TrackNode)trackEnum.nextElement();
                 if (StringUtils.equalsIgnoreCase(trackNode.toString(), trackName)) {
                     node = trackNode;
                     break;    // found it
                 }
             }
         }
 
         if (node != null) {
             // tree node found
             setSelectedNode(node);
 
             // fire this property change to tell the tree to select the node
             firePropertyChange(PROPERTYNAME_HIGHLIGHT, null, "Highlight");
         }
     }
 
     /**
      * Stores the application state to the user preferences.
      */
     public void storeState() {
         final Preferences prefs = Application.getUserPreferences();
         SETTINGS.storeIn(prefs);
         SetupManager.incrementUsageCounter();
     }
 
     /**
      * Sets a new tree model for the navigation tree.<p>
      *
      * @param newModel  the new tree model to set
      */
     private void setNavigationTreeModel(final TreeModel newModel) {
     	final TreeModel oldModel = getNavigationTreeModel();
         navigationTreeModel = newModel;
         firePropertyChange(PROPERTYNAME_NAVIGATION_TREE_MODEL, oldModel, newModel);
     }
 
     /**
      * Sets the selection and reports the previously selected node as changed.<p>
      *
      * <strong>Note:</strong> This code requires a special order. It assumes
      * that domain changes happen when the selection changes.<p>
      *
      * @param newSelectedNode   the new node selection
      */
     private void setSelectedNode(final NavigationNode newSelectedNode) {
     	final NavigationNode oldSelectedNode = selectedNode;
         selectedNode = newSelectedNode;
         setSelection(newSelectedNode.getModel());
         ((DefaultTreeModel)getNavigationTreeModel()).nodeChanged(oldSelectedNode);
     }
 
     /**
      * Sets a new domain object as selection. This method is invoked
      * by the NavigationTreeSelectionChangeHandler that observes changes in
      * the selection of the navigation tree.
      *
      * @param newSelection   the selection to set
      *
      * @see #getSelection()
      */
     private void setSelection(final Object newSelection) {
     	final Object oldSelection = getSelection();
         selection = newSelection;
         setSelectionType(newSelection.getClass());
         firePropertyChange(PROPERTYNAME_SELECTION, oldSelection, newSelection);
     }
 
     /**
      * Sets a new selection type. This method is invoked in
      * <code>#setSelection</code> with the class of the new selection.
      *
      * @param newSelectionType   the selection type to set
      *
      * @see #getSelectionType()
      */
     private void setSelectionType(final Class newSelectionType) {
     	final Class oldSelectionType = getSelectionType();
         selectionType = newSelectionType;
         if (equals(oldSelectionType, newSelectionType)) {
             return;
         }
 
         firePropertyChange(PROPERTYNAME_SELECTION_TYPE, oldSelectionType, newSelectionType);
     }
 
     /**
      * Creates and returns a tree model for the given catalog.
      * Constructs a <code>RootNode</code> with the catalog and
      * returns a <code>DefaultTreeModel</code> with this root.
      *
      * @return a TreeModel for the given catalog
      */
     private TreeModel createNavigationTreeModel(final Catalog catalog) {
     	final RootNode rootNode = new RootNode(catalog);
         rootNode.setSettings(SETTINGS);
         final DefaultTreeModel model = new DefaultTreeModel(rootNode);
         navigationTreeSelectionModel.setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
         navigationTreeSelectionModel.addTreeSelectionListener(new NavigationTreeSelectionChangeHandler());
         return model;
     }
 
     // Listens to changes in the navigation tree node selection
     // and updates the selection.
     private class NavigationTreeSelectionChangeHandler
         implements TreeSelectionListener {
 
         /**
          * The selected node in the navidation tree has changed.
          * Updates this module's selected domain object and in turn
          * the selection type.<p>
          *
          * Does nothing if the new tree selection is <code>null</code>.
          *
          * @param evt    the event that describes the change
          */
         public void valueChanged(final TreeSelectionEvent evt) {
         	final TreePath path = evt.getPath();
         	final NavigationNode aSelectedNode = (NavigationNode)path.getLastPathComponent();
             if (aSelectedNode != null) {
                 setSelectedNode(aSelectedNode);
             }
         }
 
     }
 
 }