#include <jni.h>
#include <cstdlib>
#include <iostream>
#include <string>

#include "simple.h"

namespace simple {

    JNIEnv *getEnv();
    static bool debug_j4cpp = false;

    namespace java {
        namespace lang {

            Object::Object() {
                jthis = NULL;
            };

            Object::Object(const Object &objref) {
                jobject _jthis = objref.jthis;
                if (_jthis != NULL) {
                    jthis = getEnv()->NewGlobalRef(_jthis);
                }
            };

            Object::Object(jobject _jthis, bool copy) {
                //                std::cout << "_jthis = " << _jthis << std::endl;
                jthis = NULL;
                if (_jthis != NULL) {
                    JNIEnv *env = getEnv();
                    jobjectRefType ref0 = env->GetObjectRefType(jthis);
                    if (copy || ref0 != JNIGlobalRefType) {
                        jthis = env->NewGlobalRef(_jthis);
                    }
                }
            };

            Object & Object::operator =(const Object &otherobject) {
                jobject oldjthis = jthis;
                jobject _newjthis = otherobject.jthis;
                jobject newjthis= NULL;
                jthis= NULL;
                JNIEnv *env = getEnv();
                if (_newjthis != NULL) {
                    if(debug_j4cpp) DebugPrintJObject(__FILE__,__LINE__,"Object::operator= called for _newjthis=",_newjthis);
                    newjthis = env->NewGlobalRef(_newjthis);
                }
                if (NULL != oldjthis) {
                    if(debug_j4cpp) DebugPrintJObject(__FILE__,__LINE__,"Object::operator= called for oldjthis=",oldjthis);
                    env->DeleteGlobalRef(oldjthis);
                    oldjthis = NULL;
                }
                jthis=newjthis;
                releaseEnv(env);
                return *this;
            }
            
            Object::~Object() {
                if (NULL != jthis) {
                    if(debug_j4cpp) DebugPrintJObject(__FILE__,__LINE__,"Destructor called for ",jthis);
                    getEnv()->DeleteGlobalRef(jthis);
                    jthis = NULL;
                }
            };

            jstring Object::toString() {

                if (jthis == NULL) {
                    std::cerr << "Call of method toString of java.lang.Object with jthis == NULL." << std::endl;
                    return NULL;
                }
                JNIEnv *env = getEnv();
                jobjectRefType ref0 = env->GetObjectRefType(jthis);
                if(debug_j4cpp) DebugPrintJObject(__FILE__,__LINE__," Object::toString() jthis=",jthis);
                jclass cls = env->GetObjectClass(jthis);
                jstring retVal = NULL;
                if (cls != NULL) {
                    jmethodID mid = env->GetMethodID(cls, "toString", "()Ljava/lang/String;");
                    if (NULL == mid) {
                        std::cerr << "Class ava.lang.Object has no method named toString with signature ()Ljava/lang/String;." << std::endl;
                        return NULL;
                    } else {
                        retVal = (jstring) env->CallObjectMethod(jthis, mid);
                    }
                }
                return retVal;
            }
        }
    }


 
 // get JNI handle for class Simple
 static inline jclass getSimpleClass();
 
 Simple::Simple(jobject _jthis, bool copy): java::lang::Object(_jthis,copy) {
         // Place holder for future extensibility
 }
 
 Simple::Simple(const Simple &objref): java::lang::Object((jobject)NULL,false) {
     jobject _jthis = objref.jthis;
     if(GetDebugJ4Cpp()) DebugPrintJObject(__FILE__,__LINE__,"Copy Constructor for class Simple _jthis=",_jthis);
     if (_jthis != NULL) {
         jthis = getEnv()->NewGlobalRef(_jthis);
         if(GetDebugJ4Cpp()) DebugPrintJObject(__FILE__,__LINE__,"Copy Constructor for class Simple jthis=",jthis);
     }
 }
 
 Simple Simple::cast(const java::lang::Object &objref) {
     JNIEnv *env =getEnv();
     static jclass cls = getSimpleClass(); 
     jclass objcls = env->GetObjectClass(objref.jthis);
     if(!env->IsAssignableFrom(objcls,cls)) {
         throw objcls;
     }
     Simple retVal(objref.jthis,true);
     return retVal;
 }
 Simple::Simple() : java::lang::Object((jobject)NULL,false) {
 JNIEnv *env =getEnv();
 static jclass cls = getSimpleClass();
 if (cls != NULL) {
     static jmethodID mid = env->GetMethodID(cls, "<init>", "()V");
     if (NULL == mid) {
         std::cerr << "Class Simple has no method constructor signature ()V" << std::endl;
     } else {
         jthis = env->NewObject(cls, mid );
         jthrowable t = env->ExceptionOccurred();
         if(t != NULL) {
             if(GetDebugJ4Cpp()) {
                 DebugPrintJObject(__FILE__,__LINE__," Simple::%METHOD_NAME% jthis=",t);
                 env->ExceptionDescribe();
             }
             throw t;
         }
         if(jthis == NULL) {
             std::cerr << "Call to create new Simple with signature ()V returned null." << std::endl;
             releaseEnv(env);
             return;
         }
         jobjectRefType ref = env->GetObjectRefType(jthis);
         if(GetDebugJ4Cpp()) DebugPrintJObject(__FILE__,__LINE__," new Simple jthis=",jthis);
         if(ref != JNIGlobalRefType) {
             jthis = env->NewGlobalRef(jthis);
         }
     }
 }
 releaseEnv(env);
 }

 Simple::Simple(jint int_0) : java::lang::Object((jobject)NULL,false) {
  JNIEnv *env =getEnv();
  static jclass cls = getSimpleClass();
  if (cls != NULL) {
      static jmethodID mid = env->GetMethodID(cls, "<init>", "(I)V");
      if (NULL == mid) {
          std::cerr << "Class Simple has no method constructor signature (I)V" << std::endl;
      } else {
          jthis = env->NewObject(cls, mid ,int_0);
          jthrowable t = env->ExceptionOccurred();
          if(t != NULL) {
              if(GetDebugJ4Cpp()) {
                  DebugPrintJObject(__FILE__,__LINE__," Simple::%METHOD_NAME% jthis=",t);
                  env->ExceptionDescribe();
              }
              throw t;
          }
          if(jthis == NULL) {
              std::cerr << "Call to create new Simple with signature (I)V returned null." << std::endl;
              releaseEnv(env);
              return;
          }
          jobjectRefType ref = env->GetObjectRefType(jthis);
          if(GetDebugJ4Cpp()) DebugPrintJObject(__FILE__,__LINE__," new Simple jthis=",jthis);
          if(ref != JNIGlobalRefType) {
              jthis = env->NewGlobalRef(jthis);
          }
      }
  }
  releaseEnv(env);
 }


 // Destructor for Simple
 Simple::~Simple() {
 	// Place-holder for later extensibility.
 }

 jint Simple::getValue() {

 if(jthis == NULL) {
     std::cerr << __FILE__ << ":" << __LINE__ <<" Call of method getValue of Simple with jthis == NULL." << std::endl;
     return (jint) -1;
 }
 JNIEnv *env =getEnv();
 jclass cls = env->GetObjectClass(jthis);
 if(GetDebugJ4Cpp()) DebugPrintJObject(__FILE__,__LINE__," Simple::getValue jthis=",jthis);
 jint retVal= (jint) -1;
 if (cls != NULL) {
     static jmethodID mid = env->GetMethodID(cls, "getValue", "()I");
     if (NULL == mid) {
         DebugPrintJObject(__FILE__,__LINE__," Simple::getValue jthis=",jthis);
         std::cerr << __FILE__ << ":" << __LINE__ <<  " Class Simple has no method named getValue with signature ()I." << std::endl;
         return (jint) -1;
     } else {
         retVal= (jint)  env->CallIntMethod(jthis, mid  );
         jthrowable t = env->ExceptionOccurred();
         if(t != NULL) {
             if(GetDebugJ4Cpp()) {
                 DebugPrintJObject(__FILE__,__LINE__," Simple::getValue jthrowable t=",t);
                 env->ExceptionDescribe();
             }
 //            env->ExceptionClear();
             throw t;
         }
     }
 }
 releaseEnv(env);
 return retVal;
 }
 static jclass getNewSimpleClass() {
     jclass clss = getEnv()->FindClass("Simple");
     if (NULL == clss) {
         std::cerr << " Can't find class Simple" << std::endl;
     }
     return clss;
 }
 
 static jclass SimpleClass = NULL;
 static inline jclass getSimpleClass() {
     if (SimpleClass != NULL) {
         return SimpleClass;
     }
     SimpleClass = getNewSimpleClass();
     return SimpleClass;
 }



    static JNIEnv *getNewEnv() {
        JavaVM *jvm; /* denotes a Java VM */
        JNIEnv *env; /* pointer to native method interface */
        JavaVM * jvmBuf[1];
        jsize nVMs;
        char *debugJ4CppEnv = NULL;
        char *classPathEnv = NULL;
        char *jvmOptionsEnv = NULL;
#if defined(_WIN32) || defined(_WIN64)
        errno_t errno_val;
        size_t requiredSize;
        errno_val =  getenv_s( &requiredSize, NULL, 0, "DEBUG_J4CPP");
        if(requiredSize > 0) {
            debugJ4CppEnv = (char *) malloc(requiredSize);
            errno_val =  getenv_s( &requiredSize, debugJ4CppEnv, requiredSize, "DEBUG_J4CPP");
        }
        errno_val =  getenv_s( &requiredSize, NULL, 0, "CLASSPATH");
        if(requiredSize > 0) {
            classPathEnv = (char *) malloc(requiredSize);
            errno_val =  getenv_s( &requiredSize, classPathEnv, requiredSize, "CLASSPATH");
        }
        errno_val =  getenv_s( &requiredSize, NULL, 0, "JVM_OPTIONS");
        if(requiredSize > 0) {
            jvmOptionsEnv = (char *) malloc(requiredSize);
            errno_val =  getenv_s( &requiredSize, jvmOptionsEnv, requiredSize, "JVM_OPTIONS");
        }
#else 
        debugJ4CppEnv = getenv("DEBUG_J4CPP");
        classPathEnv = getenv("CLASSPATH");
        jvmOptionsEnv = getenv("JVM_OPTIONS");
#endif
        debug_j4cpp = debug_j4cpp || (debugJ4CppEnv != NULL && debugJ4CppEnv[0] != 0);
        std::string str;
        str += "/home/shackle/java4cpp/examples/simple";
        if (classPathEnv != NULL) {
            std::string classPathEnvStr(classPathEnv);
            if (debug_j4cpp) std::cout << "classPathEnv=" << classPathEnvStr << std::endl;
            str += ":";
            str += classPathEnvStr;
        }
        if (debug_j4cpp) std::cout << "str=" << str << std::endl;
#if defined(_WIN32) || defined(_WIN64)
        _putenv_s("CLASSPATH", str.c_str());
#else
        setenv("CLASSPATH", str.c_str(), 1);
#endif
        std::string optsString;
        optsString += "-Djava.class.path=";
        optsString += str;
        if (jvmOptionsEnv != NULL) {
            std::string jvmOptionsEnvStr(jvmOptionsEnv);
            if (debug_j4cpp) std::cout << "jvmOptionsEnvStr=" << jvmOptionsEnvStr << std::endl;
            optsString += " ";
            optsString += jvmOptionsEnvStr;
        }
        if (debug_j4cpp) std::cout << "optsString=" << optsString << std::endl;
        jint v = JNI_GetCreatedJavaVMs(jvmBuf, 1, &nVMs);
        if (nVMs > 0) {
            jvmBuf[0]->GetEnv((void **) &env, JNI_VERSION_1_6);
            return env;
        }
        JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */
        JavaVMOption* options = new JavaVMOption[1];
        options[0].optionString = (char *) optsString.c_str();
        vm_args.version = JNI_VERSION_1_6;
        vm_args.nOptions = NULL != options[0].optionString ? 1 : 0;
        vm_args.options = options;
        vm_args.ignoreUnrecognized = false;
        /* load and initialize a Java VM, return a JNI interface
         * pointer in env */
        JNI_CreateJavaVM(&jvm,
                ((void **) (&env)),
                ((void *) (&vm_args)));
        delete options;
#if defined(_WIN32) || defined(_WIN64)
        if(debugJ4CppEnv != NULL) {
            free(debugJ4CppEnv);
            debugJ4CppEnv = NULL;
        }
        if(classPathEnv != NULL) {
            free(classPathEnv);
            classPathEnv = NULL;
        }
        if(jvmOptionsEnv != NULL) {
            free(jvmOptionsEnv);
            jvmOptionsEnv = NULL;
        }
#endif
        return env;
    }

    static JNIEnv *env = NULL;

    JNIEnv *getEnv() {
        if (env != NULL) {
            return env;
        }
        env = getNewEnv();
        return env;
    }

    void releaseEnv(JNIEnv *env) {
        // Maybe implement this later, 
        // This will probably cause a memory leak.
        // Don't like leaks? Why the hell are using C++?
    }

    static jclass getNewStringClass() {
        jclass clss = getEnv()->FindClass("java/lang/String");
        if (NULL == clss) {
            std::cerr << " Can't find class java/lang/String" << std::endl;
        }
        return clss;
    }

    static jclass StringClass = NULL;

    jclass getStringClass() {
        if (StringClass != NULL) {
            return StringClass;
        }
        StringClass = getNewStringClass();
        return StringClass;
    }

    static jclass getNewClassClass() {
        jclass clss = getEnv()->FindClass("java/lang/Class");
        if (NULL == clss) {
            std::cerr << " Can't find class java/lang/Class" << std::endl;
        }
        return clss;
    }

    static jclass ClassClass = NULL;

    jclass getClassClass() {
        if (ClassClass != NULL) {
            return ClassClass;
        }
        ClassClass = getNewStringClass();
        return ClassClass;
    }
    
    static jstring getNewEmptyString() {
        return getEnv()->NewStringUTF("");
    }

    static jstring EmptyString = NULL;

    jstring getEmptyString() {
        if (EmptyString != NULL) {
            return EmptyString;
        }
        EmptyString = getNewEmptyString();
        return EmptyString;
    }

    void PrintJObject(const char *prefix, jobject jobj) {
        if(NULL == jobj) {
            std::cout << prefix << "NULL" << std::endl;
            return;
        }
        JNIEnv *env = getEnv();
        jclass clss = env->GetObjectClass(jobj);
        jmethodID midToString = env->GetMethodID(clss, "toString", "()Ljava/lang/String;");
        jstring jobjstr = (jstring) env->CallObjectMethod(jobj, midToString);
        jboolean iscopy = JNI_FALSE;
        const char *cstr = env->GetStringUTFChars(jobjstr, &iscopy);
        std::cout << prefix << cstr << std::endl;
        env->ReleaseStringUTFChars(jobjstr,cstr);
    }
    
    void PrintJThrowable(const char *prefix, jthrowable jobj) {
        JNIEnv *env = getEnv();
        jclass clss = env->GetObjectClass(jobj);
        jmethodID midToString = env->GetMethodID(clss, "toString", "()Ljava/lang/String;");
        jstring jobjstr = (jstring) env->CallObjectMethod(jobj, midToString);
        jboolean iscopy = JNI_FALSE;
        const char *cstr = env->GetStringUTFChars(jobjstr, &iscopy);
        std::cerr << prefix << cstr << std::endl;
        env->ReleaseStringUTFChars(jobjstr,cstr);
        env->ExceptionDescribe();
        env->ExceptionClear();
    }
    
    void DebugPrintJObject(const char *file, int lineno, const char *prefix, jobject jobj) {
        
        if(NULL == jobj) {
            std::cout << file << ":" << lineno << " " << prefix << "NULL" << std::endl;
            return;
        }
        JNIEnv *env = getEnv();
        jclass clss = env->GetObjectClass(jobj);
        bool isnull = (jobj == NULL) || (env->IsSameObject(jobj,NULL) == JNI_TRUE);
        if(isnull) {
            std::cout << file << ":" << lineno << " jobj=" << jobj << " " << prefix << "NULL" << std::endl;
            return;
        }
        jmethodID midToString = env->GetMethodID(clss, "toString", "()Ljava/lang/String;");
        jstring jobjstr = (jstring) env->CallObjectMethod(jobj, midToString);
        jboolean iscopy = JNI_FALSE;
        const char *cstr = env->GetStringUTFChars(jobjstr, &iscopy);
        std::cout << file << ":" << lineno << " jobj=" << jobj << " " << prefix << cstr << std::endl;
        env->ReleaseStringUTFChars(jobjstr,cstr);
    }
    
    void PrintObject(const char *prefix, const ::simple::java::lang::Object &objref) {
        PrintJObject(prefix,objref.jthis);
    }
    
    extern void SetDebugJ4Cpp(bool debug) {
        debug_j4cpp = debug;
    }
    
    extern bool GetDebugJ4Cpp() { 
        return debug_j4cpp;
    }
    // end namespace simple
}