/**
 * Starts a new process to handle the given URL. The new process executes
 * the value of the <tt>com.sun.midp.midlet.platformRequestCommand</tt>
 * system property. The URL is passed as this process' sole command-line
 * argument.
 *
 * @param pszUrl The 'C' string URL
 *
 * @return true if the platform request is configured
 */
int platformRequest(char* pszUrl) {
    (void)pszUrl;
#if 0
    char *execargs[3];
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    if (strlen(pszUrl) == 0) {
        /*
         * This is a request to cancel. Since a process was already spawned
         * to handle the previous URL, it too late.
         */
        return 1;
    }

    execargs[0] = (char *)getInternalProp(PLATFORM_REQUEST_KEY);
    if (execargs[0] == NULL) {
        REPORT_WARN(LC_AMS, "PlatformRequest is not configured.");
	return 0;
    }

    execargs[1] = pszUrl;
    /* leave room for a space and zero terminator */
    execargs[2] = (char*)midpMalloc(strlen(execargs[0]) +
                     strlen(execargs[1]) + 2);
    if (execargs[2] == NULL) {
        REPORT_WARN(LC_AMS, "PlatformRequest ran out of memory.");
	return 0;
    }

    strcpy(execargs[2], execargs[0]);
    strcat(execargs[2], " ");
    strcat(execargs[2], execargs[1]);

    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);

    // spawn the request using the configured URL handler and URL parameter
    /*
     * do not inherit handles
     */
    if (CreateProcess(NULL, execargs[2], NULL, NULL, FALSE, 0,
	NULL, NULL, &si, &pi)) {
        CloseHandle(pi.hProcess);
	CloseHandle(pi.hThread);
    } else {
        REPORT_WARN(LC_AMS, "Spawning a handler process failed. Check the platformRequest configuration. ");
    }

    midpFree(execargs[2]);
#endif
    return 1;
}

/**
 * Finds push entries that belong to the given suite. If the available
 * flag is set, return only those entries with live connections (socket)
 * or cached incoming data.
 *
 * @param store The storagename of the suite
 * @param available If set, return only "live" push entries
 *
 * @return A comma delimited list of full-text push entries
 */
char* pushfindsuite(char* store, int available) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "pushfindsuite: Stubbed out.");
    (void)store;
    (void)available;
    return NULL;
}

/**
 * Given the connection string and port number, look up the
 * push entry and return its filter.
 *
 * @param conn the connection string
 * @param port the port number to match
 * @return the filter from the registry
 */
char* pushgetfilter(char* conn, int port) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "pushgetfilter: Stubbed out.");
    (void)conn;
    (void)port;
    return NULL;
}

/**
 * Given the connection string and application ID, look up the
 * push entry and return its filter.
 *
 * @param conn the connection string
 * @param appID The MMS application ID to match
 * @return the filter from the registry
 */
char* pushgetfiltermms(char *conn, char *appID) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "pushgetfiltermms: Stubbed out.");
    (void)conn;
    (void)appID;
    return NULL;
}

/**
 * Removes one entry from the push registry.
 * If the entry is not registered return an error.
 * On successful deletion, write a new copy of the file to disk.
 *
 * @param str The push entry string to be deleted
 * @param store The MIDletSuite storagename
 * @return <tt>0</tt> if successful, <tt>-2</tt> if the entry belongs
 *         to another suite.
 */
int pushdel(char *str, char *store) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "pushdel: Stubbed out.");
    (void)str;
    (void)store;
    return 0;
}

/**
 * Platform handling code for turning off or on
 * indicators for signed MIDlet.
 *
 * @todo Currently indicator does nothing for Java
 * and platform widget modules as we are waiting for
 * UI input.
 */
void anc_show_trusted_indicator(jboolean isTrusted) {
    REPORT_WARN(LC_LOWUI, "anc_show_trusted_indicator: Stubbed out.");
    /* @todo implement security indicator and remove
     * the temporary workaround for warning removal.
     */
    (void)isTrusted;
}

void configurePort(char** ppszError, int hPort, long baudRate,
                          unsigned long options) {
    (void)ppszError;
    (void)hPort;
    (void)baudRate;
    (void)options;
    REPORT_WARN(LC_PROTOCOL, "serial_port:configurePort: Stubbed out.");
}

long writeToPort(char** ppszError, long hPort, char* pBuffer,
                 long nNumberOfBytesToWrite) {
    (void)ppszError;
    (void)hPort;
    (void)pBuffer;
    (void)nNumberOfBytesToWrite;
    REPORT_WARN(LC_PROTOCOL, "serial_port:writeToPort: Stubbed out.");
}

long readFromPort(char** ppszError, long hPort, char* pBuffer,
                 long nNumberOfBytesToRead) {
    (void)ppszError;
    (void)hPort;
    (void)pBuffer;
    (void)nNumberOfBytesToRead;
    REPORT_WARN(LC_PROTOCOL, "serial_port:readFromPort: Stubbed out.");
}

long openPortByNumber(char** ppszError, long port, long baudRate,
                      long options) {
    (void)ppszError;
    (void)port;
    (void)baudRate;
    (void)options;
    REPORT_WARN(LC_PROTOCOL, "serial_port:openPortByNumber: Stubbed out.");
}

/**
 * Adds one entry to the alarm registry.
 * If the entry already exists, return previous alarm time.
 * On succesful registration, write a new copy of the file to disk.
 *
 * @param str The alarm entry to add
 * @param alarm The absolute time at which this alarm is fired
 * @param lastalarm The place to return the previous alarm time, if it exists
 *
 * @return <tt>0</tt> if successful, <tt>-2</tt> if there was an error
 *         allocating this alarm.
 */
int alarmadd(char* str, jlong alarm, jlong* lastalarm){
    /* need revisit */
    REPORT_WARN(LC_PUSH, "alarmadd: Stubbed out.");
    (void)str;
    (void)alarm;
    (void)lastalarm;
    return -2;
}

/**
 * Checks out the handle for the requested connection.
 * The CHECKED_OUT token
 * is left in the registry to indicate that an application is
 * actively using the connection.
 *
 * @param protocol The protocol of the connection
 * @param port The port number of the connection
 * @param store The storage name of the requesting Suite
 *
 * @return <tt>-1</tt> if the connection is not found, other wise returns
 * the previously opened file descriptor.
 */
int pushcheckout(char* protocol, int port, char* store) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "pushcheckout: Stubbed out.");
    (void)protocol;
    (void)port;
    (void)store;
    return -1;
}

int
createTimerHandle(int alarmHandle, jlong time) {
    /* alarmHandle is really an address to push entry */
    REPORT_WARN(LC_PUSH, "createTimerHandle: Stubbed out.");
    (void)alarmHandle;
    (void)time;
    return -1;
}

/**
 * starts another native thread.
 * The primary usage of this function is testing of NAMS subsystem 
 * - second thread is used to throw initial events to main application thread.
 *
 * ATTENTION: this is a stub ! 
 * Put real plarform specific thread start here if needed !
 * If platfoprm specific thread routine signature differs from 
 * "midp_ThreadRoutine", use platform speficic thread routine as a wrapper 
 * to prepare parameters for "midp_ThreadRoutine" and to call it ...
 *
 * @param thread thread routine
 * @param param thread routine parameter
 *
 * @return handle of created thread
 */
midp_ThreadId midp_startNativeThread(midp_ThreadRoutine thread, 
    midp_ThreadRoutineParameter param) {

    (void)thread;
    (void)param;
    REPORT_WARN(LC_AMS, "midp_startNativeThread: Stubbed out."); 
    return MIDP_INVALID_NATIVE_THREAD_ID;
}

long openPortByName(char** ppszError, char* pszDeviceName, long baudRate,
                    long  options) {
    (void)ppszError;
    (void)pszDeviceName;
    (void)baudRate;
    (void)options;
    REPORT_WARN(LC_PROTOCOL, "serial_port:openPortByName: Stubbed out.");
    return 0;
}

static MidpProperties verifyMfMustProperties(MidpProperties mfsmp) {

    /* MUST fields in MANIFEST */
    /* pcsl_string MIDlet-<n> for each MIDlet */
    pcsl_string * midlet_1;
    pcsl_string * name;
    pcsl_string * version;
    pcsl_string * vendor;
    pcsl_string * profile;
    pcsl_string * configuration;

    name = midp_find_property(&mfsmp, &SUITE_NAME_PROP);
    if (pcsl_string_is_null(name)) {
        REPORT_WARN(LC_AMS, "Missing suite name");
        mfsmp.status = NO_SUITE_NAME_PROP;
        return mfsmp;
    }

    vendor = midp_find_property(&mfsmp, &SUITE_VENDOR_PROP);
    if (pcsl_string_is_null(vendor)) {
        REPORT_WARN(LC_AMS, "Missing suite vendor");
        mfsmp.status = NO_SUITE_VENDOR_PROP;
        return mfsmp;
    }

    version = midp_find_property(&mfsmp, &SUITE_VERSION_PROP);
    if (pcsl_string_is_null(version)) {
        REPORT_WARN(LC_AMS, "Missing suite version");
        mfsmp.status = NO_SUITE_VERSION_PROP;
        return mfsmp;
    }
    if (!midpCheckVersion(version)) {
        REPORT_WARN(LC_AMS, "Corrupted suite version");
        mfsmp.status = BAD_SUITE_VERSION_PROP;
        return mfsmp;
    }

    profile = midp_find_property(&mfsmp, &MICROEDITION_PROFILE_PROP);
    if (pcsl_string_is_null(profile)) {
        REPORT_WARN(LC_AMS, "Missing Midp-Profile");
        mfsmp.status = NO_MICROEDITION_PROFILE_PROP;
        return mfsmp;
    }

    configuration = midp_find_property(&mfsmp, &MICROEDITION_CONFIGURATION_PROP);
    if (pcsl_string_is_null(configuration)) {
        REPORT_WARN(LC_AMS, "Missing Midp-Configuration");
        mfsmp.status = NO_MICROEDITION_CONFIGURATION_PROP;
        return mfsmp;
    }

    midlet_1 = midp_find_property(&mfsmp, &MIDLET_ONE_PROP);
    if (pcsl_string_is_null(midlet_1)) {
        REPORT_WARN(LC_AMS, "Missing Midlet-1");
        mfsmp.status = NO_MIDLET_ONE_PROP;
        return mfsmp;
    }
    return mfsmp;
} /* verifyMfMustProperties */

/**
 *  Fetch the datagram data into a buffer.
 *
 * @param fd The handle of the datagram port
 * @param ip The ip address of the incoming datagram
 * @param sndport The port from which the data was sent
 * @param buf A pointer to a buffer into which the data should be copied
 * @param len The size of buf
 * @return the length of the datagram data if successful, or <tt>-1</tt>
 *         unsuccessful.
 */
int pusheddatagram (int fd, int *ip, int *sndport, char *buf, int len) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "pusheddatagram : Stubbed out.");
    (void)fd;
    (void)ip;
    (void)sndport;
    (void)buf;
    (void)len;
    return -1;
}

/**
 * Return local timezone ID string. This string is maintained by this 
 * function internally. Caller must NOT try to free it.
 *
 * This function should handle daylight saving time properly. For example,
 * for time zone America/Los_Angeles, during summer time, this function
 * should return GMT-07:00 and GMT-08:00 during winter time.
 *
 * @return Local timezone ID string pointer. The ID string should be in the
 *         format of GMT+/-??:??. For example, GMT-08:00 for PST.
 */
char* getLocalTimeZone() {
    static char tz[12]; /* No longer than "GMT-10:00" */

    REPORT_WARN(LC_CORE, "getLocalTimeZone: Stubbed out."); 
    // Replace the zero with a system function that will return GMT offset
    
    /* UTC time is converted to local time */
    sprintf(tz, "GMT%+03d:00", 0);

    return tz;
}

/**
 * Adds one entry to the push registry.
 * If the entry already exists return IO_ERROR_LEN (midpString.h).
 *
 * @param suiteId ID of the suite
 * @param connection generic connection name (no spaces)
 * @param midlet class name of the MIDlet (no spaces)
 * @param filter filter string (no spaces)
 *
 * @return 0 for success, OUT_OF_MEM_LEN for out of memory,
 * IO_ERROR_LEN if already registered
 */
int midpAddPushEntry(SuiteIdType suiteId,
                     const pcsl_string * connection,
                     const pcsl_string * midlet,
                     const pcsl_string * filter) {
    /* need revisit */
    REPORT_WARN(LC_PUSH, "midpAddPushEntry: Stubbed out.");
    (void)suiteId;
    (void)connection;
    (void)midlet;
    (void)filter;
    return 0;
}

/**
 * Log the native thread ID for debugging on multi-thread platforms.
 *
 * @param message message to prefix the thread ID
 */
void midp_logThreadId(char* message) {
#if REPORT_LEVEL <= LOG_INFORMATION
    char temp[80];

    REPORT_WARN(LC_EVENTS, "midp_logThreadId: Stubbed out.");
    //put code here to get the thread id

    sprintf(temp, "%s: ThreadID = %d\n", message,
            (int)midp_getCurrentThreadId());
    REPORT_INFO(LC_EVENTS, temp);
#else
    (void)message; // avoid a compiler warning
#endif

}