/*
    * BrowserTableModel.java
    *
    * Created on den 29 januari 2003, 10:25
    */
   
   package net.sourceforge.jsh3modtool.gui.imagetable;
   
   import net.sourceforge.jsh3modtool.gui.imagetable.cache.ImageLoadingListener;
  import net.sourceforge.jsh3modtool.gui.imagetable.cellfilters.*;
  import net.sourceforge.jsh3modtool.gui.imagetable.cellsorters.FilenameCellSorter;
  import net.sourceforge.jsh3modtool.gui.imagetable.cellsorters.FoldersFirstCellSorter;
  import net.sourceforge.jsh3modtool.gui.imagetable.utils.JTableUtil;
  
  import java.util.*;
  import javax.swing.table.*;
  
  /***
   * A model for a JTable oontaining images
   *
   * @author  erma
   */
  public class ImageTableModel extends AbstractTableModel implements ImageLoadingListener
  {
      private List allItems = new ArrayList();
      private int allItemsCount;
  
      private List filteredItems = new ArrayList();
      private int  filteredItemsCount;
  
      private List filters = new ArrayList();
      private Comparator filteredItemsComparator = new FilenameCellSorter();
      private boolean useFoldersFirstWhenSorting;
  
      private int columnCount;
      private int rowCount;
  
      /***
       * Creates a new instance of BrowseTableModel
       * @param cols number of columns
       */
      public ImageTableModel(int cols)
      {
          allItemsCount = 0;
          filteredItemsCount = 0;
          columnCount = cols;
          recalculateRowCount();
          
          //updateFoldersFirstComparator();
      }
  
      /*** Returns the number of columns in the model. A
       * <code>JTable</code> uses this method to determine how many columns it
       * should create and display by default.
       *
       * @return the number of columns in the model
       * @see #getRowCount
       */
      public int getColumnCount()
      {
          return columnCount;
      }
  
      /*** Returns the number of rows in the model. A
       * <code>JTable</code> uses this method to determine how many rows it
       * should display.  This method should be quick, as it
       * is called frequently during rendering.
       *
       * @return the number of rows in the model
       * @see #getColumnCount
       */
      public int getRowCount()
      {
          return rowCount;
      }
  
      /*** Returns the value for the cell at <code>columnIndex</code> and
       * <code>rowIndex</code>.
       * @param row the row whose value is to be queried
       * @param col the column whose value is to be queried
       * @return the value Object at the specified cell
       */
      public Object getValueAt(int row, int col)
      {
          Object value = null;
          if ( filteredItems != null )
          {
              int listIndex = getImageIndex( row, col );
              if ( listIndex < filteredItemsCount )
              {
                  value = filteredItems.get( listIndex );
              }
          }
  
          return value;
      }
  
      /*** Returns the value for the cell at <code>columnIndex</code> and
       * <code>rowIndex</code>.
      * @param cell the cell
      * @return the value Object at the specified cell
      */
     public Object getValueAt(JTableUtil.Cell cell)
     {
         return getValueAt( cell.row, cell.column );
     }
 
     /***
      * Changes the number of columns
      * @param cols the desired number of columns
      */
     public void setColumnCount( int cols )
     {
         if ( columnCount != cols )
         {
             columnCount = cols;
             recalculateRowCount();
             fireTableStructureChanged();
         }
     }
 
     /***
      * Returns a List containing all images that passes the filter.
      * @param filter the Cell filter to filter out images with.
      * @return a List, can be empty
      */
     List getImageCells( CellFilter filter )
     {
         List selectedImages = new Vector();
         ListIterator iterator = filteredItems.listIterator();
         while ( iterator.hasNext() )
         {
             Object cell = iterator.next();
             if ( cell.getClass().equals( ImageCell.class ) )
             {
                 ImageCell image = (ImageCell) cell;
                 if ( filter.accept(image) )
                 {
                     selectedImages.add( image );
                 }
             }
         }
         return selectedImages;
     }
 
     /***
      * Returns a List containing all image cells.
      * @return a List, can be empty.
      */
     List getAllImageCells()
     {
         List selectedImages = new Vector();
         ListIterator iterator = filteredItems.listIterator();
         while ( iterator.hasNext() )
         {
             Object cell = iterator.next();
             if ( cell.getClass().equals( ImageCell.class ) )
             {
                 selectedImages.add( cell );
             }
         }
         return selectedImages;
     }
 
     /***
      * Returns a List containing all images that passes the filter.
      * @param filter the Cell filter to filter out images with.
      * @return a List, can be empty
      */
    /* public List getImageProperties( CellFilter filter )
     {
         List selectedImages = new Vector();
         ListIterator iterator = filteredItems.listIterator();
         while ( iterator.hasNext() )
         {
             Object cell = iterator.next();
             if ( cell.getClass().equals( ImageCell.class ) )
             {
                 ImageCell image = (ImageCell) cell;
                 if ( filter.accept(image) )
                 {
                     selectedImages.add( image.getImageProperties() );
                 }
             }
         }
         return selectedImages;
     }*/
 
     /***
      * Return a List containing all selected image cells.
      * @return a List
      */
    /*public List getSelectedImageProperties()
     {
         return getImageProperties( new SelectedImagesFilter(true) );
     }*/
 
     /***
      * Returns if the specified Cell should be included in the filtered list
      * or not
      * @param cell the cell to test
      * @return true if and only if the cell is accepted by all filters
      */
     private boolean acceptedByFilters( BaseCell cell )
     {
         boolean passedFilters = true;
         ListIterator iterator = filters.listIterator();
         while ( (passedFilters) && ( iterator.hasNext() ) )
         {
             CellFilter filter = (CellFilter) iterator.next();
             if ( ! filter.accept( cell ) )
             {
                 passedFilters = false;
             }
         }
         return passedFilters;
     }
 
 
     /***
 	 * @param nrOfImagesBefore
 	 * @param startRow
 	 */
 	private void revalidateData(int nrOfImagesBefore, int startRow) {
 		recalculateRowCount();        
         sortFilteredItems();       
         int endRow = rowCount;
 
         if ( nrOfImagesBefore == 0 )
         {
             fireTableDataChanged();
         } 
         else
         {
             if ( startRow == endRow )
             {
                 fireTableRowsUpdated( endRow - 1, endRow );
             } 
             else
             {
                 fireTableRowsInserted( startRow - 1, endRow );
             }
         }
 	}
 	
     public void addImageModel(ImageModel imageModel)
     {
         int nrOfImagesBefore = allItemsCount;
         int startRow = rowCount;
         
         BaseCell cell = new ImageCell(imageModel);
         allItems.add( cell );
         allItemsCount++;
 
         if ( acceptedByFilters( cell ) )
         {
             filteredItemsCount++;
             filteredItems.add( cell );
         }
         revalidateData(nrOfImagesBefore, startRow);
     	
     }
 
     /*** Adds the specified images to the model
      * @param filesList a list of Files
      */
     public void addImageModels( List filesList )
     {
         int nrOfImagesBefore = allItemsCount;
         int startRow = rowCount;
         ListIterator iterator = filesList.listIterator();
 
         while ( iterator.hasNext() )
         {
             BaseCell cell = new ImageCell((ImageModel) iterator.next());
             if ( cell != null )
             {
                 allItems.add( cell );
                 allItemsCount++;
 
                 if ( acceptedByFilters( cell ) )
                 {
                     filteredItemsCount++;
                     filteredItems.add( cell );
                 }
             }
         }
         revalidateData(nrOfImagesBefore, startRow);
     }
 
     /*** Removes the Files in the specified list from the table
      * @param filesList a List of Files
      */
     /*public void removeFiles( List filesList )
     {
         int startRow = rowCount;
         ListIterator iterator = filesList.listIterator();
         while ( iterator.hasNext() )
         {
             BaseCell cell = findFile( (File) iterator.next() );
             if ( cell != null )
             {
                 allItems.remove( cell );
                 allItemsCount--;
                 if ( filteredItems.remove( cell ) )
                 {
                     filteredItemsCount--;
                 }
             }
         }
         recalculateRowCount();
         sortFilteredItems();
         int endRow = rowCount;
         fireTableRowsDeleted( startRow, endRow );
     }*/
     
     /***
      * Returns the cell that is the representation of the specified file
      * @param file the file to find a cell for
      * @return the cell; null if the cell wasnt found
      */
    /* private BaseCell findFile( File file )
     {
         BaseCell foundCell = null;
         ListIterator iterator = allItems.listIterator();
         while ( ( iterator.hasNext() ) && ( foundCell == null ) )
         {
             BaseCell cell = (BaseCell) iterator.next();
             
             if ( cell instanceof ImageCell )
             {
                 if ( ((ImageCell) cell).getImageProperties().getFilename().equals( file.getAbsolutePath() ) )
                 {
                     foundCell = cell;
                 }
             }
         }
         return foundCell;
     }*/
 
 
 	/*** Returns if the model contains the specified cell
      * @param cell the cell to find in the model
      * @return true if the cell is in the model; false otherwise
      */
     public boolean contains( BaseCell cell )
     {
         boolean retValue = false;
         if ( cell != null )
         {
             retValue = allItems.contains( cell );
         }
         return retValue;
     }
 
     /***
      * Generates an Cell for the table
      * @param file the file
      * @return an AbstractCell
      */
    /* private BaseCell generateCell( File file )
     {
         BaseCell cell;
         if ( file.isDirectory() )
         {
             cell = new FolderCell( file );
         }
         else
         {
             ImageModel imageProps = new ImageProperties( file );
             cell = new ImageCell( imageProps );
 
         }
         return cell;
     }*/
 
     /*** Removes all items from the model */
     public void clear()
     {
         allItems.clear();
         filteredItems.clear();
         allItemsCount = 0;
         filteredItemsCount = 0;
         recalculateRowCount();
         fireTableDataChanged();
     }
 
     /***
      * Recalculates the number of rows.
      */
     private void recalculateRowCount()
     {
         rowCount = (int) Math.floor( (double) filteredItemsCount / (double) columnCount );
         rowCount += ( (filteredItemsCount % columnCount) == 0 ? 0 : 1 );
     }
 
     /***
      * Invoked when an image has been loaded, specified by the index in the list
      * This method fires a cell update event.
      * @param cell the cell that was updated.
      */
     public void imageIsLoaded(BaseCell cell)
     {
         int cellIndex = filteredItems.indexOf( cell );
         if ( cellIndex != -1 )
         {
             int row = (int) Math.floor( (double) cellIndex / (double) columnCount );
             int col = cellIndex - ( row * columnCount );
 
             fireTableCellUpdated( row, col );
         }
         if ( cell.getClass().equals(ImageCell.class))
         {
             ((ImageCell)cell).resetTooltip();
         }
     }
 
     /*** Returns the number of images in the model
      * @return number of items in table
      */
     public int getSize()
     {
         return filteredItemsCount;
     }
 
     /***
      * Returns the image index (in the list) from the cells row and column.
      * @param row the row.
      * @param col the col.
      * @return the image index (in the list). 
      */
     int getImageIndex( int row, int col )
     {
         return row * columnCount + col;
     }
     
     /***
      * Returns the image index (in the list) for the specified cell.
      * @param cell the cell to find the index for.
      * @return the image index (in the list). 
      */
     int getImageIndex( BaseCell cell )
     {
         int index = -1;
         JTableUtil.Cell tableCell = getTableCell(cell);
         if ( tableCell != null )
         {
             index = getImageIndex(tableCell.row, tableCell.column);
         }
         return index;
     }
     
     /***
      * Returns the AbstractCell at the specified index (in the list).
      * @param index the index to find the cell for.
      * @return an AbstractCell.
      */
     BaseCell getCell( int index )
     {
         return (BaseCell) filteredItems.get(index);
     }
 
 
     /*** 
      * Returns whetever this cell is editable or not, this
      * implementation returns false always.
      * @param rowIndex the row
      * @param columnIndex the column
      * @return false.
      */
     public boolean isCellEditable(int rowIndex, int columnIndex)
     {
         return false;
     }
 
     /*** 
      * Fires a cell update. The method checks if the cell is acceptable by the filters, if
      * not it is removed from the filteredList.
      * @param cell the cell to update.
      */
     public void fireTableCellUpdate( BaseCell cell )
     {
         JTableUtil.Cell tableCell = getTableCell( cell );
 
         if ( tableCell != null )
         {    
             if ( ! acceptedByFilters( cell ))
             {
                 filteredItems.remove(cell);
                 filteredItemsCount = filteredItems.size();
                 fireTableRowsDeleted(tableCell.row, tableCell.row );                   
             }
             else
             {        
                 fireTableCellUpdated( tableCell.row, tableCell.column );
             }
         }
     }
 
     /*** Returns a JTableUtil.Cell from the specified list index
      * @param cell the cell to find in the table
      * @return a Cell containing the row and column of the cell
      */
     public JTableUtil.Cell getTableCell( BaseCell cell )
     {
         JTableUtil.Cell tableCell = null;
 
         int cellIndex = filteredItems.indexOf( cell );
         if ( cellIndex != -1 )
         {
             tableCell = getTableCell( cellIndex );
         }
         return tableCell;
     }
     
     /*** 
      * Returns a JTableUtil.Cell that matches the specified file
      * @param file the file to find in the filteres image cells
      * @return a Cell containing the row and column of the cell
      */
    /* public JTableUtil.Cell getTableCell( File file )
     {
         JTableUtil.Cell tableCell = null;
         
         int cellIndex = 0;
         ListIterator iterator = filteredItems.listIterator();
         while ( iterator.hasNext() && ( tableCell == null ) )
         {
             Object obj = iterator.next();
             if ( ( obj instanceof ImageCell ) && 
                  ( ((ImageCell)obj).getImageProperties().getFilename().equals( file.getAbsolutePath() ) ) 
                )
             {  
                 tableCell = getTableCell( cellIndex );
             }
             cellIndex++;
         }
         return tableCell;
     }*/
     
 
     /***
      * Adds the filter to the filters list, the filter is used until it is
      * removed from this list.
      * @param filter the filter to add
      */
     public void addFilter( CellFilter filter )
     {
         filters.add( filter );
         updateFilteredList();
     }
 
     /***
      * Removes the filter from the filters list
      * @param filter the filter to remove
      */
     public void removeFilter( CellFilter filter )
     {
         filters.remove( filter );
         updateFilteredList();
     }
 
     /***
      * Removes all filters from the list
      */
     public void removeAllFilters()
     {
         filters.clear();
         updateFilteredList();
     }
 
     /***
      * Reinits the filtere items list, it copies values from the main item list
      * to the filtered items list if it passes all filters.
      */
     private void updateFilteredList()
     {
         filteredItemsCount = 0;
         filteredItems.clear();
 
         ListIterator itemIterator = allItems.listIterator();
         while ( itemIterator.hasNext() )
         {
             BaseCell cell = (BaseCell) itemIterator.next();
             if ( acceptedByFilters( cell ) )
             {
                 filteredItems.add( cell );
             }
         }
         filteredItemsCount = filteredItems.size();
         sortFilteredItems();
         recalculateRowCount();
         fireTableDataChanged();
     }
     
     /***
      * Returns a cell for the specified list index
      * @param cellIndex the cell index.
      * @return the cell.
      */
     JTableUtil.Cell getTableCell( int cellIndex )
     {
         int row = (int) Math.floor( (double) cellIndex / (double) columnCount );
         int col = cellIndex - ( row * columnCount );
 
         return new JTableUtil.Cell( row, col );
     }
     
     /***
      * Sorts the filtereditems list. Note that it only sorts the list that is displayed
      * and not the underlying.
      */
     private void sortFilteredItems()
     {
         Comparator c = filteredItemsComparator;
         if (c != null)
         {
 	        if ( useFoldersFirstWhenSorting )
 	        {
 	            c = new FoldersFirstCellSorter(c);
 	        }
 	        Collections.sort(filteredItems, c);
         }
     }
     
     /***
      * Sets the new cell comparator.
      * The comparator will be activated with Cells that extends
      * the AbstractCell class. All comparators sent to this method must
      * be able to sort the different cells.
      * @param comparator
      * @see AbstractCellSorter
      */
     public void setCellComparator( Comparator comparator )
     {
         filteredItemsComparator = comparator;
     }
 }