////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2001-2004 Open World Ltd
   // 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.vm;
  
  import org.millscript.commons.util.EList;
  import org.millscript.commons.util.EMap;
  import org.millscript.commons.util.IList;
  import org.millscript.commons.util.ListIterator;
  import org.millscript.commons.util.MapIterator;
  import org.millscript.commons.util.list.ELinkedList;
  import org.millscript.commons.util.map.EHashMap;
  import org.millscript.millscript.alert.Alerts;
  import org.millscript.millscript.functions.Function;
  import org.millscript.millscript.functions.JConstructor;
  import org.millscript.millscript.functions.JMethod;
  import org.millscript.millscript.functions.JOConstructor;
  import org.millscript.millscript.functions.JOMethod;
  import org.millscript.millscript.functions.JRecognizer;
  
  import java.lang.reflect.Array;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.util.Vector;
  
  /**
   * This class imports all available methods and constructors in a specified
   * Java class into the specified package. The available methods and
   * constructors are imported as functions. If there are multiple constructors
   * or methods that take the same number of parameters, they will not be
   * imported.
   * <p>
   * The imported constructor function will be called by the name of the class
   * prefixed with "new". A recognizer function for instances of this class can
   * be imported called by the name of the class prefixed with "is".
   * </p>
   */
  public class ImportJavaClass {
  
      /**
       * The class we intend to import.
       */
      private final Class clss;
  
      /**
       * The package we will import into.
       */
      private final Package pack;
  
      /**
       * Constructs an instance to import all methods and constructors in the
       * specified Java class into the specified package.
       *
       * @param className the class to import methods and constructors from
       * @param p the package to define the new functions in
       */
      public ImportJavaClass( final String className, final Package p ) {
          Class c = null;
          this.pack = p;
          try {
              c = Class.forName( className );
          } catch ( ClassNotFoundException ex ) {
              throw(
                  Alerts.fault( "Cannot find this class " + className ).mishap()
              );
          }
          clss = c;   //  *sigh*
      }
  
      /**
       * Convenience method to import all available constructors and methods.
       */
      public void importAll() {
          importAllConstructors();
          importAllMethods();
      }
  
      /**
       * Removes duplicate entries from the vector of lists of
       * constructors/methods. Specifically, this method removes entries from the
       * vector where there is more than one item in the list. e.g. this means if
      * two constructors or methods have the same name they will both be
      * removed.
      *
      * @param v the vector of lists of constructors/methods to check
      * @param componentClass    the class we are importing from
      * @return  an array of constructors/methods indexed by the number of
      * parameters the constructor/method takes.
      */
     @SuppressWarnings( "unchecked" )
     private static < T > T[] pruneDups( final Vector< EList< T > > v, final Class< T > componentClass ) {
         // This will hold the maximum number of parameters a constructor/method
         // in this class takes
         int hi = 0;
         // The maximum number of parameters a constructor/method in the class
         // takes, before removing duplicates
         int siz = v.size();
         for ( int i = 0; i < siz; i++ ) {
             // Get the list of constructors that take i parameters
             EList< T > list = v.get( i );
             if ( list != null ) {
                 if ( list.size() > 1 ) {
                     // There is more than one constructor/method that takes i
                     // parameters, so remove them all
                     v.set( i, null );
                 } else {
                     // There is just one constructor/method taking i parameters
                     // so set the maximum number of parameters accordingly
                     hi = Math.max( hi, i + 1 );
                 }
             }
         }
 
         // Make a new array as large as the maximum number of paramters
         T[] result = (T[]) Array.newInstance( componentClass, hi );
         // Loop through the constructors/methods and set each position in the
         // array accordingly
         for ( int i = 0; i < siz; i++ ) {
             EList< T > list = v.get( i );
             if ( list != null ) {
                 result[ i ] = list.get0( 0 );
             }
         }
         return result;
     }
 
     /**
      * Returns the number of non-null elements in the array.
      *
      * @param objs  the array to count non-null elements in
      * @return  the number of non-null elements
      */
     private int countNonNulls( final Object[] objs ) {
         int count = 0;
         for ( int i = 0; i < objs.length; i++ ) {
             if ( objs[ i ] != null ) {
                 count += 1;
             }
         }
         return count;
     }
 
     /**
      * Returns the first non-null item in the array.
      *
      * @param objs  the array to search
      * @return  the first non-null object, or <code>null</code> if all the
      * objects in the array are <code>null</code>
      */
     private Object firstItem( final Object[] objs ) {
         for ( int i = 0; i < objs.length; i++ ) {
             if ( objs[ i ] != null ) {
                 return objs[ i ];
             }
         }
         return null;
     }
 
     /**
      * Return the name of the specified class without any package prefix. e.g.
      * when java.lang.Object is specified, this method would return Object.
      *
      * @param name  the class name
      * @return  the short version of the class name
      */
     private String shortClassName( final String name ) {
         int n = name.lastIndexOf( '.' );
         if ( n == -1 ) {
             return name;
         }
         return name.substring( n + 1 );
     }
 
     /**
      * Imports a recognizer function for this class.
      */
     private void importRecognizer() {
         String name = "is" + shortClassName( clss.getName() );
         pack.bindConst(
             name,
             new JRecognizer( clss )
         );
     }
 
     /**
      * Imports all available constructors in the Java class. This will ignore
      *constructors which take the same number of parameters.
      */
     private void importAllConstructors() {
         // Get the constructors
         Constructor[] cons = clss.getConstructors();
         // Create a vector to store the available constructors in, grouped by
         // the number of parameters required. e.g. at index 1 will be all the
         // constructors taking 1 parameter, and so on.
         Vector< EList< Constructor > > v = new Vector< EList< Constructor > >();
         for ( int i = 0; i < cons.length; i++ ) {
             Constructor c = cons[ i ];
             // How many parameters does this constructor take?
             int n = c.getParameterTypes().length;
             // Ensure the vector has a position for this number of paramters
             v.setSize( n + 1 );
             // Get the list of constructors taking this number of paramters
             EList< Constructor > list = v.get( n );
             if ( list == null ) {
                 list = new ELinkedList< Constructor >();
             }
             // Add this constructor to the list
             list.addLast( c );
             // Put the list into the vector
             v.set( n, list );
         }
 
         // Prune the duplicates and get an array of constructors, indexed by
         // the number of parameters
         Constructor[] result = pruneDups( v, Constructor.class );
 
         // Count the number of non-null elements. i.e. the number of
         // constructors we've found
         int total = countNonNulls( result );
 
         // Check we've found at least one constructor
         if ( total > 0 ) {
             // Make up a string for the constructor function name
             String name = "new" + shortClassName( clss.getName() );
             //  System.out.println( "Defining " + name );
             // Bind the constructor function name to a Java constructor
             // function.
             pack.bindConst(
                 name,
                 (
                     total == 1 ?
                     (Function)new JConstructor( (Constructor)firstItem( result ) ) :
                     (Function)new JOConstructor( result )
                 ).modName( name )
             );
         }
     }
 
     /**
      * Imports all available methods in the Java class. This will ignore
      * methods which take the same number of parameters.
      */
     private void importAllMethods() {
         // Get the available methods
         Method[] meths = clss.getMethods();
         // Create a map to store the available methods in, mapping the method
         // name to a list of methods with that name
         EMap< String, EList< Method > > map = new EHashMap< String, EList< Method > >();
         for ( int i = 0; i < meths.length; i++ ) {
             Method m = meths[ i ];
             String name = m.getName();
             EList< Method > list = map.get( name );
             if ( list == null ) {
                 list = new ELinkedList< Method >();
                 map.insert( name, list );
             }
             list.addLast( m );
         }
         // Iterate over the available methods and import each one.
         MapIterator< String, EList< Method > > it = map.iterator( true );
         while ( it.hasNext() ) {
             importMethod( it.nextKey(), it.currentValue() );
         }
     }
 
     /**
      * Imports the specified list of methods, removing any methods that take
      * the same number of paramters.
      *
      * @param name  the name of the method being imported, which will be the
      * name bound in the package
      * @param methods   the list of methods to import
      */
     private void importMethod( final String name, final IList< Method > methods ) {
         // Create a vector to store the available methods in, grouped by
         // the number of parameters required. e.g. at index 1 will be all the
         // methods taking 1 parameter, and so on.
         Vector< EList< Method > > v = new Vector< EList< Method > >();
         ListIterator< Method > it = methods.iterator( true );
         while ( it.hasNext() ) {
             Method m = it.nextValue();
             // How many parameters does this method take?
             int n = m.getParameterTypes().length;
             // Ensure the vector has a position for this number of paramters
             v.setSize( n + 1 );
             // Get the list of methods taking this number of paramters
             EList< Method > list = v.get( n );
             if ( list == null ) {
                 list = new ELinkedList< Method >();
             }
             // Add this method to the list
             list.addLast( m );
             // Put the list into the vector
             v.set( n, list );
         }
 
         // Prune the duplicates and get an array of methods, indexed by the
         // number of parameters
         Method[] result = pruneDups( v, Method.class );
         // Count the number of non-null elements. i.e. the number of
         // methods we've found
         int total = countNonNulls( result );
         // Check that total is greater than zero? and that the symbol does not
         // have a pervasive import in this package
         if ( total > 0 && pack.hasPervasiveImport( name ) == null ) {
             //  System.out.println( "Assigning " + name );
             // Bind the method function name to a Java method function.
             pack.bindConst(
                 name,
                 (
                     total > 0 ?
                     (Function)JMethod.make( (Method)firstItem( result ) ) :
                     (Function)new JOMethod( result )
                 ).modName( name )
             );
         }
     }
 }