//===---- ClasspathVMClass.cpp - GNU classpath java/lang/VMClass ----------===//
//
//                              JnJVM
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include <string.h>

#include "types.h"

#include "JavaAccess.h"
#include "JavaArray.h"
#include "JavaClass.h"
#include "JavaConstantPool.h"
#include "JavaObject.h"
#include "JavaString.h"
#include "JavaTypes.h"
#include "JavaThread.h"
#include "JavaUpcalls.h"
#include "Jnjvm.h"
#include "NativeUtil.h"
#include "Reader.h"

using namespace jnjvm;

extern "C" {

JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
jobject klass) {

  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)klass);

  return cl->isArray();
  
}

JNIEXPORT jclass JNICALL Java_java_lang_VMClass_forName(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif

                                                        jobject str, 
                                                        jboolean clinit, 
                                                        jobject loader) {

  Jnjvm* vm = JavaThread::get()->isolate; 
  JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
  UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str,
                                                        true, false);
  if (cl != 0) {
    if (clinit) {
      cl->initialiseClass(vm);
    }
    return (jclass)(cl->getClassDelegatee(vm));
  } else {
    vm->classNotFoundException((JavaString*)str);
    return 0;
  }
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredConstructors(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                                         jclass clazz,
#endif

                                                                         jclass Cl, 
                                                                         jboolean publicOnly) {

  UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
  Jnjvm* vm = JavaThread::get()->isolate;

  if (cl->isArray() || cl->isInterface()) {
    return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm);
  } else {
    std::vector<JavaMethod*> res;
    cl->getDeclaredConstructors(res, publicOnly);
    
    ArrayObject* ret = 
      (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(res.size(), vm);
    sint32 index = 0;
    for (std::vector<JavaMethod*>::iterator i = res.begin(), e = res.end();
          i != e; ++i, ++index) {
      JavaMethod* meth = *i;
      // TODO: check parameter types
      UserClass* Cons = vm->upcalls->newConstructor;
      JavaObject* tmp = Cons->doNew(vm);
      vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, Cl, meth);
      ret->elements[index] = tmp;
    }
    return (jobject)ret;
  }
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredMethods(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                                    jclass clazz,
#endif

                                                                    jclass Cl, 
                                                                    jboolean publicOnly) {

  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);

  if (cl->isArray()) {
    return (jobject)vm->upcalls->methodArrayClass->doNew(0, vm);
  } else {
    std::vector<JavaMethod*> res;
    cl->getDeclaredMethods(res, publicOnly);
    
    ArrayObject* ret = (ArrayObject*)vm->upcalls->methodArrayClass->doNew(res.size(), vm);
    sint32 index = 0;
    for (std::vector<JavaMethod*>::iterator i = res.begin(), e = res.end();
          i != e; ++i, ++index) {
      JavaMethod* meth = *i;
      // TODO: check parameter types
      UserClass* Meth = vm->upcalls->newMethod;
      JavaObject* tmp = Meth->doNew(vm);
      vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl,
                                              vm->UTF8ToStr(meth->name), meth);
      ret->elements[index] = tmp;
    }
    return (jobject)ret;
  }
}

JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                           jclass clazz,
#endif
                                                           jclass Cl, 
                                                           jboolean ignore) {

  UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
  return cl->getAccess();
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                         jclass clazz, 
#endif
                                                         jobject Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);
  
  const UTF8* iname = cl->getName();
  const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, iname->size);

  return (jobject)(vm->UTF8ToStr(res));
}

JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                              jclass clazz, 
#endif
                                                              jclass Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);
  
  return cl->isPrimitive();
}

JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                              jclass clazz, 
#endif
                                                              jclass Cl) {
  UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);

  return cl->isInterface();
}

JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType(
#ifdef NATIVE_JNI
JNIEnv *env,
                                                                 jclass clazz, 
#endif
                                                                 jclass Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);

  if (cl->isArray()) {
    UserCommonClass* bc = ((UserClassArray*)cl)->baseClass();
    return (jclass)(bc->getClassDelegatee(vm));
  } else {
    return 0;
  }
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getClassLoader(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);
  return (jobject)cl->classLoader->getJavaClassLoader();
}

JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl1, jclass Cl2) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl1 = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl1);
  UserCommonClass* cl2 = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl2);

  cl2->resolveClass();
  return cl2->isAssignableFrom(cl1);

}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getSuperclass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);
  if (cl->isInterface())
    return 0;
  else {
    cl->resolveClass();
    if (cl->getSuper()) return (jobject)cl->getSuper()->getClassDelegatee(vm);
    else return 0;
  }
}

JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl, jobject obj) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = 
    (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);
  return ((JavaObject*)obj)->instanceOf(cl);
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredFields(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl, jboolean publicOnly) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass();

  if (!cl) {
    return (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm);
  } else {
    std::vector<JavaField*> res;
    cl->getDeclaredFields(res, publicOnly);
    
    ArrayObject* ret = 
      (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(res.size(), vm);
    sint32 index = 0;
    for (std::vector<JavaField*>::iterator i = res.begin(), e = res.end();
          i != e; ++i, ++index) {
      JavaField* field = *i;
      // TODO: check parameter types
      UserClass* Field = vm->upcalls->newField;
      JavaObject* tmp = Field->doNew(vm);
      vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl,
                                             vm->UTF8ToStr(field->name), field);
      ret->elements[index] = tmp;
    }
    return (jobject)ret;
  }
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getInterfaces(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
  std::vector<UserClass*> * interfaces = cl->getInterfaces();
  ArrayObject* ret = 
    (ArrayObject*)vm->upcalls->classArrayClass->doNew(interfaces->size(), vm);
  sint32 index = 0;
  for (std::vector<UserClass*>::iterator i = interfaces->begin(),
       e = interfaces->end(); i != e; ++i, ++index) {
    UserClass* klass = *i; 
    ret->elements[index] = klass->getClassDelegatee(vm);
  }
  return (jobject)ret;
}


JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getDeclaringClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass();
  if (cl) {
    cl->resolveInnerOuterClasses();
    UserClass* outer = cl->getOuterClass();
    if (outer) {
      return (jclass)outer->getClassDelegatee(vm);
    }
  }

  return 0;
}

JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl, bool publicOnly) {
  Jnjvm* vm = JavaThread::get()->isolate;
  UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass();
  if (cl) {
    cl->resolveInnerOuterClasses();
    std::vector<UserClass*>* innerClasses = cl->getInnerClasses();
    ArrayObject* res = 
      (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(innerClasses->size(), vm);
    uint32 index = 0;
    for (std::vector<UserClass*>::iterator i = innerClasses->begin(), 
         e = innerClasses->end(); i!= e; i++) {
      res->elements[index++] = (*i)->getClassDelegatee(vm); 
    }
    return (jobject)res;
  }

  return 0;

}


JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jobject throwable) {
  JavaThread::throwException((JavaObject*)throwable);
}

JNIEXPORT jobjectArray Java_java_lang_VMClass_getDeclaredAnnotations(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz, 
#endif
jclass Cl) {
  // TODO implement me
  Jnjvm* vm = JavaThread::get()->isolate;
  ArrayObject* res = (ArrayObject*)vm->upcalls->constructorArrayAnnotation->doNew(0, vm);
  return (jobjectArray)res;
}
}