package fr.ifremer.quadrige3.ui.swing;
   
   /*-
    * #%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 com.google.common.collect.Sets;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.ui.swing.table.state.ExtendedState;
  import jaxx.runtime.swing.session.State;
  import org.apache.commons.collections4.MapUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import java.awt.Component;
  import java.io.File;
  import java.io.IOException;
  import java.nio.file.Files;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.regex.Pattern;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  
  /**
   * Swing session that extends standard swing session to handle components states save/restore but handles a set of component to avoid save and restore action
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class SwingSession extends jaxx.runtime.swing.session.SwingSession {
  
      private static final Log LOG = LogFactory.getLog(SwingSession.class);
  
      private final Set<Component> unsavedComponents = Sets.newHashSet();
  
      private final Set<String> unsavedRootComponentNames = Sets.newHashSet();
  
      private boolean partialSave;
  
      /**
       * <p>newSwingSession.</p>
       *
       * @param file             a {@link File} object.
       * @param autoSave         a boolean.
       * @param additionalStates a {@link Map} object.
       * @return a {@link SwingSession} object.
       */
      public static SwingSession newSwingSession(File file, boolean autoSave, Map<Class, State> additionalStates) {
          Assert.notNull(file);
          patchFile(file);
          return new SwingSession(file, autoSave, additionalStates);
      }
  
      /**
       * Patch file if some package rename have been done
       *
       * @param file
       */
      private static void patchFile(File file) {
  
          if (!file.exists())
              return;
  
          try (Stream<String> lines = Files.lines(file.toPath())) {
              List<String> replaced = lines
                      .map(line-> line.replaceAll("fr.ifremer.quadrige3.ui.swing.common", "fr.ifremer.quadrige3.ui.swing"))
                      .collect(Collectors.toList());
              Files.write(file.toPath(), replaced);
          } catch (IOException ioe) {
              throw new QuadrigeTechnicalException("something goes wrong when patching file " + file, ioe);
          }
  
      }
  
      private SwingSession(File file, boolean autoSave, Map<Class, State> additionalStates) {
          super(file, autoSave, additionalStates);
     }
 
     /**
      * Restore the state for the specified component
      *
      * @param component the component to restore
      */
     public void restoreState(Component component) {
         walkThrowComponent("", registeredComponent, new ExtendedRestoreStateAction(component.getName()));
     }
 
     /**
      * Update the state for the specified component
      *
      * @param component    the component to update
      * @param stateContext a {@link String} object.
      */
     public void updateState(Component component, String stateContext) {
         walkThrowComponent("", registeredComponent, new ExtendedSaveStateAction(component.getName(), stateContext));
     }
 
     /**
      * Allow a partial save. When save() is called, updateState() is called to update all registered components before write xml file.
      * With partial save, updateState() will not be called. It allows user to update (and save) some components only to xml file.
      * for ex:
      * swingSession.updateState(componentToSave);
      * swingSession.setPartialSave(true);
      * swingSession.save();
      * swingSession.setPartialSave(false);
      *
      * @param partialSave a boolean.
      */
     public void setPartialSave(boolean partialSave) {
         this.partialSave = partialSave;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void updateState() {
         if (partialSave) {
             return;
         }
 
         super.updateState();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Make sure we use the correct save and restore actions
      */
     @Override
     protected void walkThrowComponent(String path, Collection<Component> roots, Action action) {
         if (action instanceof SaveStateAction && !(action instanceof ExtendedSaveStateAction)) {
             action = new ExtendedSaveStateAction();
         }
         if (action instanceof RestoreStateAction && !(action instanceof ExtendedRestoreStateAction)) {
             action = new ExtendedRestoreStateAction();
         }
         super.walkThrowComponent(path, roots, action);
     }
 
     @Override
     protected String getComponentName(Component c) {
         String name = c.getName();
         if (name == null) {
             int n = c.getParent() == null ? -1 : c.getParent().getComponentZOrder(c);
             if (n >= 0) {
                 Class clazz = c.getClass();
                 name = clazz.getSimpleName();
                 if (StringUtils.isEmpty(name)) {
                     name = "Anonymous" + clazz.getSuperclass().getSimpleName();
                 }
                 name += n;
             } else {
                 LOG.warn("Couldn't compute pathname for " + c);
             }
         }
         return name;
     }
 
     /**
      * <p>addUnsavedComponent.</p>
      *
      * @param unsavedComponent a {@link Component} object.
      */
     public void addUnsavedComponent(Component unsavedComponent) {
         this.unsavedComponents.add(unsavedComponent);
     }
 
     /**
      * <p>addUnsavedComponents.</p>
      *
      * @param unsavedComponents a {@link Set} object.
      */
     public void addUnsavedComponents(Set<Component> unsavedComponents) {
         this.unsavedComponents.addAll(unsavedComponents);
     }
 
     /**
      * <p>addUnsavedRootComponentByName.</p>
      *
      * @param unsavedRootComponentName a {@link String} object.
      */
     public void addUnsavedRootComponentByName(String unsavedRootComponentName) {
         this.unsavedRootComponentNames.add("/" + unsavedRootComponentName);
     }
 
     /**
      * <p>isComponentToSave.</p>
      *
      * @param path a {@link String} object.
      * @param c    a {@link Component} object.
      * @return a boolean.
      */
     public boolean isComponentToSave(String path, Component c) {
         if (!unsavedRootComponentNames.isEmpty()) {
             for (String rootName : unsavedRootComponentNames) {
                 if (path.startsWith(rootName)) {
                     return false;
                 }
             }
         }
         return unsavedComponents.isEmpty() || !unsavedComponents.contains(c);
     }
 
     /**
      * Return the state of the component by name matching the regex
      *
      * @param componentNameRegEx component name regex
      * @return the found state
      */
     public State findStateByComponentName(String componentNameRegEx) {
 
         if (MapUtils.isNotEmpty(states)) {
             Pattern p = Pattern.compile(componentNameRegEx);
             for (String componentPath : states.keySet()) {
                 if (p.matcher(componentPath).matches()) {
                     return states.get(componentPath);
                 }
             }
         }
         return null;
     }
 
     class ExtendedSaveStateAction extends SaveStateAction {
 
         private final String componentName;
         private final String stateContext;
 
         public ExtendedSaveStateAction() {
             this(null);
         }
 
         public ExtendedSaveStateAction(String componentName) {
             this(componentName, null);
         }
 
         public ExtendedSaveStateAction(String componentName, String stateContext) {
             this.componentName = componentName;
             this.stateContext = stateContext;
         }
 
         @Override
         public void doAction(jaxx.runtime.swing.session.SwingSession session, String path, Component c) {
             if (session instanceof SwingSession && !((SwingSession) session).isComponentToSave(path, c)) {
                 // don't save state of specified components
                 return;
             }
 
             if (componentName != null && !path.endsWith(componentName)) {
                 // if componentName is specified, save only this component
                 return;
             }
 
             // don't call super method
             State manager = session.getStateManager(c.getClass());
             State state;
             if (manager instanceof ExtendedState) {
                 // call getState with the previous state stored in session
                 state = ((ExtendedState) manager).getState(c, session.getStates(path), stateContext);
             } else {
                 state = manager.getState(c);
             }
             session.setStates(path, state);
         }
     }
 
     class ExtendedRestoreStateAction extends RestoreStateAction {
 
         private final String componentName;
 
         public ExtendedRestoreStateAction(String componentName) {
             this.componentName = componentName;
         }
 
         public ExtendedRestoreStateAction() {
             this(null);
         }
 
         @Override
         public void doAction(jaxx.runtime.swing.session.SwingSession session, String path, Component c) {
             if (session instanceof SwingSession && !((SwingSession) session).isComponentToSave(path, c)) {
                 // don't restore state of specified components
                 return;
             }
 
             if (componentName != null && !path.endsWith(componentName)) {
                 // if componentName is specified, restore only this component
                 return;
             }
 
             super.doAction(session, path, c);
         }
     }
 }