package fr.ifremer.quadrige3.ui.swing.table;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 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 fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.ui.swing.model.AbstractBeanUIModel;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import java.util.*;
  import java.util.stream.Collectors;
  
  /**
   * <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";
  
      private List<R> rows;
  
      private R singleSelectedRow;
  
      private Set<R> selectedRows;
  
      private Set<R> rowsInError;
  
      private AbstractTableModel tableModel;
  
      /**
       * <p>Constructor for AbstractTableUIModel.</p>
       */
      protected AbstractTableUIModel() {
          super(null, null);
 
         rows = new ArrayList<>();
         selectedRows = new HashSet<>();
         rowsInError = new HashSet<>();
         setValid(true);
 
         addPropertyChangeListener(PROPERTY_ROWS_IN_ERROR, evt -> {
             if (LOG.isDebugEnabled()) {
                 LOG.debug(PROPERTY_ROWS_IN_ERROR + " changed " + rowsInError.size());
             }
             setValid(hasNoRowInError());
         });
     }
 
     /**
      * 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
      */
     @SuppressWarnings("EmptyMethod")
     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}
      * <p>
      * 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) {
         this.rows = new ArrayList<>();
         if (rows != null) {
             this.rows.addAll(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() {
         setRowsInError(rows.stream().filter(row -> !row.isValid()).collect(Collectors.toSet()));
 
         // 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) {
         setRows(convertBeans(beans, calculated));
         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) {
         addRows(convertBeans(beans, calculated));
     }
 
     /**
      * <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) {
 
         return CollectionUtils.isNotEmpty(beans)
                 ? beans.stream().map(b -> convertBean(b, calculated)).filter(Objects::nonNull).collect(Collectors.toList())
                 : new ArrayList<>();
     }
 
     @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() {
 
         return rows.stream().map(this::convertRow).collect(Collectors.toList());
 
     }
 
     @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 != null ? rowsInError : new HashSet<>();
         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() {
         return rows.stream().allMatch(AbstractRowUIModel::isMandatoryValid);
     }
 
     /**
      * <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() {
         return selectedRows.stream().map(this::convertRow).collect(Collectors.toList());
     }
 
     /**
      * <p>populateSelectedRows.</p>
      */
     public void populateSelectedRows() {
         int previousHashCode = selectedRows.hashCode();
         selectedRows = rows.stream().filter(AbstractRowUIModel::isSelected).collect(Collectors.toSet());
         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>deleteSelectedRows.</p>
      */
     public void deleteSelectedRows() {
         deleteRows(selectedRows);
     }
 
     /**
      * <p>deleteRows.</p>
      *
      * @param rowsToDelete a {@link List} object.
      */
     public void deleteRows(Collection<R> rowsToDelete) {
         if (!rows.isEmpty() && rowsToDelete != null) {
             Set<R> rowSet = rowsToDelete.stream().filter(Objects::nonNull).collect(Collectors.toSet());
             rows.removeAll(rowSet);
             firePropertyChange(PROPERTY_ROWS_DELETED, null, rowSet);
             onRowsChanged();
         }
     }
 
     /**
      * <p>updateBean.</p>
      *
      * @param oldRow     a R object.
      * @param newRowBean a B object.
      */
     @SuppressWarnings("unchecked")
     public void updateBean(R oldRow, B newRowBean) {
         Assert.notNull(oldRow);
         Assert.state(rows.contains(oldRow), "the row to update should exists in actual rows");
         Assert.notNull(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);
     }
 
 }