package fr.ifremer.quadrige2.ui.swing.common.table;
   
   /*-
    * #%L
    * Quadrige2 Core :: Quadrige2 UI Common
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  
  import com.google.common.base.Preconditions;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Sets;
  import fr.ifremer.quadrige2.ui.swing.common.model.AbstractBeanUIModel;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  import java.util.Set;
  
  /**
   * <p>Abstract AbstractTableUIModel class.</p>
   *
   * @param <B> type of incoming bean to edit
   * @param <R> type of the row of the table model
   * @param <M> type of this model
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public abstract class AbstractTableUIModel<B, R extends AbstractRowUIModel, M extends AbstractTableUIModel<B, R, M>>
          extends AbstractBeanUIModel<B, M> {
  
      private static final long serialVersionUID = 1L;
  
      private static final Log LOG = LogFactory.getLog(AbstractTableUIModel.class);
  
      /** Constant <code>PROPERTY_ROWS="rows"</code> */
      public static final String PROPERTY_ROWS = "rows";
  
      /** Constant <code>PROPERTY_BEANS_LOADED="rowsLoaded"</code> */
      public static final String PROPERTY_BEANS_LOADED = "rowsLoaded";
  
      /** Constant <code>PROPERTY_SINGLE_ROW_SELECTED="singleSelectedRow"</code> */
      public static final String PROPERTY_SINGLE_ROW_SELECTED = "singleSelectedRow";
  
      /** Constant <code>PROPERTY_SELECTED_ROWS="selectedRows"</code> */
      public static final String PROPERTY_SELECTED_ROWS = "selectedRows";
  
      /** Constant <code>PROPERTY_ROWS_IN_ERROR="rowsInError"</code> */
      public static final String PROPERTY_ROWS_IN_ERROR = "rowsInError";
  
      /** Constant <code>PROPERTY_ROWS_ADDED="rowsAdded"</code> */
      public static final String PROPERTY_ROWS_ADDED = "rowsAdded";
  
      /** Constant <code>PROPERTY_ROWS_DELETED="rowsDeleted"</code> */
      public static final String PROPERTY_ROWS_DELETED = "rowsDeleted";
  
      protected List<R> rows;
  
      protected R singleSelectedRow;
  
      protected Set<R> selectedRows;
  
      protected Set<R> rowsInError;
  
      private AbstractTableModel tableModel;
  
      /**
       * <p>Constructor for AbstractTableUIModel.</p>
       */
      protected AbstractTableUIModel() {
          super(null, null);
  
          rows = Lists.newArrayList();
          selectedRows = Sets.newHashSet();
  
          addPropertyChangeListener(PROPERTY_ROWS_IN_ERROR, new PropertyChangeListener() {
  
              @Override
             public void propertyChange(PropertyChangeEvent evt) {
                 if (LOG.isDebugEnabled()) {
                     LOG.debug(PROPERTY_ROWS_IN_ERROR + " changed " + rowsInError.size());
                 }
                 setValid(CollectionUtils.isEmpty(rowsInError));
             }
         });
         setRowsInError(Sets.<R>newHashSet());
     }
 
     /**
      * Get the model itself (useful for validators)
      *
      * @return the model itself
      */
     public AbstractTableUIModel getInstance() {
         return this;
     }
 
     /**
      * Dummy setter (needed for validator using this instance directly)
      *
      * @param model dummy
      */
     public void setInstance(AbstractTableUIModel model) {
 
     }
 
     /**
      * get the underlying table model
      *
      * @return the table model
      */
     public AbstractTableModel getTableModel() {
         return tableModel;
     }
 
     /**
      * set the underlying table model
      *
      * @param tableModel the table model
      */
     public void setTableModel(AbstractTableModel tableModel) {
         this.tableModel = tableModel;
     }
 
     /**
      * {@inheritDoc}
      *
      * this model don't support binders, so no need to return a new bean in implemented classes
      */
     @Override
     protected final B newBean() {
         return null;
     }
 
     /**
      * <p>Getter for the field <code>rows</code>.</p>
      *
      * @return a {@link List} object.
      */
     public List<R> getRows() {
         return rows;
     }
 
     /**
      * <p>Setter for the field <code>rows</code>.</p>
      *
      * @param rows a {@link List} object.
      */
     public void setRows(List<R> rows) {
         if (rows == null) {
             this.rows = Lists.newArrayList();
         } else {
             this.rows = Lists.newArrayList(rows);
         }
         onRowsChanged();
     }
 
     /**
      * <p>addRow.</p>
      *
      * @param row a R object.
      */
     public void addRow(R row) {
         addRows(Collections.singletonList(row));
     }
 
     /**
      * <p>addRows.</p>
      *
      * @param rows a {@link List} object.
      */
     public void addRows(List<R> rows) {
         if (CollectionUtils.isEmpty(rows)) {
             return;
         }
         this.rows.addAll(rows);
         firePropertyChange(PROPERTY_ROWS_ADDED, null, rows);
         onRowsChanged();
     }
 
     /**
      * <p>insertRowAfterSelected.</p>
      *
      * @param row a R object.
      */
     public void insertRowAfterSelected(R row) {
         if (row == null) {
             return;
         }
         if (singleSelectedRow == null || rows.indexOf(singleSelectedRow) + 1 >= rows.size()) {
             addRow(row);
         } else {
             rows.add(rows.indexOf(singleSelectedRow) + 1, row);
             firePropertyChange(PROPERTY_ROWS_ADDED, null, Collections.singletonList(row));
             onRowsChanged();
         }
 
     }
 
     private void onRowsChanged() {
         rowsInError.clear();
         if (CollectionUtils.isNotEmpty(rows)) {
             for (R row : rows) {
                 if (!row.isValid()) {
                     rowsInError.add(row);
                 }
             }
         }
         setRowsInError(rowsInError);
 
         // always propagates (since empty list will not fire and we want it)
         firePropertyChange(PROPERTY_ROWS, null, rows);
 
         populateSelectedRows();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setBean(B bean) {
         setBeans(Collections.singletonList(bean));
     }
 
     /**
      * <p>setBeans.</p>
      *
      * @param beans a {@link Collection} object.
      */
     public void setBeans(Collection<B> beans) {
         setBeans(beans, null);
     }
 
     /**
      * <p>setBeans.</p>
      *
      * @param beans a {@link Collection} object.
      * @param calculated a {@link Boolean} object.
      */
     public void setBeans(Collection<B> beans, Boolean calculated) {
         List<R> newRows = convertBeans(beans, calculated);
         setRows(newRows);
         firePropertyChange(PROPERTY_BEANS_LOADED, null, rows);
     }
 
     /**
      * <p>addBean.</p>
      *
      * @param bean a B object.
      */
     public void addBean(B bean) {
         addBeans(Collections.singletonList(bean));
     }
 
     /**
      * <p>addBean.</p>
      *
      * @param bean a B object.
      * @param calculated a {@link Boolean} object.
      */
     public void addBean(B bean, Boolean calculated) {
         addBeans(Collections.singletonList(bean), calculated);
     }
 
     /**
      * <p>addBeans.</p>
      *
      * @param beans a {@link List} object.
      */
     public void addBeans(List<B> beans) {
         addBeans(beans, null);
     }
 
     /**
      * <p>addBeans.</p>
      *
      * @param beans a {@link List} object.
      * @param calculated a {@link Boolean} object.
      */
     public void addBeans(List<B> beans, Boolean calculated) {
         List<R> newRows = convertBeans(beans, calculated);
         addRows(newRows);
     }
 
     /**
      * <p>addNewRow.</p>
      *
      * @return a R object.
      */
     public R addNewRow() {
         return addNewRow(null);
     }
 
     /**
      * <p>addNewRow.</p>
      *
      * @param bean a B object.
      * @return a R object.
      */
     public R addNewRow(B bean) {
         R row = convertBean(bean, null);
         addRow(row);
         return row;
     }
 
     /**
      * <p>insertNewRowAfterSelected.</p>
      *
      * @return a R object.
      */
     public R insertNewRowAfterSelected() {
         R row = convertBean(null, null);
         insertRowAfterSelected(row);
         return row;
     }
 
     private List<R> convertBeans(Collection<B> beans, Boolean calculated) {
         List<R> newRows = Lists.newArrayList();
         if (CollectionUtils.isNotEmpty(beans)) {
             for (B bean : beans) {
                 R row = convertBean(bean, calculated);
                 if (row != null) {
                     newRows.add(row);
                 }
             }
         }
         return newRows;
     }
 
     @SuppressWarnings("unchecked")
     private R convertBean(B bean, Boolean calculated) {
         R row = null;
         if (getTableModel() != null) {
             row = (R) getTableModel().createNewRow();
         }
         if (row != null) {
             if (bean != null) {
                 row.fromBean(bean);
                 row.setValid(true);
             } else {
                 row.setValid(false);
             }
             if (calculated != null) {
                 row.setCalculated(calculated);
             }
         } else {
             if (LOG.isWarnEnabled()) {
                 LOG.warn("convertBean can't create a new row! check the underlying table model and its createNewRow method");
             }
         }
         return row;
     }
 
     /**
      * <p>getBeans.</p>
      *
      * @return a {@link List} object.
      */
     public List<B> getBeans() {
         List<B> beans = Lists.newArrayList();
         if (CollectionUtils.isNotEmpty(rows)) {
             for (R row : rows) {
                 beans.add(convertRow(row));
             }
         }
         return beans;
     }
 
     @SuppressWarnings("unchecked")
     private B convertRow(R row) {
         return (B) row.toBean();
     }
 
     /**
      * <p>getRowCount.</p>
      *
      * @return a int.
      */
     public int getRowCount() {
         return rows.size();
     }
 
     /**
      * <p>Getter for the field <code>rowsInError</code>.</p>
      *
      * @return a {@link Set} object.
      */
     public Set<R> getRowsInError() {
         return rowsInError;
     }
 
     /**
      * <p>Setter for the field <code>rowsInError</code>.</p>
      *
      * @param rowsInError a {@link Set} object.
      */
     public final void setRowsInError(Set<R> rowsInError) {
         this.rowsInError = rowsInError;
         firePropertyChange(PROPERTY_ROWS_IN_ERROR, null, null);
     }
 
     /**
      * <p>addRowInError.</p>
      *
      * @param row a R object.
      */
     public void addRowInError(R row) {
         rowsInError.add(row);
         firePropertyChange(PROPERTY_ROWS_IN_ERROR, null, null);
     }
 
     /**
      * <p>removeRowInError.</p>
      *
      * @param row a R object.
      */
     public void removeRowInError(R row) {
         rowsInError.remove(row);
         firePropertyChange(PROPERTY_ROWS_IN_ERROR, null, null);
     }
 
     /**
      * <p>hasNoRowInError.</p>
      *
      * @return a boolean.
      */
     public boolean hasNoRowInError() {
         return CollectionUtils.isEmpty(rowsInError);
     }
 
     /**
      * <p>hasAllRowMandatoryValid.</p>
      *
      * @return a boolean.
      */
     public boolean hasAllRowMandatoryValid() {
         for (R row: rows) {
             if (!row.isMandatoryValid()) return false;
         }
         return true;
     }
 
     /**
      * <p>Getter for the field <code>selectedRows</code>.</p>
      *
      * @return a {@link Set} object.
      */
     public Set<R> getSelectedRows() {
         return selectedRows;
     }
 
     /**
      * <p>getSelectedBeans.</p>
      *
      * @return a {@link List} object.
      */
     public List<B> getSelectedBeans() {
         List<B> beans = Lists.newArrayList();
         if (CollectionUtils.isNotEmpty(selectedRows)) {
             for (R row : selectedRows) {
                 beans.add(convertRow(row));
             }
         }
         return beans;
     }
 
     /**
      * <p>populateSelectedRows.</p>
      */
     public void populateSelectedRows() {
         int previousHashCode = selectedRows.hashCode();
         selectedRows = Sets.newHashSet();
         if (CollectionUtils.isNotEmpty(rows)) {
             for (R row : rows) {
                 if (row.isSelected()) {
                     selectedRows.add(row);
                 }
             }
         }
         if (previousHashCode != selectedRows.hashCode()) {
             firePropertyChange(PROPERTY_SELECTED_ROWS, null, selectedRows);
         }
     }
 
     /**
      * <p>deleteRow.</p>
      *
      * @param rowToDelete a R object.
      */
     public void deleteRow(R rowToDelete) {
         deleteRows(Collections.singletonList(rowToDelete));
     }
 
     /**
      * <p>deleteRows.</p>
      *
      * @param rowsToDelete a {@link List} object.
      */
     public void deleteRows(List<R> rowsToDelete) {
         if (CollectionUtils.isNotEmpty(rows) && rowsToDelete != null) {
             Set<R> rowSet = Sets.newHashSet(rowsToDelete);
             rowsInError.removeAll(rowSet);
             firePropertyChange(PROPERTY_ROWS_IN_ERROR, null, null);
             rows.removeAll(rowSet);
             firePropertyChange(PROPERTY_ROWS_DELETED, null, rowSet);
             onRowsChanged();
         }
     }
 
     /**
      * <p>deleteSelectedRows.</p>
      */
     public void deleteSelectedRows() {
         if (CollectionUtils.isNotEmpty(rows)) {
             rowsInError.removeAll(selectedRows);
             firePropertyChange(PROPERTY_ROWS_IN_ERROR, null, null);
             rows.removeAll(selectedRows);
             firePropertyChange(PROPERTY_ROWS_DELETED, null, selectedRows);
             onRowsChanged();
         }
     }
 
     /**
      * <p>updateBean.</p>
      *
      * @param oldRow a R object.
      * @param newRowBean a B object.
      */
     @SuppressWarnings("unchecked")
     public void updateBean(R oldRow, B newRowBean) {
         Preconditions.checkNotNull(oldRow);
         Preconditions.checkState(rows.contains(oldRow));
         Preconditions.checkNotNull(newRowBean);
 
         oldRow.fromBean(newRowBean);
     }
 
     /**
      * <p>Getter for the field <code>singleSelectedRow</code>.</p>
      *
      * @return a R object.
      */
     public R getSingleSelectedRow() {
         return singleSelectedRow;
     }
 
     /**
      * <p>Setter for the field <code>singleSelectedRow</code>.</p>
      *
      * @param singleSelectedRow a R object.
      */
     public void setSingleSelectedRow(R singleSelectedRow) {
         R oldValue = getSingleSelectedRow();
         this.singleSelectedRow = singleSelectedRow;
         firePropertyChange(PROPERTY_SINGLE_ROW_SELECTED, oldValue, singleSelectedRow);
     }
 
 }