////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2005 Kevin Rogers
   //
   // This file is part of MillScript.
   //
   // MillScript is free software; you can redistribute it and/or modify it under
   // the terms of the GNU General Public License as published by the Free
   // Software Foundation; either version 2 of the License, or (at your option)
  // any later version.
  //
  // MillScript 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 General Public License along with
  // MillScript; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.millscript.conf.functions;
  
  import org.millscript.commons.alert.alerts.Fault;
  import org.millscript.millscript.alert.Alerts;
  import org.millscript.millscript.functions.Function;
  import org.millscript.millscript.vm.Machine;
  import org.millscript.millscript.vm.Package;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  
  
  /**
   * This class implements the configuration function <code>AddFunction</code>.
   */
  public class AddFunctionFunction extends Function {
  
      /**
       * The package we should add functions to.
       */
      private Package pack;
  
      /**
       * Constructs a new add function function, to add a function to the given
       * package.
       *
       * @param p the package we should add functions to
       */
      public AddFunctionFunction( final Package p ) {
          this.pack = p;
      }
  
      /**
       * @see org.millscript.millscript.functions.Function#apply(org.millscript.millscript.vm.Machine, int)
       */
      @Override
      @SuppressWarnings("unchecked")
      public void apply( Machine mc, int nargs ) {
          checkNargs( mc, 2, nargs );
          final String functionClassName = mc.popString();
          final String functionName = mc.popString();
          try {
              // Get the function Class object for the configuration entry
              final Class< ? > functionClass = Class.forName( functionClassName );
              // Check the retrieved class is an extension of a Function
              if ( Function.class.isAssignableFrom( functionClass ) ) {
                  // Return an instance of the function's class
                  final Function function = this.constructFunction( (Class< Function >) functionClass );
                  // Bind the function symbol to the Function object
                  pack.bindConst( functionName, function );
              } else {
                  // Hmmm. Not a Function.
                  throw new Fault(
                      "A function must inherit from the Function class"
                  ).culprit( "class", functionClass ).mishap();
              }
          } catch ( ClassNotFoundException ex ) {
              throw(
                  Alerts.parse(
                      "Function Class not found",
                      "Ensure function class is available in a classes folder"
                  ).culprit( "class", functionClassName ).mishap()
              );
          }
      }
  
      /**
       * Returns a new instance of the specified function class.
       *
       * @param functionClass the <code>Function</code> class to make a new
       * instance of.
       * @return  a new instance of the specified <code>Function</code> class
       */
      public Function constructFunction( final Class< Function > functionClass ) {
          try {
              try {
                  // Try to find a contructor that takes a package as its sole
                  // parameter
                  Constructor< Function > c = functionClass.getConstructor( Package.class );
                 // Good, we're still here so we found it.
                 return c.newInstance( this.pack );
             } catch ( NoSuchMethodException ex ) {
                 try {
                     Constructor< Function > c = functionClass.getConstructor();
                     // Good, we're still here so we found it.
                     return c.newInstance();
                 } catch ( NoSuchMethodException ex2 ) {
                     throw new Fault(
                         "Could not construct function - need an empty or single(Package) arg constructor"
                     ).culprit( "class", functionClass ).setParentThrowable( ex2 ).mishap();
                 }
             }
             
         } catch ( ExceptionInInitializerError ex ) {
             throw new Fault(
                 "Could not construct function - unexpected failure in a static initialiser"
             ).culprit( "class", functionClass ).setParentThrowable( ex ).mishap();
         } catch ( IllegalAccessException ex ) {
             throw new Fault(
                 "Could not construct function - illegal access to constructor"
             ).culprit( "class", functionClass ).setParentThrowable( ex ).mishap();
         } catch ( IllegalArgumentException ex ) {
             throw new Fault(
                 "Could not construct function - illegal argument for constructor"
             ).culprit( "class", functionClass ).setParentThrowable( ex ).mishap();
         } catch ( InstantiationException ex ) {
             throw new Fault(
                 "Could not construct function - abstract class cannot be constructed"
             ).culprit( "class", functionClass ).setParentThrowable( ex ).mishap();
         } catch ( InvocationTargetException ex ) {
             throw new Fault(
                 "Could not construct function - constructor threw an exception"
             ).culprit(
                 "class",
                 functionClass
             ).culprit(
                 "exception",
                 ex.getCause()
             ).setParentThrowable( ex ).mishap();
         } catch ( SecurityException ex ) {
             throw new Fault(
                 "Could not construct function - access to constructor denied"
             ).culprit( "class", functionClass ).setParentThrowable( ex ).mishap();
         }
     }
 
 }