/*
 * Class:     sun_awt_shell_Win32ShellFolder2
 * Method:    initSpecial
 * Signature: (JI)V
 */
JNIEXPORT void JNICALL Java_sun_awt_shell_Win32ShellFolder2_initSpecial
    (JNIEnv* env, jobject folder, jlong desktopIShellFolder, jint folderType)
{
    // Get desktop IShellFolder interface
    IShellFolder* pDesktop = (IShellFolder*)desktopIShellFolder;
    if (pDesktop == NULL) {
        JNU_ThrowInternalError(env, "Desktop shell folder missing");
        return;
    }
    // Get special folder relative PIDL
    LPITEMIDLIST relPIDL;
    HRESULT res = fn_SHGetSpecialFolderLocation(NULL, folderType,
        &relPIDL);
    if (res != S_OK) {
        JNU_ThrowIOException(env, "Could not get shell folder ID list");
        return;
    }
    // Set field ID for relative PIDL
    env->CallVoidMethod(folder, MID_relativePIDL, (jlong)relPIDL);
    // Get special folder IShellFolder interface
    IShellFolder* pFolder;
    res = pDesktop->BindToObject(relPIDL, NULL, IID_IShellFolder,
        (void**)&pFolder);
    if (res != S_OK) {
        JNU_ThrowInternalError(env,
            "Could not bind shell folder to interface");
        return;
    }
    // Set field ID for pIShellFolder
    env->CallVoidMethod(folder, MID_pIShellFolder, (jlong)pFolder);
}

static void get_thread_state_info(JNIEnv *env, jint state,
                                      jobjectArray stateValues,
                                      jobjectArray stateNames) {
    char errmsg[128];
    jintArray values;
    jobjectArray names;

    values = (*GetThreadStateValues_fp)(env, state);
    if (values == NULL) {
        sprintf(errmsg, "Mismatched VM version: Thread state (%d) "
                        "not supported", state);
        JNU_ThrowInternalError(env, errmsg);
        return;
    }
    /* state is also used as the index in the array */
    (*env)->SetObjectArrayElement(env, stateValues, state, values);

    names = (*GetThreadStateNames_fp)(env, state, values);
    if (names == NULL) {
        sprintf(errmsg, "Mismatched VM version: Thread state (%d) "
                        "not supported", state);
        JNU_ThrowInternalError(env, errmsg);
        return;
    }
    (*env)->SetObjectArrayElement(env, stateNames, state, names);
}

int putGV(JNIEnv* env, jint gmask, jint baseIndex, jobject gvdata, const LayoutEngine* engine, int glyphCount) {
    int count = env->GetIntField(gvdata, gvdCountFID);

    jarray glyphArray = (jarray)env->GetObjectField(gvdata, gvdGlyphsFID);
    if (IS_NULL(glyphArray)) {
      JNU_ThrowInternalError(env, "glypharray null");
      return 0;
    }
    jint capacity = env->GetArrayLength(glyphArray);
    if (count + glyphCount > capacity) {
      JNU_ThrowArrayIndexOutOfBoundsException(env, "");
      return 0;
    }

    jarray posArray = (jarray)env->GetObjectField(gvdata, gvdPositionsFID);
    if (IS_NULL(glyphArray)) {
      JNU_ThrowInternalError(env, "positions array null");
      return 0;
    }
    jarray inxArray = (jarray)env->GetObjectField(gvdata, gvdIndicesFID);
    if (IS_NULL(inxArray)) {
      JNU_ThrowInternalError(env, "indices array null");
      return 0;
    }

    int countDelta = 0;

    // le_uint32 is the same size as jint... forever, we hope
    le_uint32* glyphs = (le_uint32*)env->GetPrimitiveArrayCritical(glyphArray, NULL);
    if (glyphs) {
      jfloat* positions = (jfloat*)env->GetPrimitiveArrayCritical(posArray, NULL);
      if (positions) {
        jint* indices = (jint*)env->GetPrimitiveArrayCritical(inxArray, NULL);
        if (indices) {
          LEErrorCode status = (LEErrorCode)0;
          engine->getGlyphs(glyphs + count, gmask, status);
          engine->getGlyphPositions(positions + (count * 2), status);
          engine->getCharIndices((le_int32*)(indices + count), baseIndex, status);

          countDelta = glyphCount;

          // !!! need engine->getFlags to signal positions, indices data
          /* "0" arg used instead of JNI_COMMIT as we want the carray
           * to be freed by any VM that actually passes us a copy.
           */
          env->ReleasePrimitiveArrayCritical(inxArray, indices, 0);
        }
        env->ReleasePrimitiveArrayCritical(posArray, positions, 0);
      }
      env->ReleasePrimitiveArrayCritical(glyphArray, glyphs, 0);
    }

    if (countDelta) {
      count += countDelta;
      env->SetIntField(gvdata, gvdCountFID, count);
    }

  return 1;
}

JNIEXPORT jlong JNICALL
Java_java_util_zip_Inflater_init(JNIEnv *env, jclass cls, jboolean nowrap)
{
    z_stream *strm = calloc(1, sizeof(z_stream));

    if (strm == NULL) {
        JNU_ThrowOutOfMemoryError(env, 0);
        return jlong_zero;
    } else {
        const char *msg;
        int ret = inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS);
        switch (ret) {
          case Z_OK:
            return ptr_to_jlong(strm);
          case Z_MEM_ERROR:
            free(strm);
            JNU_ThrowOutOfMemoryError(env, 0);
            return jlong_zero;
          default:
            msg = ((strm->msg != NULL) ? strm->msg :
                   (ret == Z_VERSION_ERROR) ?
                   "zlib returned Z_VERSION_ERROR: "
                   "compile time and runtime zlib implementations differ" :
                   (ret == Z_STREAM_ERROR) ?
                   "inflateInit2 returned Z_STREAM_ERROR" :
                   "unknown error initializing zlib library");
            free(strm);
            JNU_ThrowInternalError(env, msg);
            return jlong_zero;
        }
    }
}

/**
 * This is the implementation of the general GetRasInfoFunc defined in
 * SurfaceData.h.
 */
void
OGLSD_GetRasInfo(JNIEnv *env,
                 SurfaceDataOps *ops,
                 SurfaceDataRasInfo *pRasInfo)
{
    JNU_ThrowInternalError(env, "OGLSD_GetRasInfo not implemented!");
}

/**
 * This is the implementation of the general surface UnlockFunc defined in
 * SurfaceData.h.
 */
void
D3DSD_Unlock(JNIEnv *env,
             SurfaceDataOps *ops,
             SurfaceDataRasInfo *pRasInfo)
{
    JNU_ThrowInternalError(env, "D3DSD_Unlock not implemented!");
}

JNIEXPORT jlong JNICALL
Java_java_util_zip_Deflater_init(JNIEnv *env, jclass cls, jint level,
				 jint strategy, jboolean nowrap)
{
    z_stream *strm = calloc(1, sizeof(z_stream));

    if (strm == 0) {
	JNU_ThrowOutOfMemoryError(env, 0);
	return jlong_zero;
    } else {
	char *msg;
	switch (deflateInit2(strm, level, Z_DEFLATED,
			     nowrap ? -MAX_WBITS : MAX_WBITS,
			     DEF_MEM_LEVEL, strategy)) {
	  case Z_OK:
	    return ptr_to_jlong(strm);
	  case Z_MEM_ERROR:
	    free(strm);
	    JNU_ThrowOutOfMemoryError(env, 0);
	    return jlong_zero;
	  case Z_STREAM_ERROR:
	    free(strm);
	    JNU_ThrowIllegalArgumentException(env, 0);
	    return jlong_zero;
	  default:
	    msg = strm->msg;
	    free(strm);
	    JNU_ThrowInternalError(env, msg);
	    return jlong_zero;
	}
    }
}

JNIEXPORT jint JNICALL
Java_sun_nio_ch_InheritedChannel_open0(JNIEnv *env, jclass cla, jstring path, jint oflag)
{
    const char* str;
    int oflag_actual;

    /* convert to OS specific value */
    switch (oflag) {
        case sun_nio_ch_InheritedChannel_O_RDWR :
            oflag_actual = O_RDWR;
            break;
        case sun_nio_ch_InheritedChannel_O_RDONLY :
            oflag_actual = O_RDONLY;
            break;
        case sun_nio_ch_InheritedChannel_O_WRONLY :
            oflag_actual = O_WRONLY;
            break;
        default :
            JNU_ThrowInternalError(env, "Unrecognized file mode");
            return -1;
    }

    str = JNU_GetStringPlatformChars(env, path, NULL);
    if (str == NULL) {
        return (jint)-1;
    } else {
        int fd = open(str, oflag_actual);
        if (fd < 0) {
            JNU_ThrowIOExceptionWithLastError(env, str);
        }
        JNU_ReleaseStringPlatformChars(env, path, str);
        return (jint)fd;
    }
}

JNIEXPORT jobject JNICALL Java_sun_management_MemoryManagerImpl_getMemoryPools0
(JNIEnv *env, jobject mgr) {
    jobject pools = jmm_interface->GetMemoryPools(env, mgr);
    if (pools == NULL) {
        JNU_ThrowInternalError(env, "Memory Manager not found");
    }
    return pools;
}

/**
 * This is the implementation of the general surface LockFunc defined in
 * SurfaceData.h.
 */
jint
D3DSD_Lock(JNIEnv *env,
           SurfaceDataOps *ops,
           SurfaceDataRasInfo *pRasInfo,
           jint lockflags)
{
    JNU_ThrowInternalError(env, "D3DSD_Lock not implemented!");
    return SD_FAILURE;
}

JNIEXPORT void JNICALL
Java_sun_misc_VM_getThreadStateValues(JNIEnv *env, jclass cls,
                                      jobjectArray values,
                                      jobjectArray names)
{
    char errmsg[128];

    // check if the number of Thread.State enum constants
    // matches the number of states defined in jvm.h
    jsize len1 = (*env)->GetArrayLength(env, values);
    jsize len2 = (*env)->GetArrayLength(env, names);
    if (len1 != JAVA_THREAD_STATE_COUNT || len2 != JAVA_THREAD_STATE_COUNT) {
        sprintf(errmsg, "Mismatched VM version: JAVA_THREAD_STATE_COUNT = %d "
                " but JDK expects %d / %d",
                JAVA_THREAD_STATE_COUNT, len1, len2);
        JNU_ThrowInternalError(env, errmsg);
        return;
    }

    if (GetThreadStateValues_fp == NULL) {
        GetThreadStateValues_fp = (GET_THREAD_STATE_VALUES_FN)
            JDK_FindJvmEntry("JVM_GetThreadStateValues");
        if (GetThreadStateValues_fp == NULL) {
            JNU_ThrowInternalError(env,
                 "Mismatched VM version: JVM_GetThreadStateValues not found");
            return;
        }

        GetThreadStateNames_fp = (GET_THREAD_STATE_NAMES_FN)
            JDK_FindJvmEntry("JVM_GetThreadStateNames");
        if (GetThreadStateNames_fp == NULL) {
            JNU_ThrowInternalError(env,
                 "Mismatched VM version: JVM_GetThreadStateNames not found");
            return ;
        }
    }

    get_thread_state_info(env, JAVA_THREAD_STATE_NEW, values, names);
    get_thread_state_info(env, JAVA_THREAD_STATE_RUNNABLE, values, names);
    get_thread_state_info(env, JAVA_THREAD_STATE_BLOCKED, values, names);
    get_thread_state_info(env, JAVA_THREAD_STATE_WAITING, values, names);
    get_thread_state_info(env, JAVA_THREAD_STATE_TIMED_WAITING, values, names);
    get_thread_state_info(env, JAVA_THREAD_STATE_TERMINATED, values, names);
}

/*
* Class:     sun_awt_shell_Win32ShellFolderManager2
* Method:    initializeCom
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_sun_awt_shell_Win32ShellFolderManager2_initializeCom
        (JNIEnv* env, jclass cls)
{
    HRESULT hr = ::CoInitialize(NULL);
    if (FAILED(hr)) {
        char c[64];
        sprintf(c, "Could not initialize COM: HRESULT=0x%08X", hr);
        JNU_ThrowInternalError(env, c);
    }
}

/*
 * Class:     sun_awt_X11RemoteOffScreenImage
 * Method:    initIDs
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_sun_awt_motif_X11RemoteOffScreenImage_initIDs(JNIEnv *env, jclass bisd)
{
    static char *bimgName = "java/awt/image/BufferedImage";
    jclass bimg = (*env)->FindClass(env, bimgName);
    if (JNU_IsNull(env, bimg)) {
	JNU_ThrowClassNotFoundException(env, bimgName);
	return;
    }
    sDataID = (*env)->GetFieldID(env, bimg, "sData", "Lsun/java2d/SurfaceData;");
    if (sDataID == 0) {
	JNU_ThrowInternalError(env, "Could not get field IDs");
    }

    rasterID = (*env)->GetFieldID(env, bimg, "raster", "Ljava/awt/image/WritableRaster;");
    if (rasterID == 0) {
	JNU_ThrowInternalError(env, "Could not get field IDs");
    }
}

JNIEXPORT jobject JNICALL
Java_sun_misc_VMSupport_initAgentProperties(JNIEnv *env, jclass cls, jobject props)
{
    char errmsg[128];

    if (InitAgentProperties_fp == NULL) {
        if (!JDK_InitJvmHandle()) {
            JNU_ThrowInternalError(env,
                 "Handle for JVM not found for symbol lookup");
        }
        InitAgentProperties_fp = (INIT_AGENT_PROPERTIES_FN)
            JDK_FindJvmEntry("JVM_InitAgentProperties");
        if (InitAgentProperties_fp == NULL) {
            JNU_ThrowInternalError(env,
                 "Mismatched VM version: JVM_InitAgentProperties not found");
            return NULL;
        }
    }
    return (*InitAgentProperties_fp)(env, props);
}

static int
initFieldIDs(JNIEnv *env, jobject process, jobject fd) {
    jclass tmpC;

    if (field_exitcode != 0) return 0;

    tmpC = (*env)->GetObjectClass(env, process);;
    field_exitcode = (*env)->GetFieldID(env, tmpC, "exitcode", "I");
    if (field_exitcode == 0) {
	JNU_ThrowInternalError(env, "Can't find field UNIXProcess.exitcode");
	return -1;
    }
    tmpC = (*env)->GetObjectClass(env, fd);
    field_fd = (*env)->GetFieldID(env, tmpC, "fd", "I");
    if (field_fd == 0) {
	JNU_ThrowInternalError(env, "Can't find field FileDescriptor.fd");
	field_exitcode = 0;
	return -1;
    }
    return 0;
}

JNIEXPORT NativePrimitive * JNICALL
GetNativePrim(JNIEnv *env, jobject gp)
{
    NativePrimitive *pPrim;

    pPrim = (NativePrimitive *) JNU_GetLongFieldAsPtr(env, gp, pNativePrimID);
    if (pPrim == NULL) {
        JNU_ThrowInternalError(env, "Non-native Primitive invoked natively");
    }

    return pPrim;
}

    /*
     * Class:     sun_awt_shell_Win32ShellFolder
     * Method:    initFile
     * Signature: (JLjava/lang/String;Z)J
     */
    JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder_initFile
    (JNIEnv* env, jobject folder, jlong desktopIShellFolder,
     jstring absolutePath, jboolean initAttributes)
    {
        // Get desktop IShellFolder interface
        IShellFolder* pDesktop = (IShellFolder*)desktopIShellFolder;
        if (pDesktop == NULL) {
            JNU_ThrowInternalError(env, "Desktop shell folder missing");
            return 0;
        }
        // Get PIDL for file from desktop
        LPITEMIDLIST pIDL;
        int nLength = env->GetStringLength(absolutePath);
        jchar* wszPath = new jchar[nLength + 1];
        const jchar* strPath = env->GetStringChars(absolutePath, NULL);
        wcsncpy(wszPath, strPath, nLength);
        wszPath[nLength] = 0;
        HRESULT res = pDesktop->ParseDisplayName(NULL, NULL,
                      const_cast<jchar*>(wszPath), NULL, &pIDL, NULL);
        if (res != S_OK) {
            JNU_ThrowIOException(env, "Could not parse file path");
            delete[] wszPath;
            env->ReleaseStringChars(absolutePath, strPath);
            return 0;
        }
        delete[] wszPath;
        env->ReleaseStringChars(absolutePath, strPath);

        // Get display name, folder type, and possibly attributes
        SHFILEINFO fileInfo;
        UINT flags;

        if (initAttributes) {
            flags = SHGFI_ATTRIBUTES | SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_PIDL;
        } else {
            flags = SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_PIDL;
        }

        if (fn_SHGetFileInfo((char *)pIDL, 0L, &fileInfo, sizeof(fileInfo), flags) != 0) {

            if (initAttributes) {
                env->SetLongField(folder, FID_attributes, (jlong)fileInfo.dwAttributes);
            }

            env->SetObjectField(folder, FID_displayName,
                                JNU_NewStringPlatform(env, fileInfo.szDisplayName));

            env->SetObjectField(folder, FID_folderType,
                                JNU_NewStringPlatform(env, fileInfo.szTypeName));
        }
        return (jlong)pIDL;
    }

JNIEXPORT void JNICALL
SurfaceData_SetOps(JNIEnv *env, jobject sData, SurfaceDataOps *ops)
{
    if (JNU_GetLongFieldAsPtr(env, sData, pDataID) == NULL) {
        JNU_SetLongFieldFromPtr(env, sData, pDataID, ops);
        /* Register the data for disposal */
        Disposer_AddRecord(env, sData,
                           SurfaceData_DisposeOps,
                           ptr_to_jlong(ops));
    } else {
        JNU_ThrowInternalError(env, "Attempting to set SurfaceData ops twice");
    }
}

/*
 * Class:     sun_awt_shell_Win32ShellFolder2
 * Method:    initDesktop
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_sun_awt_shell_Win32ShellFolder2_initDesktop
    (JNIEnv* env, jobject desktop)
{
    // Get desktop IShellFolder
    HRESULT res = fn_SHGetDesktopFolder(&pDesktop);
    if (res != S_OK) {
        JNU_ThrowInternalError(env, "Could not get desktop shell folder");
        return;
    }
    // Set field ID for pIShellFolder
    env->CallVoidMethod(desktop, MID_pIShellFolder, (jlong)pDesktop);
    // Get desktop relative PIDL
    LPITEMIDLIST relPIDL;
    res = fn_SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &relPIDL);
    if (res != S_OK) {
        JNU_ThrowInternalError(env,
            "Could not get desktop shell folder ID list");
        return;
    }
    // Set field ID for relative PIDL
    env->CallVoidMethod(desktop, MID_relativePIDL, (jlong)relPIDL);
}

/*
 * Class:     sun_tools_attach_WindowsVirtualMachine
 * Method:    init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_sun_tools_attach_WindowsVirtualMachine_init
  (JNIEnv *env, jclass cls)
{
    HINSTANCE h = LoadLibrary("kernel32");
    if (h != NULL) {
        _LoadLibrary = (LoadLibraryFunc) GetProcAddress(h, "LoadLibraryA");
        _GetProcAddress = (GetProcAddressFunc)GetProcAddress(h, "GetProcAddress");
        _IsWow64Process = (IsWow64ProcessFunc)GetProcAddress(h, "IsWow64Process");
    }
    if (_LoadLibrary == NULL || _GetProcAddress == NULL) {
        JNU_ThrowInternalError(env, "Unable to get address of LoadLibraryA or GetProcAddress");
    }
}