/**
    * 
    */
   package org.opentrafficsim.water;
   
   import java.io.Serializable;
   import java.lang.reflect.Constructor;
   import java.lang.reflect.Method;
   import java.util.LinkedHashMap;
  import java.util.Map;
  
  import org.djutils.reflection.ClassUtil;
  
  import nl.tudelft.simulation.dsol.SimRuntimeException;
  
  /**
   * <p>
   * Copyright (c) 2013-2020 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
   * BSD-style license. See <a href="http://opentrafficsim.org/docs/current/license.html">OpenTrafficSim License</a>.
   * </p>
   * <p>
   * Based on software from the IDVV project, which is Copyright (c) 2013 Rijkswaterstaat - Dienst Water, Verkeer en Leefomgeving
   * and licensed without restrictions to Delft University of Technology, including the right to sub-license sources and derived
   * products to third parties.
   * </p>
   * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
   * initial version Nov 6, 2016 <br>
   * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   */
  public class SchedulableMethod implements Serializable
  {
      /** */
      private static final long serialVersionUID = 1L;
  
      /** target reflects the target on which a state change is scheduled. */
      @SuppressWarnings("checkstyle:visibilitymodifier")
      protected Object target = null;
  
      /** method is the method which embodies the state change. */
      @SuppressWarnings("checkstyle:visibilitymodifier")
      protected String method = null;
  
      /** args are the arguments which are used to invoke the method with. */
      @SuppressWarnings("checkstyle:visibilitymodifier")
      protected Object[] args = null;
  
      /** cache. */
      private static Map<String, Method> cacheMethods = new LinkedHashMap<String, Method>();
  
      /**
       * The constructor of the schedulable method stores the object and method to invoke with its arguments.
       * @param target Object; reflects the object on which the method must be invoked.
       * @param method String; reflects the method to invoke
       * @param args Object[]; reflects the argumenst the method to invoke with
       */
      public SchedulableMethod(final Object target, final String method, final Object[] args)
      {
          if (target == null || method == null)
          {
              throw new IllegalArgumentException("target or method==null");
          }
          this.target = target;
          this.method = method;
          this.args = args;
      }
  
      /**
       * Executes the method. Method &lt;init&gt; means the constructor.
       */
      public final synchronized void execute()
      {
          try
          {
              if (this.method.equals("<init>"))
              {
                  if (!(this.target instanceof Class))
                  {
                      throw new SimRuntimeException("Invoking a constructor implies that target should be instance of Class");
                  }
                  Constructor<?> constructor = ClassUtil.resolveConstructor((Class<?>) this.target, this.args);
                  constructor.setAccessible(true);
                  constructor.newInstance(this.args);
              }
              else
              {
                  String key = this.target.getClass().getName() + "_" + this.method;
                  Method tm = cacheMethods.get(key);
                  if (tm == null)
                  {
                      tm = ClassUtil.resolveMethod(this.target, this.method, this.args);
                      cacheMethods.put(key, tm);
                  }
                  tm.setAccessible(true);
                  tm.invoke(this.target, this.args);
              }
          }
          catch (Exception exception)
          {
              exception.printStackTrace();
         }
     }
 
     /**
      * @return Returns the args.
      */
     public final Object[] getArgs()
     {
         return this.args;
     }
 
     /**
      * @return Returns the method.
      */
     public final String getMethod()
     {
         return this.method;
     }
 
     /**
      * @return Returns the target.
      */
     public final Object getTarget()
     {
         return this.target;
     }
 
     /** {@inheritDoc} */
     @Override
     public final String toString()
     {
         return "SchedulableMethod[target=" + this.target + "; method=" + this.method + "; args=" + this.args + "]";
     }
 
 }