package fr.ifremer.quadrige3.ui.swing.table.state;
   
   /*-
    * #%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.table.*;
  import fr.ifremer.quadrige3.ui.swing.table.action.AdditionalTableActions;
  import jaxx.runtime.swing.session.State;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.jdesktop.swingx.action.AbstractActionExt;
  import org.jdesktop.swingx.table.TableColumnExt;
  
  import javax.swing.Action;
  import javax.swing.RowSorter;
  import javax.swing.SortOrder;
  import javax.swing.SwingUtilities;
  import javax.swing.table.AbstractTableModel;
  import java.util.*;
  
  /**
   * State used for a SwingTable with a AbstractTableModel
   * <p/>
   * Created by Ludovic on 05/05/2015.
   */
  public class SwingTableSessionState implements ExtendedState {
  
      private static final Log LOG = LogFactory.getLog(SwingTableSessionState.class);
  
      protected static final String SEPARATOR = "|";
  
      // session states map by context
      private Map<String, SwingTableState> sessionStates;
  
      // selected additional actions
      private Set<String> selectedActions;
  
      /**
       * <p>Constructor for SwingTableSessionState.</p>
       */
      public SwingTableSessionState() {
          sessionStates = new HashMap<>();
          selectedActions = new HashSet<>();
      }
  
      /**
       * <p>checkComponent.</p>
       *
       * @param object a {@link Object} object.
       * @return a {@link SwingTable} object.
       */
      protected SwingTable checkComponent(Object object) {
          Assert.notNull(object);
          Assert.isInstanceOf(SwingTable.class, object);
          Assert.isInstanceOf(AbstractTableModel.class, ((SwingTable) object).getModel());
          return (SwingTable) object;
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public State getState(Object o) {
  
          return getState(o, null, null);
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      @SuppressWarnings("unchecked")
      public State getState(Object o, State previousState, String stateContextToSave) {
  
          SwingTable table = checkComponent(o);
  
  
         // Retrieve table model and its state context
         String stateContext = stateContextToSave != null ? stateContextToSave : table.getTableModel().getStateContext();
 
         // Reuse previous state or create new one
         SwingTableSessionState tableSessionState;
         if (previousState instanceof SwingTableSessionState) {
             tableSessionState = (SwingTableSessionState) previousState;
         } else {
             tableSessionState = new SwingTableSessionState();
         }
         try {
             // Get or create the table state for the context
             SwingTableState tableState = tableSessionState.getSessionStates().computeIfAbsent(stateContext, k -> new SwingTableState());
 
             // get tableModel.getIdentifiers() in a new list to prevent ConcurrentModificationException
             List<ColumnIdentifier> identifiers = new ArrayList<>(table.getTableModel().getIdentifiers());
             // Retrieve sort keys
             Map<Integer, Integer> sortOrderPriority = new HashMap<>();
             if (table.getRowSorter() != null && table.getRowSorter().getSortKeys() != null) {
                 for (int priority = 0; priority < table.getRowSorter().getSortKeys().size(); priority++) {
                     RowSorter.SortKey sortKey = table.getRowSorter().getSortKeys().get(priority);
                     sortOrderPriority.put(sortKey.getColumn(), priority);
                 }
             }
 
             // Iterate over identifiers
             for (ColumnIdentifier identifier : identifiers) {
                 TableColumnExt column = table.getColumnExt(identifier);
                 if (column == null || column instanceof FixedColumn) {
                     // ignore fixed column
                     continue;
                 }
 
                 int columnViewIndex = table.convertColumnIndexToView(column.getModelIndex());
                 boolean isPmfmColumn = identifier instanceof PmfmColumnIdentifier;
                 boolean isHidden = column instanceof HiddenColumn;
 
                 // shift column view index if table model has checkTableColumn
 //            if (table.getColumnModel().hasCheckTableColumn() && columnViewIndex > 0) {
 //                columnViewIndex--;
 //            }
 
                 // set the visibility and width property
                 if (isPmfmColumn) {
                     // pmfm column
                     if (isHidden) {
                         tableState.getPmfmVisibility().remove(((PmfmColumnIdentifier) identifier).getPmfmId());
                         tableState.getPmfmWidth().remove(((PmfmColumnIdentifier) identifier).getPmfmId());
                     } else {
                         tableState.getPmfmVisibility().put(((PmfmColumnIdentifier) identifier).getPmfmId(), columnViewIndex);
                         tableState.getPmfmWidth().put(((PmfmColumnIdentifier) identifier).getPmfmId(), column.getPreferredWidth());
                     }
 
                 } else {
                     // normal column
                     if (isHidden) {
                         tableState.getVisibility().remove(identifier.getPropertyName());
                         tableState.getWidth().remove(identifier.getPropertyName());
                     } else {
                         tableState.getVisibility().put(identifier.getPropertyName(), columnViewIndex);
                         tableState.getWidth().put(identifier.getPropertyName(), column.getPreferredWidth());
                     }
                 }
 
                 // set the sortOrder property
                 // test if the table has a rowSorter to prevent NullPointerException in table.getSortOrder(identifier) (see Mantis#29603)
                 if (table.getRowSorter() != null) {
                     SortOrder sortOrder = table.getSortOrder(identifier);
                     if (sortOrder != SortOrder.UNSORTED) {
                         String propertyName = identifier.getPropertyName() + (isPmfmColumn ? SEPARATOR + ((PmfmColumnIdentifier) identifier).getPmfmId() : "");
                         String order = sortOrder.name() + SEPARATOR + sortOrderPriority.get(column.getModelIndex());
                         tableState.getSortOrder().put(propertyName, order);
                     }
                 }
             }
 
             // get additional actions
             tableSessionState.getSelectedActions().clear();
             AdditionalTableActions additionalTableActions = getAdditionalTableActions(table);
             if (additionalTableActions != null) {
                 additionalTableActions.getActions().stream()
                     // Read the selected property (a boolean) from an AbstractActionExt with state action is enabled
                     .filter(action -> (action instanceof AbstractActionExt) && ((AbstractActionExt) action).isStateAction() && ((AbstractActionExt) action).isSelected())
                     .forEach(action -> tableSessionState.getSelectedActions().add(action.getClass().getName()));
             }
 
         } catch (Exception e) {
             LOG.error("Something goes wrong on getState", e);
         }
         return tableSessionState;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings("unchecked")
     public void setState(Object o, State state) {
         if (state == null) {
             return;
         }
         if (!(state instanceof SwingTableSessionState)) {
             throw new IllegalArgumentException("invalid state");
         }
         SwingTable table = checkComponent(o);
 
         // Retrieve table model
         SwingTableSessionState tableSessionState = (SwingTableSessionState) state;
         SwingTableState tableState = tableSessionState.getSessionStates().get(table.getTableModel().getStateContext());
         if (tableState == null) {
             // Ignore if no session state for this context
             return;
         }
 
         try {
             // get tableModel.getIdentifiers() in a new list to prevent ConcurrentModificationException
             List<ColumnIdentifier> identifiers = new ArrayList<>(table.getTableModel().getIdentifiers());
             Map<Integer, SortOrder> sortOrderByModelIndex = new HashMap<>();
             Map<Integer, Integer> sortPriority = new HashMap<>();
             Map<Integer, Integer> deferredMove = new HashMap<>();
 
             for (ColumnIdentifier identifier : identifiers) {
                 TableColumnExt column = table.getColumnExt(identifier);
                 if (column == null || column instanceof FixedColumn) {
                     // ignore fixed column
                     continue;
                 }
                 boolean isPmfmColumn = identifier instanceof PmfmColumnIdentifier;
                 boolean isHidden = column instanceof HiddenColumn;
 
                 // Get the visibility property
                 if (isHidden) {
                     // Force hide column
                     column.setVisible(false);
                 } else {
                     Integer visibility;
                     if (isPmfmColumn) {
                         // pmfm column
                         visibility = tableState.getPmfmVisibility().get(((PmfmColumnIdentifier) identifier).getPmfmId());
                     } else {
                         // normal column
                         visibility = tableState.getVisibility().get(identifier.getPropertyName());
                     }
                     if (visibility != null && visibility > -1) {
                         // set column visible
                         column.setVisible(true);
                         // but move it after this loop
                         deferredMove.put(visibility, column.getModelIndex());
                     } else if (column.isHideable()) {
                         // set column invisible if allowed
                         column.setVisible(false);
                     }
                 }
 
                 // Get the width property
                 if (column.getResizable() && !isHidden) {
                     Integer width;
                     if (isPmfmColumn) {
                         // pmfm column
                         width = tableState.getPmfmWidth().get(((PmfmColumnIdentifier) identifier).getPmfmId());
 
                     } else {
                         // normal column
                         width = tableState.getWidth().get(identifier.getPropertyName());
                     }
                     if (width != null) {
                         column.setPreferredWidth(width);
                     }
                 }
 
                 // Get the sortOrder property
                 if (column.isSortable()) {
                     String propertyName = identifier.getPropertyName() + (isPmfmColumn ? SEPARATOR + ((PmfmColumnIdentifier) identifier).getPmfmId() : "");
                     String order = tableState.getSortOrder().get(propertyName);
                     if (order != null) {
                         // parse the sort order and priority
                         String[] orderAndPriority = StringUtils.split(order, SEPARATOR);
                         SortOrder sortOrder = SortOrder.valueOf(orderAndPriority[0]);
                         Integer priority = Integer.parseInt(orderAndPriority[1]);
                         // populate sort order and sort priority maps to apply to table later
                         sortOrderByModelIndex.put(column.getModelIndex(), sortOrder);
                         sortPriority.put(priority, column.getModelIndex());
                     }
                 }
             }
 
             // Apply columns moves
             if (!deferredMove.isEmpty()) {
                 // Process with the target position order instead of model order (Mantis #45506)
                 for (Integer newColumnViewIndex : deferredMove.keySet()) {
                     int columnViewIndex = table.convertColumnIndexToView(deferredMove.get(newColumnViewIndex));
 
                     // shift new column view index if table model has checkTableColumn
 //                if (table.getColumnModel().hasCheckTableColumn() && newColumnViewIndex >= 0) {
 //                    newColumnViewIndex++;
 //                }
                     if (newColumnViewIndex >= table.getColumnCount()) {
                         newColumnViewIndex = table.getColumnCount() - 1;
                     }
 
                     // Move column to target position
                     table.moveColumn(columnViewIndex, newColumnViewIndex);
                 }
             }
 
             // Apply column sort
             if (!sortOrderByModelIndex.isEmpty()) {
                 SortedSet<Integer> priorityOrder = new TreeSet<>(sortPriority.keySet());
                 List<RowSorter.SortKey> sortKeys = new ArrayList<>();
                 for (Integer priority : priorityOrder) {
                     Integer modelIndex = sortPriority.get(priority);
                     SortOrder sortOrder = sortOrderByModelIndex.get(modelIndex);
                     RowSorter.SortKey sortKey = new RowSorter.SortKey(modelIndex, sortOrder);
                     sortKeys.add(sortKey);
                 }
                 table.getRowSorter().setSortKeys(sortKeys);
             }
 
             // Apply additional actions
             AdditionalTableActions additionalTableActions = getAdditionalTableActions(table);
             if (additionalTableActions != null) {
                 tableSessionState.getSelectedActions().forEach(selectedActionName -> additionalTableActions.getActions().stream()
                     .filter(action -> (action instanceof AbstractActionExt) && ((AbstractActionExt) action).isStateAction())
                     .filter(action -> action.getClass().getName().equals(selectedActionName))
                     .findFirst()
                     .ifPresent(action ->
                         {
                             AbstractActionExt stateAction = (AbstractActionExt) action;
                             stateAction.setSelected(true);
                             SwingUtilities.invokeLater(() -> stateAction.actionPerformed(null));
                         }
                     ));
             }
 
         } catch (Exception e) {
             LOG.error("Something goes wrong on setState", e);
         }
     }
 
     // <Dont' delete> these getters ans setters used by SwingSession
 
     public Map<String, SwingTableState> getSessionStates() {
         return sessionStates;
     }
 
     public void setSessionStates(Map<String, SwingTableState> sessionStates) {
         this.sessionStates = sessionStates;
     }
 
     public Set<String> getSelectedActions() {
         return selectedActions;
     }
 
     public void setSelectedActions(Set<String> selectedActions) {
         this.selectedActions = selectedActions;
     }
 
     // </Don't delete>
 
     private AdditionalTableActions getAdditionalTableActions(SwingTable table) {
         Action additionalActions = table.getActionMap().get(AdditionalTableActions.ACTION_NAME);
         return (additionalActions instanceof AdditionalTableActions) ? (AdditionalTableActions) additionalActions : null;
     }
 }