/*
    * 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.file.action;
  
  import java.awt.Component;
  import java.awt.Dimension;
  import java.io.File;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.swing.AbstractListModel;
  import javax.swing.Box;
  import javax.swing.BoxLayout;
  import javax.swing.Icon;
  import javax.swing.JLabel;
  import javax.swing.JList;
  import javax.swing.JOptionPane;
  import javax.swing.JScrollPane;
  import javax.swing.ListSelectionModel;
  import javax.swing.border.EmptyBorder;
  
  import org.abstracthorizon.aequo.action.BaseAction;
  import org.abstracthorizon.aequo.file.FileCompareEntry;
  import org.abstracthorizon.aequo.file.FilesModel;
  
  /**
   * Base action for operations on file model
   *
   * @author Daniel Sendula
   */
  public abstract class FileBaseAction extends BaseAction {
      
      /** File model */
      protected FilesModel filesModel;
      
      /** Preselected entries. Entries are going to be collected for dialog and stored here to avoid repeating the operation */
      protected FileCompareEntry[] preselectedEntries;
      
      /**
       * Constructor
       */
      public FileBaseAction() {
      }
  
      /**
       * Sets file model
       * @param model file model
       */
      public void setFilesModel(FilesModel model) {
          this.filesModel = model;
      }
      
      /**
       * Returns file model
       * @return file model
       */
      public FilesModel getFilesModel() {
          return filesModel;
      }
      
      /**
       * Returns if exactly one row is selected
       * @return <code>true</code> if exactly one row is selected
       */
      public boolean isOneSelected() {
          ListSelectionModel selModel = getFilesModel().getSelectionModel();
          int min = selModel.getMinSelectionIndex();
          int max = selModel.getMaxSelectionIndex();
          return ((min >= 0) && (min == max));
      }
  
      /**
       * Returns if selection is valid
       * @return <code>true</code> if selection is valid
       */
      public boolean isSelectionValid() {
          ListSelectionModel selModel = getFilesModel().getSelectionModel();
          int min = selModel.getMinSelectionIndex();
          int max = selModel.getMaxSelectionIndex();
          return ((min >= 0) && (min <= max));
      }
      
      /**
       * Helper method that collects all selected entries
       * @param model model
       * @return array of all selected entries
       */
      protected static FileCompareEntry[] collectSelectedEntries(FilesModel model) {
          ArrayList<FileCompareEntry> entries = new ArrayList<FileCompareEntry>();
         ListSelectionModel selModel = model.getSelectionModel();
         int min = selModel.getMinSelectionIndex();
         int max = selModel.getMaxSelectionIndex();
         int i = min;
         int level = 0;
         while (i <= max) {
             if (selModel.isSelectedIndex(i)) {
                 FileCompareEntry entry = model.get(i);
                 if (level >= entry.getLevel()) {
                     FileCompareEntry previousEntry = model.get(i - 1);
                     collectRecursively(previousEntry, entries);
                 }
                 entries.add(entry);
                 level = entry.getLevel();
             }
             i++;
         }
         collectRecursively(entries.get(entries.size() - 1), entries);
 
         FileCompareEntry[] res = new FileCompareEntry[entries.size()];
         return entries.toArray(res);
     }
 
     /**
      * Collects entries recursively
      * @param entry starting entry
      * @param list list to collect entries to
      */
     protected static void collectRecursively(FileCompareEntry entry, List<FileCompareEntry> list) {
         if (entry.hasChildren()) {
             for (FileCompareEntry e : entry.getChildren()) {
                 list.add(e);
                 collectRecursively(e, list);
             }
         }
     }
 
     /**
      * This method shows confirmation dialog
      * @return result as in {@link JOptionPane#showConfirmDialog(java.awt.Component, Object)}
      */
     protected int showConfirmDialog() {
         int res = super.showConfirmDialog();
         if (res != JOptionPane.OK_OPTION) {
             preselectedEntries = null;
         }
         return res;
     }
     
     /**
      * Creates a panel with message and a list of files operation to be performed on.
      * @return created panel
      */
     public Object updateMessage() {
         preselectedEntries = collectSelectedEntries(getFilesModel());
         
         Box box = new Box(BoxLayout.Y_AXIS);
         Component comp = null;
         if (message instanceof String) {
             JLabel l = new JLabel((String)message);
             l.setBorder(new EmptyBorder(0, 0, 10, 0));
             l.setAlignmentX(Component.LEFT_ALIGNMENT);
             comp = l;
         } else if (message instanceof Icon) {
             JLabel l = new JLabel((Icon)message);
             l.setAlignmentX(Component.LEFT_ALIGNMENT);
             l.setBorder(new EmptyBorder(0, 0, 10, 0));
             comp = l;
         } else if (message instanceof Component) {
             comp = (Component)message;
         }
         if (comp != null) {
             box.add(comp);
         }
         
         int c = column;
         if (c < 0) {
             c = 0;
         }
         final int len = getFilesModel().getData(c).getAbsolutePath().length();
         
         JList list = new JList(new AbstractListModel() {
             
             public Object getElementAt(int index) {
                 int c = column;
                 if (c < 0) {
                     c = 0;
                 }
                 File f = preselectedEntries[index].getData(c);
                 String name = f.getAbsolutePath();
                 if (name.length() > len) {
                     name = name.substring(len);
                 } else {
                     name = "/";
                 }
                 return name;
             }
 
             public int getSize() {
                 return preselectedEntries.length;
             }
             
         });
         list.setVisibleRowCount(5);
         JScrollPane sp = new JScrollPane(list);
         sp.setAlignmentX(Component.LEFT_ALIGNMENT);
         box.add(sp);
         Dimension d = box.getPreferredSize();
         if (d.width >  450) {
             box.setPreferredSize(new Dimension(450, d.height));
         }
         
         return box;
     }
     
     /**
      * It returns preselected entries if they exist. If not it just returns
      * result of {@link #collectSelectedEntries(FilesModel)}.
      * If preselected entries did exist it removes them.
      * 
      * @return preselected entries
      */
     protected FileCompareEntry[] getPreselectedEntries() {
         if (preselectedEntries != null) {
             FileCompareEntry[] res = preselectedEntries;
             preselectedEntries = null;
             return res;
         }
         return collectSelectedEntries(getFilesModel());
     }
 }