/**
 * Opens a file and fills the content of the file in the result_buf. <BR>
 * This function made memory allocation inside.
 *
 * @param filename   Path to the file.
 * @param result_buf Pointer to the buffer that will be filled by content of the file.
 * @return buffer file size in bytes
 */
long readJadFile(const pcsl_string * filename, char** result_buf) {
    int fd = 0;
    char* err = NULL;
    long bufsize = -1;
    int numread = 0;
    char* res = *result_buf;

    if (pcsl_string_length(filename) <= 0) {
        REPORT_INFO(LC_AMS, "readJadFile():No file name.");
        return BAD_PARAMS;
    }

    fd = storage_open(&err, filename, OPEN_READ);
    if(err != NULL) {
        REPORT_INFO1(LC_AMS, "readJadFile():Can't open jad file '%s'",err);
        storageFreeError(err);
        return NO_JAD_FILE;
    }

    bufsize = storageSizeOf(&err, fd);
    if((bufsize <= 0) || (err != NULL)) {
        REPORT_INFO1(LC_AMS,  "readJadFile():Problem getting file size: %s",
		     err );
        storageFreeError(err);
        return IO_ERROR;
    }

    res = (char*)midpMalloc(bufsize+1);
    if (res == NULL || (err != NULL)) {
        REPORT_INFO1(LC_AMS, "readJadFile():Can't allocate memory. %s", err);
        storageFreeError(err);
        return OUT_OF_MEMORY;
    }

    memset(res,0,(bufsize+1));

    REPORT_INFO2(LC_AMS, "fd = %d, bufsize = %ld\n", fd, bufsize);

    numread = storageRead(&err, fd, res, bufsize);
    if((numread <= 0) || (numread != bufsize) || (err)) {
        REPORT_INFO3(LC_AMS, "size = %ld, numread = %d, err = %s.",
               bufsize, numread, err);
        storageClose(&err, fd);
        return IO_ERROR;
    }

    REPORT_INFO2(LC_AMS, "size = %ld, numread = %d", bufsize, numread);

    storageClose(&err, fd);
    if(err != NULL) {
        REPORT_INFO1(LC_AMS, "Can't close jad file %s\n", err);
    }
    *result_buf = res;
    return bufsize;
} /* end of readJadFile */

void
printPcslStringWithMessageImpl(char* message, const pcsl_string* pstr) {
    char* tag;

    if ((pcsl_string_length(pstr) <= 0) && (!message)) {
        REPORT_INFO(LC_MIDPSTRING,
		    "printPcslStringWithMessage() No input");
        return;
    }

    if (message) {
        tag = message;
    } else {
        tag = "message = NULL:";
    }

    if (pcsl_string_length(pstr) > 0) {
        const char* msg = pcsl_string_get_utf8_data(pstr);
        if (msg) {
            REPORT_INFO2(LC_MIDPSTRING, "%s: %s", tag, msg);
            pcsl_string_release_utf8_data(msg, pstr);
        } else {
           REPORT_INFO1(LC_MIDPSTRING,
	        "%s: printPcslStringWithMessage can't convert pcsl_string to char*", tag);
        }
    } else {
        REPORT_INFO2(LC_MIDPSTRING, "%s: pcsl_string is %s", tag,
            0 == pcsl_string_length(pstr) ? "empty" : "null" );
    }
}

/**
 * Prints a <tt>MidpString</tt> with a given message. A new line will
 * be emitted after <tt>mstr</tt>.  This output goes to the log in cases
 * were the log service defined <code>REPORT_LEVEL <= LOG_INFORMATION</code>
 * conditional is true.
 *
 * @param message the specified message to print 
 * @param mstr the <tt>MidpString</tt> to print
 */
void
printMidpStringWithMessageImpl(char* message, MidpString mstr) {
    char* msg = NULL;
    char* tag;

    if ((mstr.len <= 0) && (!message)) {
              REPORT_INFO(LC_MIDPSTRING, 
		    "printMidpString() No input");
        return;
    }

    if (message) {
        tag = message;
    } else {
        tag = "message = NULL:";
    }

    if (mstr.len > 0) {
        msg = midpJcharsToChars(mstr);
        if (msg) {
          REPORT_INFO2(LC_MIDPSTRING, "%s: %s", tag, msg);
	    midpFree(msg);
        } else {
            REPORT_INFO1(LC_MIDPSTRING, 
	        "%s: printMidpString can't convert MidpString to char*",tag);
        }
    }
}

javacall_result bt_push_unregister_url(const char *url)
{
    bt_port_t port;
    bt_push_t *push, *prev;
    REPORT_INFO(LC_PUSH, "Bluetooth PushRegistry URL un-registration:");
    REPORT_INFO1(LC_PUSH, "%s", url);
    bt_push_parse_url(url, &port, NULL);
    push = find_push(&port, &prev);
    if (push == NULL) {
        return JAVACALL_FAIL;
    }
    /* remove the service record */
    javacall_bt_sddb_remove_record(push->record.id);
    /* close server and client connections */
    close_all(push);
    /* remove the entry */
    if (prev != NULL) {
        prev->next = push->next;
    } else {
        g_registry = push->next;
    }
    g_count--;
    pcsl_mem_free(push);
    push_save();
    javacall_bt_stack_set_service_classes(javacall_bt_sddb_get_service_classes(0));
    REPORT_INFO(LC_PUSH, "Un-registration successful.");
    return JAVACALL_OK;
}

/*
 * Return the amount of free bytes of file storage.
 * The maximum amount of free space is limited by the value set with
 * the <tt>storageSetTotalSpace</tt> method.
 *
 * @param storageId ID of the storage to check for free space
 */
jlong
storage_get_free_space(StorageIdType storageId) {
    jlong freeSpace;
    jlong usedSpace;

    if (storageId < 0 || storageId >= MAX_STORAGE_NUM) {
        return 0; /* Invalid storage ID: no free space available */
    }

    usedSpace = pcsl_file_getusedspace(&sRoot[storageId]);

    if (usedSpace == -1) { /* PCSL error */
        return 0; /* No free space available */
    }

    if (totalSpace > usedSpace) {
        freeSpace = totalSpace - usedSpace;
    } else {
        freeSpace = 0;
    }

    REPORT_INFO1(LC_CORE, "Free space = %ld\n", freeSpace);

    return freeSpace;
}

/**
 * A notification function for telling Java to perform installation of
 * a MIDletl,
 * 
 * 
 * If the given url is of the form http://www.sun.com/a/b/c/d.jad then
 * java will start a graphical installer will download the MIDlet
 * fom the internet.
 * If the given url is a file url (see below, file:///a/b/c/d.jar or
 * file:///a/b/c/d/jad) installation will be performed 
 * in the backgroudn without launching the graphic installer application
 * 
 *
 * @param url of MIDlet to install, can be either one of the following
 *   1. A full path to the jar file, of the following form file:///a/b/c/d.jar
 *   2. A full path to the JAD file, of the following form file:///a/b/c/d.jad
 *   3. An http url of jad file, of the following form,
 *      http://www.sun.com/a/b/c/d.jad
 * 
 */
void javanotify_install_midlet(const char *httpUrl) {
    int length;
    midp_jc_event_union e;
    midp_jc_event_start_arbitrary_arg *data = &e.data.startMidletArbitraryArgEvent;

    REPORT_INFO1(LC_CORE,"javanotify_install_midlet() >> httpUrl=%s\n",httpUrl);

    e.eventType = MIDP_JC_EVENT_START_ARBITRARY_ARG;

    data->argc = 0;
    data->argv[data->argc++] = "runMidlet";
    data->argv[data->argc++] = "-1";
    data->argv[data->argc++] = "com.sun.midp.installer.GraphicalInstaller";
    data->argv[data->argc++] = "I";

    length = strlen(httpUrl);
    if (length >= BINARY_BUFFER_MAX_LEN)
        return;

    memset(urlAddress, 0, BINARY_BUFFER_MAX_LEN);
    memcpy(urlAddress, httpUrl, length);
    data->argv[data->argc++] = urlAddress;

    midp_jc_event_send(&e);
}

/**
 * Create the native peer of a DateField.
 * Upon successful return, *datefieldPtr should be filled in properly.
 * Param time is number of milliseconds since the standard base time known as
 * "the epoch", namely January 1, 1970, 00:00:00 GMT.
 * (defined in midp_datefield.h)
 */
extern "C" MidpError
lfpport_datefield_create(MidpItem* datefieldPtr,
			 MidpDisplayable* formPtr,
			 const pcsl_string* label, int layout,
			 int input_mode, long time, const pcsl_string* timezoneID)
{
  QString qlabel, qtzone;

  TRACE_DF(lfpport_datefield_Create);

  REPORT_INFO1(LC_HIGHUI, "\tinput_mode=%d\n", input_mode);

  pcsl_string2QString(*label, qlabel);
  pcsl_string2QString(*timezoneID, qtzone);

  // Fill in MidpItem structure
  datefieldPtr->widgetPtr = 
    new DateField((formPtr == INVALID_NATIVE_ID ? 
		   0 : (QWidget *)formPtr->frame.widgetPtr),
		  qlabel,
		  layout,
		  time,
		  input_mode,
		  qtzone);

  initItemPtr(datefieldPtr, formPtr);

  return KNI_OK;
}

int testReadJadFile_2(void) {
    int    jadsize   =  0;
    char*  jad_buf   =  NULL;
    char*  jad       =  "../../../src/common/native/share/unittests/no_such_a_file.jad";
    int    res       =  NO_JAD_FILE;
    MidpString jadURL = {0,NULL};

    REPORT_INFO(LC_AMS, "#############  This test should fail. Trying to load file that doesn't exist.\n");
    jadURL = midpCharsToJchars(jad);
    jadsize = (int)readJadFile (jadURL, &jad_buf);
    if ((jadsize <= 0) || (!jad_buf)) {
        REPORT_WARN1(LC_AMS, "\nCan't open JAD file %s\n", jad);
        res = ALL_OK;
    } else {
        REPORT_INFO1(LC_AMS, "JAD content is:\n%s\n", jad_buf);
    }

    midpFreeString(jadURL);

    if (jad_buf) {
        midpFree(jad_buf);
    } /* end of if */

    return res;
} /* testReadJadFile_2 */

int testReadJadFile_1(void) {
    int    jadsize   =  0;
    char*  jad_buf   =  NULL;
    char*  jad       =  "../../../src/common/native/share/unittests/jad1.jad";
    int    res       =  ALL_OK;
    MidpString jadURL = {0,NULL};

    REPORT_INFO(LC_AMS, "############# This test should pass.");
    jadURL = midpCharsToJchars(jad);
    jadsize = (int)readJadFile (jadURL, &jad_buf);
    if ((jadsize <= 0) || (!jad_buf)) {
        REPORT_WARN1(LC_AMS, "Can't open JAD file %s", jad);
        res = NO_JAD_FILE;
    } else {
        REPORT_INFO1(LC_AMS, "JAD content is:\n%s\n", jad_buf);
    }

    midpFreeString(jadURL);

    if (jad_buf) {
        midpFree(jad_buf);
    } /* end of if */

    return res;
} /* testReadJadFile_1 */

/**
 * A notification function for telling Java to perform installation of
 * a MIDlet
 *
 * If the given url is of the form http://www.sun.com/a/b/c/d.jad then
 * java will start a graphical installer will download the MIDlet
 * fom the internet.
 * If the given url is a file url (see below, file:///a/b/c/d.jar or
 * file:///a/b/c/d/jad) installation will be performed
 * in the backgroudn without launching the graphic installer application
 *
 *
 * @param url of MIDlet to install, can be either one of the following
 *   1. A full path to the jar file, of the following form file:///a/b/c/d.jar
 *   2. A full path to the JAD file, of the following form file:///a/b/c/d.jad
 *   3. An http url of jad file, of the following form,
 *      http://www.sun.com/a/b/c/d.jad
 */
void javanotify_install_midlet(const char *httpUrl) {
    int length;
    int argc = 0;
    char *argv[MIDP_RUNMIDLET_MAXIMUM_ARGS];
    javacall_result res;

    REPORT_INFO1(LC_CORE,"javanotify_install_midlet() >> httpUrl = %s\n", httpUrl);

    if (initialize_memory_slavemode() != JAVACALL_OK) {
        return;
    }

    argv[argc++] = "runMidlet";
    argv[argc++] = "-1";
    argv[argc++] = "com.sun.midp.installer.GraphicalInstaller";
    argv[argc++] = "I";

    length = strlen(httpUrl);
    if (length >= BINARY_BUFFER_MAX_LEN){
        REPORT_ERROR(LC_AMS, "javanotify_install_midlet(): httpUrl is too long\n");
        return;
    }

    memset(urlAddress, 0, BINARY_BUFFER_MAX_LEN);
    memcpy(urlAddress, httpUrl, length);
    argv[argc++] = urlAddress;

    javacall_lifecycle_state_changed(JAVACALL_LIFECYCLE_MIDLET_STARTED, JAVACALL_OK);
    res = runMidlet(argc, argv);
}

/**
 * Gets a raw IPv4 address for the given hostname.
 * <p>
 * Java declaration:
 * <pre>
 *     static getIpNumber([B)I
 * </pre>
 *
 * @param szHost the hostname to lookup as a 'C' string
 * @return raw IPv4 address or <tt>-1</tt> if there was an error
 */
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_midp_io_j2me_datagram_Protocol_getIpNumber(void) {
    int len;
    int status;
    int ipn = -1;
    unsigned char ipBytes[MAX_ADDR_LENGTH];
    void* context = NULL;
    void* handle;
    MidpReentryData* info;

    KNI_StartHandles(1);
    KNI_DeclareHandle(hostObject);

    KNI_GetParameterAsObject(1, hostObject);

    info = (MidpReentryData*)SNI_GetReentryData(NULL);

    if (info == NULL) {  /* First invocation */
        SNI_BEGIN_RAW_POINTERS;
        status = pcsl_network_gethostbyname_start(
               (char*)JavaByteArray(hostObject),
                ipBytes, MAX_ADDR_LENGTH, &len, &handle, &context);
        SNI_END_RAW_POINTERS;
    } else {  /* Reinvocation after unblocking the thread */
        handle = (void*)info->descriptor;
        /* IMPL NOTE: Please see 6440539 for details. */
        /* All but windows implementations of pcsl_network_gethostbyname_finish */
        /*  ignore context parameter. Windows one expects status code there. */
        context = (void*)info->status;
        status = pcsl_network_gethostbyname_finish(ipBytes, MAX_ADDR_LENGTH,
                                                  &len, handle, context);
    }

    KNI_EndHandles();

    if (status == PCSL_NET_SUCCESS) {
        /*
         * Convert the unsigned char ip bytes array into an integer
         * that represents a raw IP address.
         */
        //ipn = pcsl_network_getRawIpNumber(ipBytes);
        memcpy(&ipn, ipBytes, MAX_ADDR_LENGTH);
    } else if (status == PCSL_NET_WOULDBLOCK) {
        midp_thread_wait(HOST_NAME_LOOKUP_SIGNAL, (int)handle, context);
    } else {
        /* status is either PCSL_NET_IOERROR or PCSL_NET_INVALID */
        ipn = -1;
        REPORT_INFO1(LC_PROTOCOL,
            "datagram::getIpNumber returns PCSL error code %d", status);
        /*
         * IOException is thrown at the Java layer when return value
         * is -1
         */
        //KNI_ThrowNew(midpIOException, "Host name could not be resolved");
    }

    KNI_ReturnInt((jint)ipn);
}

/*
 * Return a 32 bit handle to an open a file in storage in different modes.
 *
 * See "I/O Modes" and "Filenames" above for move information.
 *
 * If not successful *ppszError will set to point to an error string,
 * on success it will be set to NULL.
 */
int
storage_open(char** ppszError, const pcsl_string* filename_str, int ioMode) {
    int flags = 0;
    int openStatus;
    void *handle;

    *ppszError = NULL;

    if (OPEN_READ == ioMode) {
        DEBUGP2F("opening for read only %s\n", filename_str);
        flags |= PCSL_FILE_O_RDONLY;
    } else {
        if (!storage_file_exists(filename_str)) {
            flags |= PCSL_FILE_O_CREAT;
        } else if (OPEN_READ_WRITE_TRUNCATE == ioMode) {
            flags |= PCSL_FILE_O_TRUNC;
        }

        if (OPEN_WRITE == ioMode) {
            DEBUGP2F("opening write only %s\n", filename_str);
            flags |= PCSL_FILE_O_WRONLY;
        } else {
            DEBUGP2F("opening read write %s\n", filename_str);
            flags |= PCSL_FILE_O_RDWR;
        }
    }

    /**
     * Verify that the resource is available well within limit as per
     * the policy in ResourceLimiter
     */
    if (midpCheckResourceLimit(RSC_TYPE_FILE, 1) == 0) {
        REPORT_INFO(LC_CORE, "Resource limit exceeded for file handles");
        *ppszError = (char *)FILE_LIMIT_ERROR;
        return -1;
    }

    openStatus = pcsl_file_open(filename_str, flags, &handle);

    REPORT_INFO1(LC_CORE, "storage_open allocated file_desc %d\n", (int)handle);

    if (-1 == openStatus) {
        *ppszError = storage_get_last_file_error("storage_open()", filename_str);
        return -1;
    }

    /* Update the resource count  */
    if (midpIncResourceCount(RSC_TYPE_FILE, 1) == 0) {
        REPORT_INFO(LC_CORE, "FILE : resource limit update error");
    }

#if REPORT_LEVEL <= LOG_INFORMATION
    DEBUGP2F("created %s\n", filename_str);
#endif

    return (int)handle;
}

/**
 * Remove specified timer handler from queue and free allocated memory
 *
 * @param timer instance of timer that should be remove
 */
void delete_timer(TimerHandle* timer) {
    TimerHandle **ptr = get_timer_ptr(timer);
    REPORT_INFO1(LC_PUSH, "[delete_timer] timer=%p", timer);

    if (ptr != NULL) {
        *ptr = timer->next;
        midpFree(timer);
    }
}

int CustomItem::bodyWidthForHeight(int *takenHeight, int ) {
  
  REPORT_INFO1(LC_HIGHUI, "[lfpport_qte_customitem.cpp:%d] "
	       "***CustomItem::bodyWidthForHeight ", 
	       __LINE__);

  *takenHeight = drawable->height();
  return drawable->width();
}

/**
 * Remove specified timer handler from queue but don't free allocated memory
 *
 * @param timer instance that should be remove
 *
 * @return poitner to timer instance that should be remove from queue
 */
TimerHandle* remove_timer(TimerHandle* timer) {
    TimerHandle **ptr = get_timer_ptr(timer);
    REPORT_INFO1(LC_PUSH, "[remove_timer] timer=%p", timer);

    if (ptr != NULL) {
        *ptr = timer->next;
    }

    return timer;
}

/**
 * Sets the content buffer. All paints are done to that buffer.
 * When paint is processed snapshot of the buffer is flushed to
 * the native resource content area.
 * 
 * @param ciPtr pointer to the custom item's MidpItem structure.
 * @param imgPtr pointer to the native resource corresponding
 *        to the Java offcreen buffer for CustomItem content
 */
extern "C" MidpError
lfpport_customitem_set_content_buffer(MidpItem* ciPtr, unsigned char* imgPtr) {
  REPORT_INFO1(LC_HIGHUI, "[lfpport_qte_customitem.cpp:%d] "
	       "lfpport_customitem_SetContentBuffer", __LINE__);
  
  ((CustomItem *)ciPtr->widgetPtr)->
    setContentBuffer(gxpportqt_get_mutableimage_pixmap(imgPtr));

  return KNI_OK;
}

/**
 * Gets the padding for the custom item.
 *
 * @param pad the padding for the custom item.
 * @param ciPtr pointer to the custom item's MidpItem structure.
 *
 * @return an indication of success or the reason for failure
 */
extern "C" MidpError
lfpport_customitem_get_item_pad(int *pad, MidpItem* ciPtr)
{
  REPORT_INFO1(LC_HIGHUI, "[lfpport_qte_customitem.cpp:%d] "
	       "lfpport_customitem_GetItemPad", __LINE__);
  (void)ciPtr; // Suppress unused parameter warning

  *pad = ITEM_BOUND_PAD;

  return KNI_OK;
}

/**
 * Remove a specific entry indicated by user data.
 * Only first element matching the userData is removed.
 *
 * @param userdata user specified data used to identify the entry to remove
 */
void delete_timer_by_userdata(void* userdata) {
    TimerHandle* timer;
    REPORT_INFO1(LC_PUSH, "[delete_timer_by_userdata] userdata=%p", userdata);

    for(timer = rootTimer; timer != NULL; timer = timer->next) {
        if (timer->userData == userdata) {
            delete_timer(timer);
            return;
        }
    }
}

/**
 * Insert new timer to the correct place in timer queue
 * ordered by wakeup time
 *
 * @param newTimer new timer to add to queue
 */
void add_timer(TimerHandle* newTimer) {
    TimerHandle **ptr = &rootTimer;
    REPORT_INFO1(LC_PUSH, "[add_timer] newTimer=%p", newTimer);

    for(; *ptr != NULL; ptr = &((*ptr)->next)) {
        if ((*ptr)->timeToWakeup > newTimer->timeToWakeup) {
           break;
        }
    }
    newTimer->next = *ptr;
    (*ptr) = newTimer;
}

int testMidpCompareVersion_3(void) {
    jchar ver1[] = {'1','.','0','.','2','3'};
    MidpString in1 = {sizeof (ver1) / sizeof (jchar),ver1};
    jchar ver2[] = {'1','.','0','.','2','4'};
    MidpString in2 = {sizeof (ver2) / sizeof (jchar),ver2};
    int res = 0;
    res = midpCompareVersion(in1,in2);
    REPORT_INFO1(LC_AMS, "testMidpCompareVersion_3 res = %d\n", res);
    if(res < 0 ) {
        return 1;
    }
    return -1;
}