/*
    * 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;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  import javax.swing.DefaultListSelectionModel;
  import javax.swing.ListSelectionModel;
  import javax.swing.event.ListDataEvent;
  import javax.swing.event.ListDataListener;
  
  /**
   * Implementation of {@link CompareModel}.
   * 
   * @param <T> type
   * @param <CompareEntryType> compare entry type of T.
   *
   * @author Daniel Sendula
   *
   */
  public class DefaultCompareModel<T, CompareEntryType extends CompareEntry<T>> implements CompareModel<T, CompareEntryType> {
  
      /** List of entries */
      protected List<CompareEntryType> entries;
      
      /** List of data listeners */
      protected ArrayList<ListDataListener> listeners = new ArrayList<ListDataListener>();
  
      /** Default list selection model */
      protected DefaultListSelectionModel selectionModel = new DefaultListSelectionModel();
      
      /** Model's width - number of columns to compare */
      protected int width;
      
      /**
       * Constructor
       * 
       * @param width model's width - number of columns to compare
       */
      public DefaultCompareModel(int width) {
          this.width = width;
          entries = new ArrayList<CompareEntryType>();
      }
      
      /**
       * Constructor
       * 
       * @param entries initial list of entries
       */
      public DefaultCompareModel(List<CompareEntryType> entries) {
          this.entries = entries;
          if (entries.size() == 0) {
              throw new IllegalArgumentException("Supplied list must not be empty");
          }
          width = entries.get(0).getData().length;
          ensureWidth(entries);
      }
      
      /**
       * Returns width - number of columns
       * @return width of the model
       */
      public int getWidth() {
          return width;
      }
      
      /**
       * Method that ensures that each entry has same length of data
       * @param entry entry
       * @throws IllegalArgumentException if length is not the same as model's
       */
      protected void ensureWidth(CompareEntryType entry) throws IllegalArgumentException {
          if (entry.getData().length != width) {
              throw new IllegalArgumentException("Not all elements are of the required width; width=" + width);
          }
      }
      
      /**
       * Method that ensures that each entry from the given collection has same length of data
       * @param entries collection of entries
       * @throws IllegalArgumentException if length is not the same as model's
       */
      protected void ensureWidth(Collection<? extends CompareEntryType> entries) throws IllegalArgumentException {
          for (CompareEntryType entry : entries) {
              if (entry.getData().length != width) {
                  throw new IllegalArgumentException("Not all elements are of the required width; width=" + width);
              }
         }
     }
     
     /**
      * Returns default selection model
      * @return selection model
      */
     public ListSelectionModel getSelectionModel() {
         return selectionModel;
     }
     
     /**
      * This method exposes internal entries list to clients. Be careful as changes to this
      * list won't be propagated to listeners
      * @return internal list of entries
      */
     public List<CompareEntryType> getAllEntries() {
         return entries;
     }
     
     /**
      * Notifies data listeners of change
      * @param listeners listeners to be notified
      * @param event change
      */
     protected static void notifyListeners(Collection<ListDataListener> listeners, ListDataEvent event) {
         if (event.getType() == ListDataEvent.CONTENTS_CHANGED) {
             for (ListDataListener listener : listeners) {
                 listener.contentsChanged(event);
             }
         } else if (event.getType() == ListDataEvent.INTERVAL_ADDED) {
             for (ListDataListener listener : listeners) {
                 listener.intervalAdded(event);
             }
         } else {
             for (ListDataListener listener : listeners) {
                 listener.intervalRemoved(event);
             }
         }
     }
     
     /**
      * Fires change event
      * @param from starting index of change
      * @param to ending index of change
      */
     protected void fireConentChangedEvent(int from, int to) {
         ListDataEvent event = new ListDataEvent(DefaultCompareModel.this, ListDataEvent.CONTENTS_CHANGED, from, to);
         notifyListeners(listeners, event);
     }
 
     /**
      * Notifies listeners of entries added
      * @param from starting index of change
      * @param to ending index of change
      */
     protected void fireIntervalAddedEvent(int from, int to) {
         ListDataEvent event = new ListDataEvent(DefaultCompareModel.this, ListDataEvent.INTERVAL_ADDED, from, to);
         notifyListeners(listeners, event);
     }
 
     /**
      * Notifies listeners of entries removed
      * @param from starting index of change
      * @param to ending index of change
      */
     protected void fireIntervalRemovedEvent(int from, int to) {
         ListDataEvent event = new ListDataEvent(DefaultCompareModel.this, ListDataEvent.INTERVAL_REMOVED, from, to);
         notifyListeners(listeners, event);
     }
 
     /**
      * Callback method where clients notify listeners of updated entries of the model
      * @param from starting index of change
      * @param to ending index of change
      */
     public void notifyUpdate(int from, int to) {
         ListDataEvent event = new ListDataEvent(this, ListDataEvent.CONTENTS_CHANGED, from, to);
         notifyListeners(listeners, event);
     }
     
     /**
      * Adds data listener
      * @param l listener
      */
     public void addListDataListener(ListDataListener l) {
         listeners.add(l);
     }
 
     /**
      * Removes data listener
      * @param l listener
      */
     public void removeListDataListener(ListDataListener l) {
         listeners.remove(l);
     }
 
     /**
      * Returns model's column as list of data
      * @param column column
      * @return list of data from given column
      */
     public List<T> getAsList(int column) {
         ArrayList<T> res = new ArrayList<T>();
         for (CompareEntryType entry : entries) {
             T o = entry.getData()[column];
             if (o != null) {
                 res.add(o);
             }
         }
         return res;
     }
     
 
     /**
      * Returns model's column as list of data
      * @param column column
      * @param start start index
      * @param end end index
      * @return list of data from given column
      */
     public List<T> getAsSubList(int column, int start, int end) {
         ArrayList<T> res = new ArrayList<T>();
         for (int i = start; i <= end; i++) {
             CompareEntryType entry = get(i);
             T o = entry.getData()[column];
             if (o != null) {
                 res.add(o);
             }
         }
         return res;
     }
     
     /**
      * Adds new entry to the internal list
      * @param index index to be added to
      * @param entry entry
      */
     public void addImpl(int index, CompareEntryType entry) {
         entries.add(index, entry);
     }
     
     /**
      * Adds new entry to the internal list
      * @param entry entry
      * @return <code>true</code> if entry is really added
      */
     public boolean addImpl(CompareEntryType entry) {
         return entries.add(entry);
     }
     
     /**
      * Removes entry from the internal list
      * @param index index
      * @return old entry
      */
     public CompareEntryType removeImpl(int index) {
         return entries.remove(index);
     }
     
     /* List implementations */
 
     /**
      * Adds new entry to the model
      * @param entry entry 
      * @return <code>true</code> model changed
      */
     public boolean add(CompareEntryType entry) {
         ensureWidth(entry);
         int i = entries.size();
         boolean res = addImpl(entry);
         if (res) {
             fireIntervalAddedEvent(i, i);
         }
         return res;
     }
 
     /**
      * Returns entry at given index
      * @return entry at given index
      */
     public CompareEntryType get(int index) {
         return entries.get(index);
     }
 
     /**
      * Removes entry at given index
      * @param index index
      * @return entry at given index
      */
     public CompareEntryType remove(int index) {
         CompareEntryType res = removeImpl(index);
         fireIntervalRemovedEvent(index, index);
         return res;
     }
 
     /* ListModel implementations */
     
     /**
      * Returns entry at given index
      * @param index index
      * @return entry at given index
      */
     public Object getElementAt(int index) {
         return get(index);
     }
     
     /**
      * Returns number of entries
      * @return number of entries
      */
     public int getSize() {
         return entries.size();
     }
 
 }