package com.melloware.jukes.gui.view.editor;
   
   import java.awt.Color;
   import java.awt.Component;
   import java.awt.Container;
   import java.awt.Cursor;
   import java.awt.Font;
   import java.awt.KeyboardFocusManager;
   import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Locale;
  
  import javax.swing.BorderFactory;
  import javax.swing.Icon;
  import javax.swing.JComboBox;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JTextArea;
  import javax.swing.JTextField;
  import javax.swing.JToolBar;
  import javax.swing.ProgressMonitor;
  import javax.swing.Timer;
  import javax.swing.border.Border;
  import javax.swing.text.JTextComponent;
  
  import com.jgoodies.forms.builder.PanelBuilder;
  import com.jgoodies.forms.layout.CellConstraints;
  import com.jgoodies.forms.layout.FormLayout;
  import com.jgoodies.uif.action.ActionManager;
  import com.jgoodies.uif.application.Application;
  import com.jgoodies.uif.component.ToolBarButton;
  import com.jgoodies.uifextras.util.UIFactory;
  import com.jgoodies.validation.view.ValidationComponentUtils;
  import com.jgoodies.validation.view.ValidationResultViewFactory;
  import com.melloware.jukes.db.orm.AbstractJukesObject;
  import com.melloware.jukes.gui.tool.Actions;
  import com.melloware.jukes.gui.tool.MainModule;
  import com.melloware.jukes.gui.tool.Resources;
  import com.melloware.jukes.gui.tool.Settings;
  import com.melloware.jukes.gui.view.MainFrame;
  import com.melloware.jukes.gui.view.tasks.UpdateTagsTask;
  import com.melloware.jukes.gui.view.validation.AbstractValidationModel;
  import com.melloware.jukes.util.MessageUtil;
  
  /**
   * The abstract superclass of all <code>Editor</code> implementations.
   * <p>
   * Copyright (c) 1999-2007 Melloware, Inc. <http://www.melloware.com>
   * @author Emil A. Lefkof III <info@melloware.com>
   * @version 4.0
   */
  @SuppressWarnings("PMD")
  abstract public class AbstractEditor
      extends JPanel
      implements Editor {
  
      protected static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MMM dd yyyy h:mm a", Locale.US);
      protected static final Font FONT_ENABLED = new JLabel().getFont();
      protected static final Font FONT_DISABLED = FONT_ENABLED.deriveFont(FONT_ENABLED.getStyle() ^ Font.BOLD);
      protected static final Border BORDER_ENABLED = new JTextField().getBorder();
      protected static final Border BORDER_DISABLED = BorderFactory.createEmptyBorder();
      protected static final String HINT = "HINT";
      protected AbstractValidationModel validationModel;
      protected final Icon icon;
      protected JComponent hintAreaPane;
      protected JLabel createdByLabel;
      protected JLabel createdDateLabel;
      protected JLabel hintLabel;
      protected JLabel modifiedByLabel;
      protected JLabel modifiedDateLabel;
      protected JTextArea hintArea;
      protected ProgressMonitor progressMonitor;
      protected final String titlePrefix;
      protected Timer timer;
      protected UpdateTagsTask task;
      private Object model;
  
      /**
       * Constructs an <code>AbstractEditor</code> with the specified icon.
       */
      public AbstractEditor(Icon icon) {
          this(icon, "");
      }
  
      /**
       * Constructs an <code>AbstractEditor</code> with the specified title
       * prefix.
       */
      public AbstractEditor(String titlePrefix) {
          this(null, titlePrefix);
      }
  
      /**
       * Constructs an <code>AbstractEditor</code> with the specified
      * <code>Icon</code> and title prefix.
      */
     public AbstractEditor(Icon icon, String titlePrefix) {
         this.icon = icon;
         this.titlePrefix = titlePrefix;
         build();
     }
 
     /**
      * Returns the class used to register this instance in the UpdateManager.
      */
     abstract public Class getDomainClass();
 
     /**
      * Answers this <code>Editor</code>'s <code>JToolBar</code>.
      * The default implementation specifies that no tool bar is used.
      */
     public JToolBar getHeaderToolBar() {
         return null;
     }
 
     /**
      * Answers this <code>Editor</code>'s <code>Icon</code>.
      */
     public Icon getIcon() {
         return icon;
     }
 
     /**
      * Returns this editor's underlying model.
      */
     public Object getModel() {
         return model;
     }
 
     /**
      * Returns this editor's underlying model as an AbstractJukesObject.
      */
     public AbstractJukesObject getOrmObject() {
         return (AbstractJukesObject)model;
     }
 
     /**
      * Answers this <code>Editor</code>'s title.
      */
     public String getTitle() {
         return titlePrefix + ' ' + getTitleSuffix();
     }
 
     /**
      * Answers this <code>Editor</code>'s <code>JToolBar</code>.
      * The default implementation specifies that no tool bar is used.
      */
     public JToolBar getToolBar() {
         return null;
     }
 
     /**
      * Sets a new model. Does nothing if the old and new model are the same.
      * If the model changes, invokes <code>#updateView</code>.
      *
      * @param newModel   the model to set
      */
     public void setModel(Object newModel) {
         Object oldModel = getModel();
         if ((oldModel != null) &&(oldModel.equals(newModel))) {
         	this.lock();
         	
             return;
         }
         model = newModel;
         updateView();
         this.lock();
     }
 
     /**
      * Activates this viewer.
      */
     public void activate() {
         // Do nothing by default; subclasses may override.
     }
 
     /**
      * Commits any changes made to this editor.
      */
     public void commit() {
     	this.lock();
     }
     
     /**
      * Unlocks this viewer and updates all text fields and buttons.
      */
     public void unlock() {
     	ActionManager.get(Actions.UNLOCK_ID).setEnabled(false);
     	validationModel.updateButtonState(true);
         final Collection components = getAllComponents(this);
     	
     	for (Iterator iter = components.iterator(); iter.hasNext();) {
 			final Component component = (Component) iter.next();
 			if (component instanceof JTextComponent) {
 				final JTextComponent field = (JTextComponent)component;
 				//skip if this is the hint area
 				if (field.getClientProperty(HINT) != null) {
 					continue;
 				}
 				field.setEnabled(true);
 				field.setBorder(BORDER_ENABLED);
 				field.setOpaque(true);
 				field.setFont(FONT_ENABLED);
 			} else if (component instanceof JComboBox) {
 				final JComboBox field = (JComboBox)component;
 				field.setEnabled(true);
 				field.setVisible(true);
 			} else if (component instanceof JLabel) {
 				final JLabel field = (JLabel)component;
 				if ("GENRE".equalsIgnoreCase(field.getName())) {
 					field.setVisible(false);
 				}
 			} else if (component instanceof ToolBarButton) {
 				final ToolBarButton button = (ToolBarButton)component;
 				button.setVisible(true);
 			}
 		}
     	
     	this.updateUI();
     }
     
     /**
      * Locks this viewer and updates all text fields and buttons.
      */
     public void lock() {
     	ActionManager.get(Actions.UNLOCK_ID).setEnabled(true);
     	validationModel.updateButtonState(false);
     	final Collection components = getAllComponents(this);
     	
     	for (Iterator iter = components.iterator(); iter.hasNext();) {
 			final Component component = (Component) iter.next();
 			if (component instanceof JTextComponent) {
 				final JTextComponent field = (JTextComponent)component;
 				//skip if this is the hint area
 				if (field.getClientProperty(HINT) != null) {
 					continue;
 				}
 				
 				field.setEnabled(false);
 				field.setDisabledTextColor(Color.BLACK);
 				field.setBorder(BORDER_DISABLED);
 				field.setOpaque(false);
 				field.setFont(FONT_DISABLED);
 			}  else if (component instanceof JComboBox) {
 				final JComboBox field = (JComboBox)component;
 				field.setEnabled(false);
 				field.setVisible(false);
 			} else if (component instanceof JLabel) {
 				final JLabel field = (JLabel)component;
 				if ("GENRE".equalsIgnoreCase(field.getName())) {
 					final String text = field.getText().trim();
 					field.setText("  " + text);
 					field.setVisible(true);
 					field.setFont(FONT_DISABLED);
 				}
 			} else if (component instanceof ToolBarButton) {
 				final ToolBarButton button = (ToolBarButton)component;
 				button.setVisible(false);
 			}
 			
 		}
     	
     	this.updateUI();
     }
     
     /**
      * Recurse through a component and build a list of all the components 
      * underneath of it.
      * <p>
      * @param aTop the top container
      * @return the collection of all components under the container
      */
     private Collection getAllComponents(Container aTop) {
     	final Component[] comp = aTop.getComponents();
     	final ArrayList list = new ArrayList();
     	
     	if (comp.length == 0) {
 			return list;
 		}
     	
     	for (int i = 0; i < comp.length; i++) {
     		list.add(comp[i]);
     		if (comp[i] instanceof Container) {
 				list.addAll(getAllComponents((Container)comp[i]));
 			}
 		}
     	return list;
     }
 
     /**
      * Deactivates this viewer.
      */
     public void deactivate() {
         // refresh the object if there are errors when leaving
         if (this.hasErrors()) {
             this.rollback();
         } else {
         	//if dirty prompt the user to save changes
             if (validationModel.isDirty()) {
                 if (MessageUtil.promptYesNo(getMainFrame(), Resources.getString("messages.promptSaveChanges"))) {
                     this.commit();
                 } else {
                 	//if they don't want to save then refresh this object
                 	this.rollback();
                 }
             }
         }
     }
 
     /**
      * Delete the object and its descendants contained by this editor.
      */
     public void delete() {
         // Do nothing by default; subclasses may override.
     }
 
     /**
      * Tries to find a new cover for the disc.
      */
     public void findCover() {
         // Do nothing by default; subclasses may override.
     }
 
     /**
      * Renames any files this editor owns.
      */
     public void renameFiles() {
         // Do nothing by default; subclasses may override.
     }
 
     /**
      * Rollback any changes made to this editor
      */
     public void rollback() {
         // Do nothing by default; subclasses may override.
     	this.lock();
     }
 
     /**
      * Perform the web service search to look for disc info.
      */
     public void webSearch() {
         // Do nothing by default; subclasses may override.
     }
 
     /**
      * Returns a suffix for this editor's title.
      *
      * @return a suffix for this editor's title
      */
     abstract protected String getTitleSuffix();
 
     /**
      * Builds this panel.
      */
     abstract protected void build();
 
     /**
      * Writes the view contents to the underlying model.
      */
     abstract protected void updateModel();
 
     /**
      * Reads the view contents from the underlying model.
      */
     abstract protected void updateView();
 
     /**
      * Gets the MainFrame for the application.
      * <p>
      * @return the MainFrame object
      */
     protected MainFrame getMainFrame() {
         return (MainFrame)Application.getDefaultParentFrame();
     }
 
     /**
      * Gets the MainModule for the application.
      * <p>
      * @return the MainModule object
      */
     protected MainModule getMainModule() {
         return getMainFrame().getMainModule();
     }
 
     /**
      * Gets the settings for the application.
      * <p>
      * @return the Settings object of user defined settings
      */
     protected Settings getSettings() {
         return MainModule.SETTINGS;
     }
 
     /**
      * Gets the validationModel.
      * <p>
      * @return Returns the validationModel.
      */
     protected AbstractValidationModel getValidationModel() {
         return this.validationModel;
     }
 
     /**
      * Sets the cursor to hourglass for true and default for false.  Used for
      * long operations such as saves.
      * <p>
      * @param aBusy true for busy cursor, false for default
      */
     protected void setBusyCursor(boolean aBusy) {
         if (aBusy) {
             getMainFrame().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
         } else {
             getMainFrame().setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
         }
     }
 
     /**
      * Builds the audit information panel which displays the created by, and
      * modified by info of a ORM record.
      * <p>
      * @return the panel to display the audit info
      */
     protected JComponent buildAuditInfoPanel() {
         // create the labels as BOLD
         createdDateLabel = UIFactory.createBoldLabel("");
         createdByLabel = UIFactory.createBoldLabel("");
         modifiedDateLabel = UIFactory.createBoldLabel("");
         modifiedByLabel = UIFactory.createBoldLabel("");
 
         FormLayout layout = new FormLayout("right:max(40dlu;pref), 3dlu, 100dlu, 7dlu, "
                                            + "right:max(40dlu;pref), 3dlu, 100dlu", "p, 3dlu, p, 3dlu, p, 3dlu, p");
         PanelBuilder builder = new PanelBuilder(layout);
         CellConstraints cc = new CellConstraints();
 
         int row = 1;
         builder.addLabel(Resources.getString("label.createdby") + ": ", cc.xy(1, row));
         builder.add(createdByLabel, cc.xy(3, row));
         builder.addLabel(Resources.getString("label.createddate") + ": ", cc.xy(5, row));
         builder.add(createdDateLabel, cc.xy(7, row++));
         row++;
 
         builder.addLabel(Resources.getString("label.modifiedby") + ": ", cc.xy(1, row));
         builder.add(modifiedByLabel, cc.xy(3, row));
         builder.addLabel(Resources.getString("label.modifieddate") + ": ", cc.xy(5, row));
         builder.add(modifiedDateLabel, cc.xy(7, row++));
         row++;
         
         JComponent component = builder.getPanel();
         component.setVisible(this.getSettings().isAuditInfo());
 
         return component;
     }
 
     /**
      * Builds the hint area panel where validation hints are displayed.
      * <p>
      * @return the panel to display the hints
      */
     protected JComponent buildHintAreaPane() {
         hintLabel = new JLabel(ValidationResultViewFactory.getInfoIcon());
         hintArea = new JTextArea(1, 38);
         hintArea.putClientProperty(HINT, HINT);
         hintArea.setEditable(false);
         hintArea.setOpaque(false);
 
         FormLayout layout = new FormLayout("pref, 2dlu, default", "pref");
         PanelBuilder builder = new PanelBuilder(layout);
         CellConstraints cc = new CellConstraints();
         builder.add(hintLabel, cc.xy(1, 1));
         builder.add(hintArea, cc.xy(3, 1));
 
         hintAreaPane = builder.getPanel();
         hintAreaPane.setVisible(false);
         return hintAreaPane;
     }
 
     /**
      * Does this editor pass validation right now. True if so false otherwise.
      * <p>
      * @return true if passes validation
      */
     protected boolean hasErrors() {
         return getValidationModel().getValidationResultModel().getResult().hasErrors();
     }
 
     /**
      * Initializes any event handling.
      */
     protected void initEventHandling() {
         KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(new FocusChangeHandler());
     }
 
 
     /**
      * Displays an input hint for components that get the focus permanently.
      */
     private final class FocusChangeHandler
         implements PropertyChangeListener {
 
         public void propertyChange(PropertyChangeEvent evt) {
             String propertyName = evt.getPropertyName();
             if (!"permanentFocusOwner".equals(propertyName)) {
                 return;
             }
             Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
             String focusHint = (focusOwner instanceof JComponent)
                                ? (String)ValidationComponentUtils.getInputHint((JComponent)focusOwner) : null;
 
             hintArea.setText(focusHint);
             hintAreaPane.setVisible(focusHint != null);
         }
     }
 
 }