/*
    * Copyright (c) 2007 Creative Sphere Limited.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *
   *   Creative Sphere - initial API and implementation
   *
   */
  package org.abstracthorizon.aequo.gui;
  
  import java.awt.Adjustable;
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Dimension;
  import java.awt.Point;
  import java.awt.event.AdjustmentEvent;
  import java.awt.event.AdjustmentListener;
  import java.awt.event.FocusEvent;
  import java.awt.event.FocusListener;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.swing.AbstractButton;
  import javax.swing.Action;
  import javax.swing.JComponent;
  import javax.swing.JFrame;
  import javax.swing.JMenu;
  import javax.swing.JMenuBar;
  import javax.swing.JMenuItem;
  import javax.swing.JPanel;
  import javax.swing.JPopupMenu;
  import javax.swing.JScrollBar;
  import javax.swing.JScrollPane;
  import javax.swing.JViewport;
  import javax.swing.KeyStroke;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  import javax.swing.event.ListDataEvent;
  import javax.swing.event.ListDataListener;
  
  import org.abstracthorizon.aequo.CompareEntry;
  import org.abstracthorizon.aequo.CompareModel;
  import org.abstracthorizon.aequo.DefaultCompareModel;
  import org.abstracthorizon.aequo.GlobalContext;
  import org.abstracthorizon.aequo.action.BaseAction;
  import org.abstracthorizon.aequo.text.TextCompareEntry;
  
  /**
   * Abstract compare panel. It is a base for side by side compare panels.
   *  
   * @param <T> type
   * @param <CompareEntryType> compare entry type of type T.
   *
   * @author Daniel Sendula
   */
  public abstract class AbstractComparePanel<T, CompareEntryType extends CompareEntry<T>> extends JPanel {
  
      /** Global context */
      protected GlobalContext context;
      
      /** Left view component */
      protected JComponent leftList;
      
      /** Right view component */
      protected JComponent rightList;
  
      /** Left panel */
      protected JPanel leftPanel;
      
      /** Right panel */
      protected JPanel rightPanel;
      
      /** Bottom left panel */
      protected BottomPanel bottomLeftPanel;
      
      /** Bottom rigth panel */
      protected BottomPanel bottomRightPanel;
      
      /** Left scroll pane */
      protected JScrollPane leftScrollPane;
      
      /** Right scroll pane */
      protected JScrollPane rightScrollPane;
  
      /** Horizontal bar */
      protected JScrollBar horizontalBar;
      
      /** Foreground colours */
      protected Map<Byte, Color> foreGrounds = new HashMap<Byte, Color>();
  
      /** Background colours */
     protected Map<Byte, Color> backGrounds = new HashMap<Byte, Color>();
 
     /** Model */
     protected CompareModel<T, CompareEntryType> compareModel = new DefaultCompareModel<T, CompareEntryType>(2);
 
     /** Cache of actions */
     protected Map<String, BaseAction> actionsCache = new HashMap<String, BaseAction>();
         
     /** Left popup menu */
     protected JPopupMenu leftPopupMenu;
     
     /** Right popup menu */
     protected JPopupMenu rightPopupMenu;
 
     /**
      * Constructor
      * @param context global context
      */
     public AbstractComparePanel(GlobalContext context) {
         this(context, new DefaultCompareModel<T, CompareEntryType>(2));
     }
 
     /**
      * Constructor
      * @param context global context
      * @param compareModel model
      */
     public AbstractComparePanel(GlobalContext context, CompareModel<T, CompareEntryType> compareModel) {
         super(new BorderLayout());
         this.compareModel = compareModel;
         this.context = context;
     }
 
     /**
      * Returns global context
      * @return global context
      */
     public GlobalContext getGlobalContext() {
         return context;
     }
     
     /**
      * Returns left list
      * @return left list
      */
     public Component getLeftList() {
         return leftList;
     }
     
     /**
      * Returns right list
      * @return right list
      */
     public Component getRightList() {
         return rightList;
     }
     
     /**
      * <p>Initialise panel.</p>
      * <p>This method calls following methods in this order</p>
      * <ul>
      *   <li>setUpColors()</li>
      *   <li>createPanels()</li>
      *   <li>createLists()</li>
      *   <li>createScrollPanes()</li>
      * </ul>
      * 
      */
     public void initialise() {
 
         createActions();
 
         setUpColors();
 
         createPanels();
         
         createLists();
         
         createScrollPanes();
         
         // addHorizontalBar();
 
 
     }
     
     /**
      * Returns the model
      * @return the model
      */
     public CompareModel<T, CompareEntryType> getCompareModel() {
         return compareModel;
     }
 
     /**
      * Sets up default colours
      */
     protected void setUpColors() {
         foreGrounds.put(CompareEntry.EMPTY, Color.BLACK);
         backGrounds.put(CompareEntry.EMPTY, Color.LIGHT_GRAY);
 
         foreGrounds.put(CompareEntry.EQUAL, Color.BLACK);
         backGrounds.put(CompareEntry.EQUAL, Color.WHITE);
         
         foreGrounds.put(CompareEntry.LESS, Color.BLACK);
         backGrounds.put(CompareEntry.LESS, new Color(255, 180, 180));
 
         foreGrounds.put(CompareEntry.GREATER, Color.BLACK);
         backGrounds.put(CompareEntry.GREATER, new Color(255, 180, 180));
 
         foreGrounds.put(CompareEntry.DIFFERENT, Color.BLACK);
         backGrounds.put(CompareEntry.DIFFERENT, new Color(255, 180, 180));
 
         foreGrounds.put(TextCompareEntry.SIMILAR, Color.BLACK);
         backGrounds.put(TextCompareEntry.SIMILAR, new Color(255, 208, 208));
 
         foreGrounds.put(TextCompareEntry.CHANGED, Color.BLACK);
         backGrounds.put(TextCompareEntry.CHANGED, new Color(255, 255, 180));
     }
     
     /**
      * Creates panels
      */
     protected void createPanels() {
         leftPanel = new JPanel(new BorderLayout());
         rightPanel = new JPanel(new BorderLayout());
         
         bottomLeftPanel = new BottomPanel();
         bottomRightPanel = new BottomPanel();
         
         bottomLeftPanel.setOtherPanel(bottomRightPanel);
         bottomRightPanel.setOtherPanel(bottomLeftPanel);
         
         leftPanel.add(bottomLeftPanel, BorderLayout.SOUTH);
         rightPanel.add(bottomRightPanel, BorderLayout.SOUTH);
     }
     
     /**
      * Creates lists (views)
      */
     protected void createLists() {
         leftList = createLeftComponent();
         rightList = createRightComponent();
 
         leftPopupMenu = createActionMenu(0);
         rightPopupMenu = createActionMenu(1);
         
         leftList.addFocusListener(new ListFocusListener(0));
         rightList.addFocusListener(new ListFocusListener(1));
     }
     
     /**
      * This method is to create left view component
      * @return left view component
      */
     protected abstract JComponent createLeftComponent();
 
     /**
      * This method is to create right view component
      * @return right view component
      */
     protected abstract JComponent createRightComponent();
     
     /**
      * Creates scroll panes
      */
     protected void createScrollPanes() {
         leftScrollPane = new JScrollPane(leftList);
         rightScrollPane = new JScrollPane(rightList);
         
         leftScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
         rightScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
         leftScrollPane.getViewport().setScrollMode(JViewport.BACKINGSTORE_SCROLL_MODE);
         rightScrollPane.getViewport().setScrollMode(JViewport.BACKINGSTORE_SCROLL_MODE);
         
         
         leftPanel.add(leftScrollPane, BorderLayout.CENTER);
         rightPanel.add(rightScrollPane, BorderLayout.CENTER);
         
         leftScrollPane.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {
             public void adjustmentValueChanged(AdjustmentEvent e) {
                 rightScrollPane.getVerticalScrollBar().setValue(e.getAdjustable().getValue());
             }
         });
         
         rightScrollPane.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {
             public void adjustmentValueChanged(AdjustmentEvent e) {
                 leftScrollPane.getVerticalScrollBar().setValue(e.getAdjustable().getValue());
             }
         });        
     }
     
     /**
      * This method is called to create popup menu
      * @param column column it is invoked for
      * @return popup menu
      */
     protected JPopupMenu createActionMenu(int column) {
         JPopupMenu menu = new JPopupMenu();
         menu.addPropertyChangeListener("visible", new PropertyChangeListener() {
             public void propertyChange(PropertyChangeEvent e) {
                 JPopupMenu menu = (JPopupMenu)e.getSource();
                 updateActions(menu);
             }
             
             public void updateActions(Container container) {
                 for (Component component : container.getComponents()) {
                     if (component instanceof AbstractButton) {
                         AbstractButton abstractButton = (AbstractButton)component;
                         Action a = abstractButton.getAction();
 
                         boolean oldValue = component.isEnabled();
                         boolean newValue = a.isEnabled();
                         if (oldValue != newValue) {
                             component.setEnabled(newValue);
                         }
                     } else if (component instanceof Container) {
                         updateActions((Container)component);
                     }
                 }
             }
             
         });
         return menu;
     }
 
     /**
      * This method is called to populate menu bar
      * @param menuBar menu bar
      */
     public void createMenu(JMenuBar menuBar) {
     }
 
     /**
      * Creates the actions for this component
      */
     protected void createActions() {
     }
 
     /**
      * Searches for a main menu with given name and if one is present it returns it.
      * If not it creates one and returns it.
      *  
      * @param name name of menu
      * @param menuBar menu bar to be searched
      * @return existing or newly created menu
      */
     protected JMenu obtainMenu(String name, Container menuBar) {
         int count = menuBar.getComponentCount();
         for (int i = 0; i < count; i++) {
             Component c = menuBar.getComponent(i);
             if (c instanceof JMenu) {
                 JMenu menu = (JMenu)c;
                 String menuName = menu.getText();
                 if (name.equals(menuName)) {
                     return menu;
                 }
             }
         }
         JMenu menu = new JMenu(name);
         menuBar.add(menu, 1);
         return menu;
     }
     
     /**
      * This method adds horizontal bar that scrolls both panels
      */
     protected void addHorizontalBar() {
         horizontalBar = new JScrollBar(JScrollBar.HORIZONTAL);
 
         horizontalBar.setMinimum(0);
         horizontalBar.setValue(0);
 
         horizontalBar.addAdjustmentListener(new AdjustmentListener() {
             public void adjustmentValueChanged(AdjustmentEvent e) {
                 Adjustable a = e.getAdjustable();
                 JViewport leftViewport = leftScrollPane.getViewport();
                 JViewport rightViewport = rightScrollPane.getViewport();
 
                 Point leftPoint = leftViewport.getViewPosition();
                 Point rightPoint = rightViewport.getViewPosition();
                 
                 leftPoint = new Point(a.getValue(), leftPoint.y);
                 rightPoint = new Point(a.getValue(), rightPoint.y);
                 
                 leftViewport.setViewPosition(leftPoint);
                 rightViewport.setViewPosition(rightPoint);
                 
             }
         });
         
         compareModel.addListDataListener(new ListDataListener() {
 
             public void contentsChanged(ListDataEvent e) {
                 updateScrollBar(horizontalBar, leftScrollPane, rightScrollPane);
             }
 
             public void intervalAdded(ListDataEvent e) {
                 updateScrollBar(horizontalBar, leftScrollPane, rightScrollPane);
             }
 
             public void intervalRemoved(ListDataEvent e) {
                 updateScrollBar(horizontalBar, leftScrollPane, rightScrollPane);
             }
             
         });
 
         bottomRightPanel.add(horizontalBar, BorderLayout.CENTER);        
 
         updateScrollBar(horizontalBar, leftScrollPane, rightScrollPane);
     }
 
     /**
      * Creates an action and then stores it in a local cache
      * @param name action name
      * @return newly created action
      */
     protected BaseAction createCachedAction(String name) {
         BaseAction action = (BaseAction)createAction(name);
         if (action != null) {
             actionsCache.put(name, action);
         } else {
             throw new NullPointerException(name);
         }
         return action;
     }
     
     /**
      * Creates an action and then stores it in a local cache
      * @param name action name
      */
     protected void createCachedColumnActions(String name) {
         BaseAction action = (BaseAction)createAction(name, 0);
         if (action != null) {
             actionsCache.put(name, action);
         } else {
             throw new NullPointerException(name);
         }
     }
     
     /**
      * This is helper method that creates action based on given name
      * @param name actio name
      * @param column column
      * @return newly created action or null if that fails
      */
     protected Action createAction(String name, int column) {
         try {
             Action a = instantiateAction(name);
             updateAction(a, column);
             return a;
         } catch (Exception e) {
             ErrorDialog.showError(null, "Trying to instantiate action for " + name, e);
         }
         return null;
     }
 
     /**
      * This method creates action of given name
      * @param name action name
      * @return action or <code>null</code> if it fails
      */
     protected Action createAction(String name) {
         try {
             Action a = instantiateAction(name);
             updateAction(a);
             return a;
         } catch (Exception e) {
             e.printStackTrace();
             ErrorDialog.showError(null, "Trying to instantiate action for " + name, e);
         }
         return null;
     }
     
     @SuppressWarnings("unchecked")
     /**
      * This method instantiates action
      * @param name action name
      */
     protected Action instantiateAction(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
         Class c = null;
         if (name.indexOf('.') > 0) {
             // TODO Better handing of errors
             try {
                 c = Class.forName(name);
             } catch (Exception ignore) {
             }
         }
         if (c == null) {
             try {
                 String n = getClass().getPackage().getName() + ".action." + name;
                 c = Class.forName(n);
             } catch (Exception ignore) {
             }
         }
         if (c == null) {
             try {
                 String n = "org.abstracthorizon.aequo.action." + name;
                 c = Class.forName(n);
             } catch (Exception ignore) {
             }
         }
         if (c != null) {
             Action a = (Action)c.newInstance();
             return a;
         } else {
             throw new IllegalStateException("Cannot find class " + name);
         }
     }
     
     /**
      * This method updates action with column
      * @param a action
      * @param column column
      */
     protected void updateAction(Action a, int column) {
         updateAction(a);
         if (a instanceof BaseAction) {
             BaseAction baseAction = (BaseAction)a;
             baseAction.setColumn(column);
         }
     }
     
     /**
      * This method updates action with gobal context
      * @param a action
      */
     protected void updateAction(Action a) {
         if (a instanceof BaseAction) {
             BaseAction baseAction = (BaseAction)a;
             baseAction.setGlobalContext(getGlobalContext());
         }
     }
     
     /**
      * Updates menu items with the values of action elements
      * @param menu menu to be updated
      */
     protected void updateMenu(Component[] components) {
         for (Component c : components) {
             if (c instanceof JMenuItem) {
                 JMenuItem item = (JMenuItem)c;
                 if (item.getAction() instanceof BaseAction) {
                     BaseAction action = (BaseAction)item.getAction();
                     item.setEnabled(action.isEnabled());
                     KeyStroke accelerator = (KeyStroke)action.getValue(Action.ACCELERATOR_KEY);
                     item.setAccelerator(accelerator);
                     Integer mnemonic = (Integer)action.getValue(Action.MNEMONIC_KEY);
                     if (mnemonic != null) {
                         int m = mnemonic.intValue();
                         item.setMnemonic((char)m);
                     }
                 }
             }
         }
     }
 
     /**
      * Updates cached actions' column
      * @param column
      */
     protected void updateCachedActionsColumn(int column) {
         for (BaseAction action : actionsCache.values()) {
             action.setColumn(column);
         }
     }
 
     /**
      * Returns enclosing frame
      * @return enclosing frame
      */
     protected JFrame getEnclosingFrame() {
         Component c = this;
         while ((c != null) && !(c instanceof JFrame)) {
             c = c.getParent();
         }
         return (JFrame)c;
     }
     
     /**
      * This method updates scroll bar
      * @param scrollBar scroll bar
      * @param leftScrollPane left scroll pane
      * @param rightScrollPane right scroll pane
      */
     protected static void updateScrollBar(JScrollBar scrollBar, JScrollPane leftScrollPane, JScrollPane rightScrollPane) {
         int max = 0;
         
         int leftWidth = leftScrollPane.getComponent(0).getPreferredSize().width;
         int rightWidth = rightScrollPane.getComponent(0).getPreferredSize().width;
         
         if (leftWidth > max) {
             max = leftWidth;
         }
         if (rightWidth > max) {
             max = rightWidth;
         }
         
         
         if (scrollBar.getValue() > max) {
             scrollBar.setValue(max);
         }
         if (scrollBar.getMaximum() != max) {
             leftWidth = leftScrollPane.getViewport().getWidth();
             rightWidth = rightScrollPane.getViewport().getWidth();
             if (leftWidth < rightWidth) {
                 leftWidth = rightWidth;
             }
             
             scrollBar.setMaximum(max - leftWidth);
         }
     }
 
     /**
      * Bottom panel
      */
     protected static class BottomPanel extends JPanel {
         
         protected BottomPanel other;
         
         public BottomPanel() {
             super(new BorderLayout());
         }
         
         public void setOtherPanel(BottomPanel other) {
             this.other = other;
         }
         
         public BottomPanel getOtherPanel() {
             return other;
         }
         
         protected int getInternalPreferredHeight() {
             return super.getPreferredSize().height;
         }
         
         public Dimension getPreferredSize() {
             Dimension d = super.getPreferredSize();
             int otherHeight = other.getInternalPreferredHeight();
             if (otherHeight > d.height) {
                 d = new Dimension(d.width, otherHeight);
                 super.setPreferredSize(d);
             }
             
             return d;
         }
     }
 
     /**
      * Listener that updates the menu when it is shown
      * 
      * @author Daniel Sendula
      */
     public class MenuChangeListener implements ChangeListener {
 
         public void stateChanged(ChangeEvent e) {
             JMenu menu = (JMenu)e.getSource();
             if (menu.isSelected()) {
                 updateMenu(menu.getMenuComponents());
             }
         }
     }
     
     
     /** 
      * List focus listener. It updates action column.
      * 
      * @author Daniel Sendula
      */
     public class ListFocusListener implements FocusListener {
 
         protected int column;
         
         public ListFocusListener(int column) {
             this.column = column;
         }
 
         public void focusGained(FocusEvent e) {
             if (!e.isTemporary()) {
                 updateCachedActionsColumn(column);
             }
         }
 
         public void focusLost(FocusEvent e) {
             if (!e.isTemporary()) {
                 updateCachedActionsColumn(-1);
             }
         }
     }
 
 }