package fr.ifremer.quadrige3.ui.swing.action;
   
   /*
    * #%L
    * Reef DB :: UI
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2013 - 2014 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.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.core.config.QuadrigeCoreConfiguration;
  import fr.ifremer.quadrige3.ui.swing.ApplicationUI;
  import fr.ifremer.quadrige3.ui.swing.ApplicationUIContext;
  import fr.ifremer.quadrige3.ui.swing.AbstractUIHandler;
  import fr.ifremer.quadrige3.ui.swing.model.ProgressionUIModel;
  import org.jdesktop.beans.AbstractBean;
  import org.nuiton.i18n.I18n;
  
  import javax.swing.AbstractAction;
  import javax.swing.Icon;
  import javax.swing.SwingWorker;
  import java.awt.event.ActionEvent;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.ThreadPoolExecutor;
  
  /**
   * <p>Abstract AbstractWorkerAction class.</p>
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   * @param <M>
   * @param <UI>
   * @param <H>
   */
  public abstract class AbstractWorkerAction<M extends AbstractBean, UI extends ApplicationUI<M, ?>, H extends AbstractUIHandler<M, UI>>
      extends AbstractAction {
  
      protected final H handler;
  
      private Worker worker;
  
      private final ThreadPoolExecutor executor;
  
      private final Object lock = new Object();
  
      private boolean wait;
  
      private Exception reportedException;
  
      /**
       * <p>initAction.</p>
       *
       * @return a boolean.
       */
      public abstract boolean initAction();
  
      /**
       * <p>doAction.</p>
       *
       * @throws Exception if any.
       */
      public abstract void doAction() throws Exception;
  
      /**
       * <p>doneAction.</p>
       */
      public abstract void doneAction();
  
      /**
       * <p>failedAction.</p>
       *
       * @param ex a {@link Throwable} object.
       */
      public abstract void failedAction(Throwable ex);
  
      /**
       * <p>disposeAction.</p>
       */
      public abstract void disposeAction();
  
      /**
       * <p>Constructor for AbstractWorkerAction.</p>
       *  @param handler a H object.
       *
      */
     public AbstractWorkerAction(H handler) {
 
         super();
         this.handler = handler;
 
         // executor for worker action must not be pooled
         executor = ActionFactory.createSingleThreadExecutor(ActionFactory.ExecutionMode.UNIQUE);
     }
 
     /**
      * <p>Getter for the field <code>handler</code>.</p>
      *
      * @return a H object.
      */
     public H getHandler() {
         return handler;
     }
 
     /**
      * <p>getUI.</p>
      *
      * @return a UI object.
      */
     public UI getUI() {
         return handler.getUI();
     }
 
     /**
      * <p>getModel.</p>
      *
      * @return a M object.
      */
     public M getModel() {
         return handler.getModel();
     }
 
     /**
      * <p>getConfig.</p>
      *
      * @return a {@link QuadrigeCoreConfiguration} object.
      */
     public QuadrigeCoreConfiguration getConfig() {
         return handler.getConfig();
     }
 
     /**
      * <p>getContext.</p>
      *
      * @return a {@link ApplicationUIContext} object.
      */
     public ApplicationUIContext getContext() {
         return handler.getContext();
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isEnabled() {
         return super.isEnabled() && (worker == null || worker.isDone());
     }
 
     public boolean isRunning() {
         return executor.getActiveCount() > 0;
     }
 
     /**
      * <p>getActionDescription.</p>
      *
      * @return a {@link String} object.
      */
     public String getActionDescription() {
         return (String) getValue(SHORT_DESCRIPTION);
     }
 
     /**
      * <p>setActionDescription.</p>
      *
      * @param actionDescription a {@link String} object.
      */
     public void setActionDescription(String actionDescription) {
         putValue(SHORT_DESCRIPTION, actionDescription);
     }
 
     /**
      * <p>setActionIcon.</p>
      *
      * @param actionIcon a {@link Icon} object.
      */
     public void setActionIcon(Icon actionIcon) {
         putValue(SMALL_ICON, actionIcon);
         putValue(LARGE_ICON_KEY, actionIcon);
     }
 
     /**
      * <p>setActionKey.</p>
      *
      * @param actionKey a {@link String} object.
      */
     public void setActionKey(String actionKey) {
         putValue(ACTION_COMMAND_KEY, actionKey);
     }
 
     /**
      * <p>setActionName.</p>
      *
      * @param actionName a {@link String} object.
      */
     public void setActionName(String actionName) {
         putValue(NAME, actionName);
     }
 
     /**
      * <p>setActionMnemonic.</p>
      *
      * @param key a int.
      */
     public void setActionMnemonic(int key) {
         putValue(MNEMONIC_KEY, key);
     }
 
     /**
      * <p>execute.</p>
      */
     public void execute() {
         run();
     }
 
     /**
      * <p>executeAndWait.</p>
      *
      * @throws Exception if any.
      */
     public void executeAndWait() throws Exception {
         wait = true;
         run();
         lock();
         if (reportedException != null) {
             throw reportedException;
         }
     }
 
     private void run() {
 
         boolean doWork;
 
         try {
             doWork = initAction();
         } catch (Exception ex) {
             disposeAction();
             unlock();
             throw new QuadrigeTechnicalException(I18n.t("quadrige3.error.prepare.action", getActionDescription()), ex);
         }
 
         if (doWork) {
 
             try {
 
                 // Threaded action
                 worker = new Worker();
                 executor.execute(worker);
 
             } catch (Exception ex) {
                 disposeAction();
                 throw new QuadrigeTechnicalException(I18n.t("quadrige3.error.execute.action", getActionDescription()), ex);
             }
 
         }
         else {
 
             disposeAction();
             unlock();
 
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void actionPerformed(ActionEvent e) {
 
         // call default run
         run();
 
     }
 
     /**
      * <p>lock.</p>
      */
     protected void lock() {
         if (wait) {
             synchronized (lock) {
                 try {
                     lock.wait();
                 } catch (InterruptedException ex) {
                     throw new QuadrigeTechnicalException(I18n.t("quadrige3.error.execute.wait.action", getActionDescription()), ex);
                 } finally {
                     wait = false;
                 }
             }
         }
     }
 
     /**
      * <p>unlock.</p>
      */
     protected void unlock() {
         if (wait) {
             synchronized (lock) {
                 lock.notifyAll();
             }
         }
     }
 
     /**
      * <p>isWait.</p>
      *
      * @return a boolean.
      */
     public boolean isWait() {
         return wait;
     }
 
     /**
      * <p>Setter for the field <code>reportedException</code>.</p>
      *
      * @param reportedException a {@link Exception} object.
      */
     public void setReportedException(Exception reportedException) {
         this.reportedException = reportedException;
     }
 
     private class Worker extends SwingWorker<Void, ProgressionUIModel> {
 
         public Worker() {
         }
 
         @Override
         protected Void doInBackground() throws Exception {
 
             doAction();
 
             return null;
         }
 
         @Override
         protected void done() {
 
             try {
                 try {
                     get();
                     doneAction();
                 } catch (InterruptedException ex) {
                     if (wait) {
                         throw new QuadrigeTechnicalException(ex);
                     }
                     else {
                         failedAction(ex);
                     }
                 } catch (ExecutionException ex) {
                     Throwable cause = ex.getCause();
                     if (wait) {
                         if (cause != null && cause instanceof Exception) {
                             setReportedException((Exception) cause);
                         }
                         else {
                             setReportedException(ex);
                         }
                     }
                     else {
                         failedAction(cause);
                     }
                 }
             } finally {
                 disposeAction();
                 unlock();
 
             }
 
         }
 
     }
 
 }