//
// GetNative.java : (native) からメソッドオブジェクトを生成するクラス定義
//
//              This is a part of miolisp sourcefile
//              Copyright (C) 1998  Nishiyama, Naoki / Mio software lab. 
//
//  This program 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.
//
//  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 General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

import java.util.* ;
import java.io.* ;
import java.lang.* ;
import java.lang.reflect.* ;

class GetNative {
  // (native でコンストラクタを得るために使用する文字列
  public static final String CONSTRUCTOR = "new" ;
  public static final String IMPORTSTR   = "Import" ;

  // LispFunc インターフェイスチェック用のクラス参照 (import で使用
  static Class   LispFuncInterface ;
  static Class[] LispFuncMarg ;

  // LispFunc インターフェイスクラスの名前 (import で使用
  static final String LISPFUNCINTERF = "LispFunction" ;
  static final String LISPFUNCMARG[] = { "Environment" , "java.lang.Object" };

  static {
    LispFuncMarg = new Class[LISPFUNCMARG.length] ;
    try {
      for (int i=0;i<LISPFUNCMARG.length;i++)
        LispFuncMarg[i] = Class.forName(LISPFUNCMARG[i]) ;
    } catch(ClassNotFoundException e) { // LISPFUNCMARG に記述されている
      e.printStackTrace() ;             // クラス名が間違っている場合
    }
  }

  // Bind Import
  public static void bindimport() {
    try {
      SAtom.getSAtom(IMPORTSTR).setGlobal(
        new NativeFunction(
          Class.forName("GetNative").getMethod(IMPORTSTR,LispFuncMarg)
        )
      ) ;
    } catch(Exception e) {               // LISPFUNCMARG に記述されている
      e.printStackTrace() ;             // クラス名が間違っている場合
    }
  }

  // Import
  public static Object Import(Environment e,Object o) throws Exception {
    o = Eval.eval(Evalutil.getarg1("import :",o),e) ;
    if (!(o instanceof String)) {
      throw new EvalException("import : filename must be String") ;
    }
    return importlispclass(o,e,false) ;
  }

  // LispFunc method かどうかの判別
  public static boolean islispfuncmethod(Method m) {
    int i , mtyp = m.getModifiers() ;	
    // public & static ?
    if (Modifier.isPublic(mtyp) && Modifier.isStatic(mtyp)) {
      // method(Environment,Object) ?
      Class ca[] = m.getParameterTypes() ;

      // 引数タイプの不一致があれば、その method は無視
      for (i=0;i<LispFuncMarg.length;i++) {
        if (ca[i] != LispFuncMarg[i]) return false ;
      }
      return true ;
    }
    return false ;
  } 

  // LispFunc Class かどうかの判別
  public static boolean islispfuncclass(Class c) throws Exception {
    Class[] cla = c.getInterfaces() ;

    if (LispFuncInterface == null) {
      LispFuncInterface = Class.forName(LISPFUNCINTERF) ;
    }
    for (int i = 0;i < cla.length;i++) {
      if (cla[i] == LispFuncInterface) return true ;
    }
    return false ;
  }

  public static Object getmethod(Object c,Object m,Object argcs) throws Exception {
    int i ;

    if (!(c instanceof String)) {
      throw new EvalException("classname not string") ;
    }
    if (!(m instanceof String)) {
      throw new EvalException("classname not string") ;
    }
    String cname = (String)c , mname = (String)m ;
    Object[] arg = Evalutil.listtoarg(argcs) ;
    Class[] argc = new Class[arg.length] ;
    Class cls = Class.forName(cname) ;

    // 引数のチェックとクラス形への変換
    for (i=0;i<arg.length;i++) {
      if (!(arg[i] instanceof String)) {
        throw new EvalException("Getmethod Args-Classes must be string") ;
      }
      // プリミティブ型かどうかの判別
      // 注意：現在暫定的に int しか判断していない。
      // boolean, byte, char, short, int, long, float, double, および void 
      // の全てについて、同じ事を行う必要があるはず (99/1/5)
      if (((String)arg[i]).equals("int")) {
        argc[i] = Integer.TYPE ;
      } else {
        argc[i] = Class.forName((String)arg[i]) ;
      }
    }

    if (!mname.equals(CONSTRUCTOR)) {
      return cls.getMethod(mname,argc) ;
    } else {
      return cls.getConstructor(argc) ;
    }
  }

  // Importing LispFunction
  public static Object importlispclass(Object o,Environment e,boolean v) throws Exception {
    int total = 0 ;

    if (!(o instanceof String)) {
      throw new EvalException("classname not string") ;
    }
    String s = (String)o ;
    Class cls = Class.forName(s) ;

    if (!islispfuncclass(cls)) {
      return importjavaclass(s,cls,e) ;
    }

    Method ma[] = cls.getDeclaredMethods() ;
    for (int i=0;i<ma.length;i++) {
      // static public な method のみを import する。
      if (islispfuncmethod(ma[i])) {
        e.bind(SAtom.getSAtom(ma[i].getName().toLowerCase()),new NativeFunction(ma[i])) ;
        total++ ;
        if (v) System.out.print(ma[i].getName().toLowerCase()+". ") ;
      } else {
        // System.out.println(ma[i].getName().toLowerCase()+" ignored.") ;
      }
    }

    if (v) {
      System.out.println() ;
      System.out.println("Total "+total+" primitives imported.") ;
    }
    return new Integer(total) ;
  }

  // Importing Java Class 
  public static Object importjavaclass(String s,Class cls,Environment e) throws Exception {

    int total = 0 ;                  // 1999/1/5
    Method ma[] = cls.getMethods() ; // getDeclaredMethods() -> getMethods()
    for (int i=0;i<ma.length;i++) {
      SAtom sa = SAtom.getSAtom(s+"."+ma[i].getName().toLowerCase()) ;
      Object o = sa.getGlobal() ;

      if (!(o instanceof JavaMethod)) {
        sa.setGlobal(new JavaMethod(ma[i])) ;
//        System.out.println(sa.getName()+" binded.") ;
      } else {
        ((JavaMethod)o).addMethod(ma[i]) ;
//        System.out.println(sa.getName()+" binded. (*)") ;
      }
      total++ ;
    }

    return new Integer(total) ;
  }

}