/*
    * Copyright 2004-2008 the Seasar Foundation and the Others.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
   * either express or implied. See the License for the specific language
   * governing permissions and limitations under the License.
   */
  package org.seasar.uruma.binding.method;
  
  import java.lang.reflect.Method;
  
  import org.eclipse.core.runtime.IProgressMonitor;
  import org.eclipse.core.runtime.IStatus;
  import org.eclipse.core.runtime.Status;
  import org.eclipse.core.runtime.jobs.Job;
  import org.eclipse.swt.widgets.Display;
  import org.seasar.framework.beans.BeanDesc;
  import org.seasar.framework.beans.PropertyDesc;
  import org.seasar.framework.beans.factory.BeanDescFactory;
  import org.seasar.framework.util.MethodUtil;
  import org.seasar.uruma.core.UrumaConstants;
  import org.seasar.uruma.core.UrumaMessageCodes;
  import org.seasar.uruma.desc.PartActionDesc;
  import org.seasar.uruma.desc.PartActionDescFactory;
  import org.seasar.uruma.jobs.ProgressMonitor;
  import org.seasar.uruma.jobs.impl.RcpProgressMonitor;
  import org.seasar.uruma.log.UrumaLogger;
  
  /**
   * メソッドを非同期に実行するための {@link MethodBinding} です。<br />
   * 本メソッドでは、実行対象オブジェクトに {@link ProgressMonitor} 型のプロパティが存在する場合、
   * {@link ProgressMonitor} オブジェクトをインジェクションします。<br />
   * また、{@link Display#getCurrent()} によって {@link Display} オブジェクトが取得できる場合には、
   * {@link MethodCallback#callback(MethodBinding, Object[], Object)} メソッドの呼び出しを
   * UI スレッド側で実行します。
   * 
   * @author y-komori
   */
  public class AsyncMethodBinding extends MethodBinding implements
          UrumaMessageCodes {
      private static final UrumaLogger logger = UrumaLogger
              .getLogger(AsyncMethodBinding.class);
  
      private String taskNameProperty;
  
      private boolean cancelable;
  
      /**
       * {@link AsyncMethodBinding} を構築します。<br />
       * 
       * @param target
       *            ターゲットオブジェクト
       * @param method
       *            ターゲットメソッド
       * @param callback
       *            コールバックオブジェクト
       */
      AsyncMethodBinding(final Object target, final Method method,
              final MethodCallback callback) {
          super(target, method, callback);
      }
  
      /*
       * @see org.seasar.uruma.binding.method.MethodBinding#invoke(java.lang.Object[])
       */
      @Override
      public Object invoke(final Object[] args) {
          Object[] filteredArgs = args;
          for (ArgumentsFilter filter : argumentsFilterList) {
              filteredArgs = filter.filter(filteredArgs);
          }
  
          String taskName = getTaskName(taskNameProperty, target);
          AsyncJob job = new AsyncJob(taskName, this, filteredArgs, Display
                  .getCurrent());
          if (cancelable) {
              job.setUser(true);
          }
          job.schedule();
  
          if (logger.isInfoEnabled()) {
              logger.log(ASYNC_METHOD_SCHEDULED, UrumaLogger
                      .getObjectDescription(target), method.getName(), args);
          }
  
          return null;
      }
  
      /**
       * タスク名称を保持するプロパティ名を設定します。<br />
       * 
      * @param taskNameProperty
      *            プロパティ名
      */
     public void setTaskNameProperty(final String taskNameProperty) {
         this.taskNameProperty = taskNameProperty;
     }
 
     /**
      * キャンセル可能かどうかを設定します。<br />
      * 
      * @param cancelable
      *            キャンセル可能な場合は <code>true</code>。
      */
     public void setCancelable(final boolean cancelable) {
         this.cancelable = cancelable;
     }
 
     protected String getTaskName(final String propName, final Object target) {
         if (propName == null) {
             return UrumaConstants.NULL_STRING;
         }
 
         BeanDesc desc = BeanDescFactory.getBeanDesc(target.getClass());
         if (desc.hasPropertyDesc(propName)) {
             PropertyDesc pd = desc.getPropertyDesc(propName);
             if (pd.isReadable()
                     && String.class.isAssignableFrom(pd.getPropertyType())) {
                 return (String) pd.getValue(target);
             }
         }
         return UrumaConstants.NULL_STRING;
     }
 
     protected void injectProgressMonitor(final Object target,
             final IProgressMonitor monitor) {
         PartActionDesc desc = PartActionDescFactory.getPartActionDesc(target
                 .getClass());
 
         ProgressMonitor uMonitor = new RcpProgressMonitor(monitor);
         desc.injectProgressMonitor(target, uMonitor);
     }
 
     /**
      * アクションを非同期実行するための {@link Job} です。<br />
      * 
      * @author y-komori
      */
     class AsyncJob extends Job {
         private MethodBinding binding;
 
         private Object[] args;
 
         private Object returnValue;
 
         private Display display;
 
         /**
          * {@link AsyncJob} を構築します。<br />
          */
         AsyncJob(final String name, final MethodBinding binding,
                 final Object[] args, final Display display) {
             super(name);
             this.binding = binding;
             this.args = args;
             this.display = display;
         }
 
         /*
          * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
          */
         @Override
         protected IStatus run(final IProgressMonitor monitor) {
             if (logger.isInfoEnabled()) {
                 logger.log(ASYNC_METHOD_START, UrumaLogger
                         .getObjectDescription(target), method.getName(), args);
             }
 
             try {
                 injectProgressMonitor(target, monitor);
                 returnValue = MethodUtil.invoke(binding.getMethod(), binding
                         .getTarget(), args);
 
                 if (callback != null) {
                     if (display != null) {
                         display.asyncExec(new Runnable() {
                             public void run() {
                                 returnValue = callback.callback(binding, args,
                                         returnValue);
                             }
                         });
                     } else {
                         returnValue = callback.callback(binding, args,
                                 returnValue);
                     }
                 }
             } catch (Throwable ex) {
                 logger.log(EXCEPTION_OCCURED_INVOKING_METHOD, ex, binding
                         .toString());
             } finally {
                 if (logger.isInfoEnabled()) {
                     String desc = UrumaLogger.getObjectDescription(target);
                     if (!monitor.isCanceled()) {
                         logger.log(ASYNC_METHOD_END, desc, method.getName(),
                                 returnValue);
                     } else {
                         logger.log(ASYNC_METHOD_CANCELED, desc, method
                                 .getName(), returnValue);
                     }
                 }
             }
 
             if (!monitor.isCanceled()) {
                 return Status.OK_STATUS;
             } else {
                 return Status.CANCEL_STATUS;
             }
         }
     }
 }