package fr.ifremer.quadrige2.ui.swing.common.action;
   
   /*-
    * #%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 fr.ifremer.quadrige2.core.exception.Quadrige2TechnicalException;
  import fr.ifremer.quadrige2.ui.swing.common.ApplicationUIContext;
  import fr.ifremer.quadrige2.ui.swing.common.AbstractUIHandler;
  import org.apache.commons.lang3.reflect.ConstructorUtils;
  import org.nuiton.i18n.I18n;
  import org.nuiton.jaxx.application.swing.AbstractApplicationUIHandler;
  import org.nuiton.jaxx.application.swing.action.AbstractApplicationAction;
  import org.nuiton.jaxx.application.swing.action.ApplicationActionFactory;
  
  import javax.swing.AbstractButton;
  import java.util.concurrent.*;
  
  /**
   * Action Factory
   */
  public class ActionFactory extends ApplicationActionFactory {
  
      /** {@inheritDoc} */
      @Override
      public <A extends AbstractApplicationAction> A createLogicAction(AbstractApplicationUIHandler handler, Class<A> actionName) {
          ApplicationUIContext context = (ApplicationUIContext) handler.getContext();
          if (AbstractMainUIAction.class.isAssignableFrom(actionName) && context.getMainUI() != null) {
              handler = context.getMainUI().getHandler();
          }
  
          return super.createLogicAction(handler, actionName);
      }
  
      /**
       * <p>createNonBlockingUIAction.</p>
       *
       * @param handler a {@link AbstractUIHandler} object.
       * @param actionName a {@link Class} object.
       * @param <A> a A object.
       * @return a A object.
       */
      public <A extends AbstractWorkerAction> A createNonBlockingUIAction(AbstractUIHandler handler, Class<A> actionName) {
          return createNonBlockingUIAction(handler, actionName, null);
      }
  
      /**
       * <p>createNonBlockingUIAction.</p>
       *
       * @param handler a {@link AbstractUIHandler} object.
       * @param actionName a {@link Class} object.
       * @param button a {@link AbstractButton} object.
       * @param <A> a A object.
       * @return a A object.
       */
      public <A extends AbstractWorkerAction> A createNonBlockingUIAction(AbstractUIHandler handler, Class<A> actionName, AbstractButton button) {
          try {
              // create action
              A action = ConstructorUtils.invokeConstructor(actionName, handler);
  
              if (button != null) {
                  action.setActionIcon(button.getIcon());
                  action.setActionName(button.getText());
                  action.setActionDescription(button.getToolTipText());
                  action.setActionMnemonic(button.getMnemonic());
              }
  
              return action;
          } catch (Exception e) {
              throw new Quadrige2TechnicalException(I18n.t("quadrige2.error.create.action", actionName.getName()), e);
          }
  
      }
  
      /**
       * Create a ThreadPoolExecutor with pool active option
       *
       * @param isPoolActive if true, create a poolable executor that allows multiple calls but always executes the last.
       *                     if false, an exception is raised if a second call happens
      * @return a ThreadPoolExecutor
      */
     public static ThreadPoolExecutor createThreadExecutor(boolean isPoolActive) {
         int capacity = isPoolActive ? 2 : 1;
         BlockingQueue<Runnable> queue = new LinkedBlockingDeque<>(capacity);
 
         RejectedExecutionHandler rejectedExecutionHandler = isPoolActive
                 ? new ThreadPoolExecutor.DiscardPolicy()
                 : new ThreadPoolExecutor.AbortPolicy();
 
         return new ThreadPoolExecutor(1, 1, 1, TimeUnit.MINUTES, queue, rejectedExecutionHandler);
     }
 }