/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  ?Description
*
*/


#include <e32def.h>
#include <e32cmn.h>
#include <e32std.h>

#include "s60commonutils.h"
#include "jni.h"
#include <f32file.h>
#include <bautils.h>                    // BaflUtils
#include <driveinfo.h>                  // DriveInfo
#include <data_caging_path_literals.hrh> // KDC_* constant strings

using namespace java::util;

enum TJavaArrayPanic
{
    EBadOffsetIntoJavaArray,
    EWritingOverEndOfJavaArray,
    EBadOffsetIntoJavaArrayForRead,
    EReadingOverEndOfJavaArray,
};



/**
 * Copies the java buffer to native descriptor.
 * @param aJni The JNI environment.
 * @param aJavaBuffer The Java buffer to copy data from.
 * @param aOffset Start of data in Java buffer to copy. This is assumed to be valid.
 * @param aLength Amount of data to copy. This is assumed to be valid.
 * @param aNativeBuffer Target for data. This is assumed to be long enough.
 * @returns An error code.
 */
OS_EXPORT TInt S60CommonUtils::CopyToNative(JNIEnv& aJni, jbyteArray aJavaBuffer,
        TInt aOffset, TInt aLength, TDes8& aNativeBuffer)
{
    __ASSERT_DEBUG(aOffset <= aJni.GetArrayLength(aJavaBuffer),
                   User::Panic(_L("S60CommonUtils"), EBadOffsetIntoJavaArrayForRead));
    __ASSERT_DEBUG(aLength <= aJni.GetArrayLength(aJavaBuffer) - aOffset,
                   User::Panic(_L("S60CommonUtils"), EReadingOverEndOfJavaArray));

    aNativeBuffer.SetLength(aLength);
    TUint8* nativeBufPtr = const_cast<TUint8*>(aNativeBuffer.Ptr());
    jbyte* jNativeBufPtr = reinterpret_cast<jbyte*>(nativeBufPtr);
    aJni.GetByteArrayRegion(aJavaBuffer, aOffset, aLength, jNativeBufPtr);
    return KErrNone;
}



/**
 * Copies data from the native to the Java array.
 * @return The number of bytes copied.
 */
OS_EXPORT TInt S60CommonUtils::CopyToJava(JNIEnv& aJni, const TDesC8& aNativeBuffer,
        jbyteArray aJavaBuffer, TInt aOffset, TInt aLength)
{
    __ASSERT_DEBUG(aOffset <= aJni.GetArrayLength(aJavaBuffer),
                   User::Panic(_L("S60CommonUtils"), EBadOffsetIntoJavaArray));
    __ASSERT_DEBUG(aLength <= aJni.GetArrayLength(aJavaBuffer) - aOffset,
                   User::Panic(_L("S60CommonUtils"), EWritingOverEndOfJavaArray));

    TInt nativeBufLength = aNativeBuffer.Length();
    TInt length = (nativeBufLength < aLength) ? nativeBufLength : aLength;
    TUint8* nativeBufPtr = const_cast<TUint8*>(aNativeBuffer.Ptr());
    jbyte* jNativeBufPtr = reinterpret_cast<jbyte*>(nativeBufPtr);
    aJni.SetByteArrayRegion(aJavaBuffer, aOffset, length, jNativeBufPtr);
    return length;
}

OS_EXPORT jstring S60CommonUtils::NativeToJavaString(JNIEnv& aJni, const TDesC16& aNativeString)
{
    const jchar* ptr = aNativeString.Ptr();
    const jsize len = aNativeString.Length();
    jstring javaString = aJni.NewString(ptr, len);
    return javaString;
}

/**
 * Creates a Java array of strings from a native array of descriptors allocated
 * on the heap.
 * @param aJni The JNI environment.
 * @param aNativeArray The array of descriptors.
 * @return The newly created Java array of String objects, or NULL on error.
 */
OS_EXPORT jobjectArray S60CommonUtils::NativeToJavaStringArray(JNIEnv& aJni,
        const RPointerArray<HBufC>& aNativeArray)
{
    jclass stringClass = aJni.FindClass("java/lang/String");
    if (stringClass == NULL)
    {
        return NULL;
    }

    TInt count = aNativeArray.Count();
    jobjectArray jObjArray = aJni.NewObjectArray(count, stringClass, NULL);
    if (jObjArray == NULL)
    {
        return NULL;
    }

    for (int i = 0; i< count; i++)
    {
         if( !aNativeArray[ i ] )
         {
             // Skip null elements since already initialized
             continue;
         }
    	
        //TPtr16 temp =  aNativeArray[i]->Des();
        jstring javaString = S60CommonUtils::NativeToJavaString(aJni, *aNativeArray[i]);
        if (javaString == NULL)
        {
            aJni.DeleteLocalRef(jObjArray);
            return NULL;
        }

        aJni.SetObjectArrayElement(jObjArray, i, javaString);
        aJni.DeleteLocalRef(javaString);
    }

    return jObjArray;
}

/* Converts wchar_t to descriptor */
OS_EXPORT HBufC* S60CommonUtils::wstringToDes(const wchar_t* cStr)
{
    HBufC* descStr = NULL;
    int length = wcslen(cStr);
    if (length > 0)
    {
        descStr = HBufC::New(length + 1);
        if (descStr == NULL)
        {
            return descStr;
        }
        TPtr ptr = descStr->Des();
        TPtr ptr16((TUint16*)cStr,length);
        ptr16.SetLength(length);
        ptr.Copy(ptr16);
        ptr.ZeroTerminate();
    }
    return descStr;
}

OS_EXPORT TTime S60CommonUtils::JavaTimeToTTime(jlong aJavaTime)
{
    // Convert jlong to a TInt64
    TInt64 milliSeconds = *reinterpret_cast<TInt64*>(&aJavaTime);
    // Create a TTime object that represents the Java Date 'epoch' time of 00:00, 1 Jan 1970
    TInt64 javaEpocTimeNum = MAKE_TINT64(JavaUpperEpocTime, JavaLowerEpocTime);
    TTime time(javaEpocTimeNum);
    TTimeIntervalMicroSeconds timeInterval(milliSeconds * 1000);
    return time + timeInterval;
}

OS_EXPORT jlong S60CommonUtils::TTimeToJavaTime(TTime aEpocTime)
{
    // Create a TTime object that represents the Java Date 'epoch' time of 00:00, 1 Jan 1970
    TInt64 javaEpocTimeNum = MAKE_TINT64(JavaUpperEpocTime, JavaLowerEpocTime);
    TTime javaEpochTime(javaEpocTimeNum);
    // Find difference in microseconds between 'epoch' and EPOC date and adjust to milliseconds
    TTimeIntervalMicroSeconds microInterval = aEpocTime.MicroSecondsFrom(javaEpochTime);
    TInt64 timeInterval = microInterval.Int64();
    timeInterval = timeInterval/1000;
    jlong javaTimeInterval = *reinterpret_cast<jlong*>(&timeInterval);
    return javaTimeInterval;
}


//------------------------------------------------------------------------------
// public static ConvertWiderToNarrowL(const TDesC& aSource,TDesC8& aDestination)
//
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::ConvertWiderToNarrowLC(const TDesC& aSource,
        TDesC8*& aDestination)
{
    TBool value = (!&aSource) || (aSource.Length() < 1);
    if (value)
    {
        // we are poping in NON CleanupStack version.
        CleanupStack::PushL(aDestination);
        return 0;
    }

    HBufC8* buffer = HBufC8::NewLC(aSource.Length());
    TPtr8 ptr = buffer->Des();
    ptr.Copy(aSource);
    aDestination = buffer;

    return aDestination->Length();
}
//------------------------------------------------------------------------------
// public static ConvertWiderToNarrowL(const TDesC& aSource,TDesC8& aDestination)
// DO NOT LEAVE IT ON THE CLEANUP STACK
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::ConvertWiderToNarrowL(const TDesC& aSource,
        TDesC8*& aDestination)
{
    ConvertWiderToNarrowLC(aSource, aDestination);
    CleanupStack::Pop(aDestination); //aDestination

    if (aDestination)
        return aDestination->Length();
    else
        return 0;
}
//------------------------------------------------------------------------------
// public static ConvertNarrowToWiderL(const TDesC& aSource,TDesC8& aDestination)
// Leave the TDesC on cleanup stack
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::ConvertNarrowToWiderLC(const TDesC8& aSource,
        TDesC*& aDestination)
{
    TBool value = (!&aSource) || (aSource.Length() < 1);
    if (value)
    {
        // we are poping in NON CleanupStack version.
        CleanupStack::PushL(aDestination);
        return 0;
    }
    HBufC16* buffer = HBufC16::NewLC(aSource.Length());
    TPtr16 ptr = buffer->Des();
    ptr.Copy(aSource);
    aDestination = buffer;

    return aDestination->Length();
}
//------------------------------------------------------------------------------
// public static ConvertNarrowToWiderL(const TDesC& aSource,TDesC8& aDestination)
// DO NOT LEAVE IT ON THE CLEANUP STACK
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::ConvertNarrowToWiderL(const TDesC8& aSource,
        TDesC*& aDestination)
{
    ConvertNarrowToWiderLC(aSource, aDestination);
    CleanupStack::Pop(aDestination); //aDestination

    if (aDestination)
        return aDestination->Length();
    else
        return 0;
}
//------------------------------------------------------------------------------
// public static ConvertNarrowToWiderL(const TDesC& aSource,TDesC8& aDestination)
// Leave the TDesC on cleanup stack
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::CopyNarrowLC(const TDesC8& aSource,
        TDesC8*& aDestination)
{
    TBool value = (!&aSource) || (aSource.Length() < 1);
    if (value)
    {
        // we are poping in NON CleanupStack version.
        CleanupStack::PushL(aDestination);
        return 0;
    }
    HBufC8* buffer = HBufC8::NewLC(aSource.Length());
    TPtr8 ptr = buffer->Des();
    ptr.Copy(aSource);
    aDestination = buffer;

    return aDestination->Length();
}
//-------------------------------------------------------------------------------
// public static ConvertNarrowToWiderL(const TDesC& aSource,TDesC8& aDestination)
// DO NOT LEAVE IT ON THE CLEANUP STACK
//-------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::CopyNarrowL(const TDesC8& aSource,
        TDesC8*& aDestination)
{
    CopyNarrowLC(aSource, aDestination);
    CleanupStack::Pop(aDestination); //aDestination
    if (aDestination)
        return aDestination->Length();
    else
        return 0;
}
//------------------------------------------------------------------------------
// public static ConvertNarrowToWiderL(const TDesC& aSource,TDesC8& aDestination)
// Leave the TDesC on cleanup stack
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::CopyWiderLC(const TDesC16& aSource,
        TDesC16*& aDestination)
{
    TBool value = (!&aSource) || (aSource.Length() < 1);
    if (value)
    {
        // we are poping in NON CleanupStack version.
        CleanupStack::PushL(aDestination);
        return 0;
    }
    HBufC16* buffer = HBufC16::NewLC(aSource.Length());
    TPtr16 ptr = buffer->Des();
    ptr.Copy(aSource);
    aDestination = buffer;

    return aDestination->Length();
}
//------------------------------------------------------------------------------
// public static ConvertNarrowToWiderL(const TDesC& aSource,TDesC8& aDestination)
// DO NOT LEAVE IT ON THE CLEANUP STACK
//------------------------------------------------------------------------------
OS_EXPORT TInt S60CommonUtils::CopyWiderL(const TDesC16& aSource,
        TDesC16*& aDestination)
{
    CopyWiderLC(aSource, aDestination);
    CleanupStack::Pop(aDestination); //aDestination
    if (aDestination)
        return aDestination->Length();
    else
        return 0;
}

OS_EXPORT TFileName S60CommonUtils::ResourceLanguageFileNameL(const TDesC& aResourceFileName)
{
    // get the name of the running process
    TFileName* dllFileName = new(ELeave) TFileName;
    CleanupStack::PushL(dllFileName);
    Dll::FileName(*dllFileName);

    // create the full path without drive letter
    TFileName* tmp = new(ELeave) TFileName;
    CleanupStack::PushL(tmp);
    tmp->Append(KDC_RESOURCE_FILES_DIR);
    tmp->Append(_L("java\\"));
    tmp->Append(aResourceFileName);

    // add the drive letter of the DLL's file name
    TParse p;
    p.Set(*tmp, dllFileName, NULL);
    CleanupStack::PopAndDestroy(tmp);
    CleanupStack::PopAndDestroy(dllFileName);

    // check if the resource exists
    TFileName resourceFullName = p.FullName();
    RFs fs;
    User::LeaveIfError(fs.Connect());
    CleanupClosePushL(fs);
    BaflUtils::NearestLanguageFile(fs, resourceFullName);
    if (!BaflUtils::FileExists(fs, resourceFullName))
    {
        // try the ROM drive
        TChar romDriveLetter;
        User::LeaveIfError(DriveInfo::GetDefaultDrive(DriveInfo::EDefaultRom, romDriveLetter));
        // replace resourceFullName's drive letter with romDriveLetter
        resourceFullName[0] = romDriveLetter;
        BaflUtils::NearestLanguageFile(fs, resourceFullName);
    }
    CleanupStack::PopAndDestroy(&fs);

    // return
    return resourceFullName;
}


OS_EXPORT TFileName S60CommonUtils::VerifiedFileNameL(const TDesC& aFileName)
{
    _LIT(KColonChar, ":");

    RFs fs;
    User::LeaveIfError(fs.Connect());
    CleanupClosePushL(fs);

    // Does the file name specify drive ?
    // If the second char is ':' assume that the first one is drive
    TBool fileNameContainsDrive(EFalse);
    TChar originalDriveLetter(0);
    TUint attr(0);
    TInt  err(KErrNone);
    TFileName fullName = aFileName;
    if (aFileName.Find(KColonChar) == 1)
    {
        fileNameContainsDrive = ETrue;
        // Is the file in current drive?
        err = fs.Att(aFileName, attr);
        if (KErrNone == err)
        {
            CleanupStack::PopAndDestroy(&fs);
            return fullName;
        }

        // Must search from other drives. Remember the current drive;
        originalDriveLetter = aFileName[0];
        originalDriveLetter.UpperCase();
    }

    // First check system drive
    TChar driveLetter;
    User::LeaveIfError(DriveInfo::GetDefaultDrive(DriveInfo::EDefaultSystem, driveLetter));
    // Check system drive if it has not yet been checked
    if (originalDriveLetter != driveLetter)
    {
        if (fileNameContainsDrive)
        {
            fullName[0] = driveLetter;
        }
        else
        {
            fullName.Zero();
            fullName.Append(driveLetter);
            fullName.Append(KColonChar);
            fullName.Append(aFileName);
        }

        err = fs.Att(fullName, attr);
        if (KErrNone == err)
        {
            CleanupStack::PopAndDestroy(&fs);
            return fullName;
        }
    }

    // Next try to find file from ROM if the ROM drive has not yet been checked
    User::LeaveIfError(DriveInfo::GetDefaultDrive(DriveInfo::EDefaultRom, driveLetter));
    if (originalDriveLetter != driveLetter)
    {
        if (fileNameContainsDrive)
        {
            fullName[0] = driveLetter;
        }
        else
        {
            fullName.Zero();
            fullName.Append(driveLetter);
            fullName.Append(KColonChar);
            fullName.Append(aFileName);
        }

        err = fs.Att(fullName, attr);
    }
    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(&fs);
    return fullName;
}