/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "libzfs_jni_disk.h"

/*
 * Function prototypes
 */

static jobject create_DiskDeviceBean(JNIEnv *, dmgt_disk_t *);
static jobject get_SliceUsage_Use(JNIEnv *, char *);
static jobject create_SliceUsage(JNIEnv *env, dmgt_slice_t *sp);
static jobject create_SliceDeviceBean(JNIEnv *env, dmgt_slice_t *sp);
static jobjectArray create_SliceDeviceBean_array(JNIEnv *, dmgt_slice_t **);

/*
 * Static functions
 */

static jobject
create_DiskDeviceBean(JNIEnv *env, dmgt_disk_t *dp)
{
        jobject disk = NULL;

        int naliases = zjni_count_elements((void **)dp->aliases);
        jobjectArray aliases = zjni_c_string_array_to_java(
            env, dp->aliases, naliases);
        if (aliases != NULL) {
                jobjectArray slices = create_SliceDeviceBean_array(env,
                    dp->slices);
                if (slices != NULL) {
                        jstring nameUTF = (*env)->NewStringUTF(env, dp->name);

                        jboolean in_use = dp->in_use ? JNI_TRUE : JNI_FALSE;

                        jclass class_DiskDeviceBean = (*env)->FindClass(
                            env, ZFSJNI_PACKAGE_DATA "DiskDeviceBean");

                        jmethodID constructor =
                            (*env)->GetMethodID(env, class_DiskDeviceBean,
                                "<init>",
                                "(JLjava/lang/String;[Ljava/lang/String;[L"
                                ZFSJNI_PACKAGE_DATA "SliceDeviceBean;Z)V");

                        disk = (*env)->NewObject(env, class_DiskDeviceBean,
                            constructor, dp->size, nameUTF, aliases, slices,
                            in_use);
                }
        }

        return (disk);
}

static jobject
get_SliceUsage_Use(JNIEnv *env, char *dm_usage)
{
        jobject enumVal = NULL;

        if (dm_usage != NULL) {
                jclass class_SliceUsage_Use = (*env)->FindClass(
                    env, ZFSJNI_PACKAGE_DATA "SliceUsage$Use");

                jfieldID id = (*env)->GetStaticFieldID(env,
                    class_SliceUsage_Use,
                    dm_usage, "L" ZFSJNI_PACKAGE_DATA "SliceUsage$Use;");

                if (id != NULL) {
                        /* Retrieve the proper SliceUsage$Use enum value */
                        enumVal = (*env)->GetStaticObjectField(
                            env, class_SliceUsage_Use, id);
#ifdef  DEBUG
                } else {
                        (void) fprintf(stderr, "Unknown slice usage: %s\n",
                            dm_usage);
#endif /* DEBUG */
                }
        }

        return (enumVal);
}

static jobject
create_SliceUsage(JNIEnv *env, dmgt_slice_t *sp)
{
        jobject usage = NULL;
        if (sp->used_name != NULL) {
                jobject use = get_SliceUsage_Use(env, sp->used_name);

                if (use != NULL) {
                        jstring usedByUTF =
                            (*env)->NewStringUTF(env, sp->used_by);

                        jclass class_SliceUsage = (*env)->FindClass(
                            env, ZFSJNI_PACKAGE_DATA "SliceUsage");

                        jmethodID constructor =
                            (*env)->GetMethodID(env, class_SliceUsage, "<init>",
                                "(L" ZFSJNI_PACKAGE_DATA
                                "SliceUsage$Use;Ljava/lang/String;)V");

                        usage = (*env)->NewObject(env,
                            class_SliceUsage, constructor, use, usedByUTF);
                }
        }

        return (usage);
}

static jobject
create_SliceDeviceBean(JNIEnv *env, dmgt_slice_t *sp)
{
        jobject slice = NULL;

        /* May be NULL if unused */
        jobject usage = create_SliceUsage(env, sp);

        jstring nameUTF = (*env)->NewStringUTF(env, sp->name);

        jclass class_SliceDeviceBean = (*env)->FindClass(
            env, ZFSJNI_PACKAGE_DATA "SliceDeviceBean");

        jmethodID constructor =
            (*env)->GetMethodID(env, class_SliceDeviceBean, "<init>",
                "(JLjava/lang/String;JL" ZFSJNI_PACKAGE_DATA "SliceUsage;)V");

        slice = (*env)->NewObject(env, class_SliceDeviceBean,
            constructor, sp->size, nameUTF, sp->start, usage);

        return (slice);
}

static jobjectArray
create_SliceDeviceBean_array(JNIEnv *env, dmgt_slice_t **slices)
{
        /* Create an array list */
        zjni_ArrayList_t list_class = {0};
        zjni_ArrayList_t *list_class_p = &list_class;
        zjni_new_ArrayList(env, list_class_p);

        if (slices != NULL) {
                int i;
                for (i = 0; slices[i] != NULL; i++) {
                        dmgt_slice_t *slice = slices[i];
                        jobject obj;
                        obj = create_SliceDeviceBean(env, slice);
                        if (obj != NULL) {
                                (*env)->CallBooleanMethod(env,
                                    ((zjni_Object_t *)list_class_p)->object,
                                    ((zjni_Collection_t *)list_class_p)->
                                    method_add, obj);
                        }
                }
        }

        return (zjni_Collection_to_array(
            env, (zjni_Collection_t *)list_class_p,
            ZFSJNI_PACKAGE_DATA "SliceDeviceBean"));
}

/*
 * Package-private functions
 */

int
zjni_create_add_DiskDevice(dmgt_disk_t *dp, void *data)
{
        JNIEnv *env = ((zjni_ArrayCallbackData_t *)data)->env;
        zjni_Collection_t *list = ((zjni_ArrayCallbackData_t *)data)->list;
        jobject disk = create_DiskDeviceBean(env, dp);

        /* Add disk to zjni_ArrayList */
        (*env)->CallBooleanMethod(env, ((zjni_Object_t *)list)->object,
            ((zjni_Collection_t *)list)->method_add, disk);

        return (0);
}