/*
* 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:
 *
*/

#include <memory>
#include <errno.h>
#include <f32file.h>
#include <gsmumsg.h>
#include <smsustrm.h>
#include <charconv.h>

#include "logger.h"
#include "s60commonutils.h"
#include "javacommonutils.h"
#include "javasymbianoslayer.h"
#include "csmsplatformservices60impl.h"
#include "cservicecentrenumretrievers60impl.h"

namespace java
{
namespace wma
{
//Constructor
CSmsPlatformServiceS60Impl::CSmsPlatformServiceS60Impl(std::wstring aUri)
        :mUri(aUri)
{
    JELOG2(EWMA);
}

//Destructor
CSmsPlatformServiceS60Impl::~CSmsPlatformServiceS60Impl()
{
    JELOG2(EWMA);
    if (mUri.find(L"cbs://:") == std::wstring::npos)
    {
        mSmsSendSocket.CancelAll();
        mSmsSendSocket.Close();
        delete mSendMessage;
    }
    delete mMessageParameters;
}

SmsPlatformService* SmsPlatformService::getNewInstance(std::wstring aUri)
{
    JELOG2(EWMA);
    CSmsPlatformServiceS60Impl* msgConn = new CSmsPlatformServiceS60Impl(aUri);
    if (aUri.find(L"cbs://:") == std::wstring::npos)
    {
        msgConn->initialize();
    }
    else
    {
        // Its a Cbs Connection nothing to be initialized.
    }
    return msgConn;
}
/**
 * Initializing function
 */
void CSmsPlatformServiceS60Impl::initialize()
{
    JELOG2(EWMA);
    int err = KErrNone;
    err = mSocketServer.Connect();
    if (KErrNone == err)
    {
        err = mSocketServer.ShareAuto();
    }
    if (err == KErrNone)
    {
        err = mSmsSendSocket.Open(mSocketServer, KSMSAddrFamily,
                                  KSockDatagram, KSMSDatagramProtocol);
        if (err == KErrNone)
        {
            mSmsSendAddress.SetFamily(ESmsAddrApplication16BitPort);
            mSmsSendAddress.SetPort(mSendPort);
            err = mSmsSendSocket.Bind(mSmsSendAddress);
            if (err != KErrNone)
            {
                ELOG1(EWMA, "SMS : error while binding socket : %d", err);
                throw err;
            }
            else
            {
                // No error nothing to do
            }
        }
        else
        {
            ELOG1(EWMA, "SMS : error while opening socket : %d", err);
            throw err;
        }
    }
    else
    {
        ELOG1(EWMA, "SMS : error while connecting to socketserver : %d", err);
        throw err;
    }
}
/**
 * Converts the CString to Descriptor
 */
HBufC* CSmsPlatformServiceS60Impl::convertToDes(const char* aData,
        const int aMsgType,
        const int aLength)
{
    HBufC* smsData = 0;
    smsData = HBufC::New(aLength+1);
    if (aData != NULL)
    {
        if (aMsgType == MESSAGE_TEXT)
        {
            TPtr ptr = smsData->Des();
            TPtr16 ptr16((TUint16 *)aData,aLength);
            ptr16.SetLength(aLength);
            ptr.Copy(ptr16);
            ptr.ZeroTerminate();
        }
        else
        {

            TPtr ptr = smsData->Des();
            TPtr8 ptr8((TUint8 *)aData,aLength);
            ptr8.SetLength(aLength);
            ptr.Copy(ptr8);
            ptr.ZeroTerminate();
        }
    }
    return smsData;
}
/**
 * Calculates and returns numberofDataSegments of the Message.
 */
int CSmsPlatformServiceS60Impl::getSmsDataSegments(const int aMsgType,
        const int aLength,
        const int aHostPort,
        const char* aHostAddress,
        const char* aData)
{
    JELOG2(EWMA);
    int numberOfSegments =0;
    TBool PortAddressing = EFalse;
    TInt receiveIntoPort = 0;
    if (mUri.find(L"sms://:") != std::wstring::npos)
    {
        receiveIntoPort = java::util::JavaCommonUtils::wstringToInt(
                              mUri.substr(KPortFieldStartIndex));
    }
    else
    {
        // It is a client connection, Nothing to do
    }
    TRAPD(error,
    {
        HBufC* smsData = convertToDes(aData,aMsgType,aLength);
        CleanupStack::PushL(smsData);
        std::auto_ptr<HBufC> smsAddress(stringToDes(aHostAddress));
        // The sms message takes ownership of the buffer
        CSmsBuffer* buffer = CSmsBuffer::NewL();
        CleanupStack::PushL(buffer);
        delete mSendMessage;
        mSendMessage = 0;
        RFs fileServer;
        mSendMessage = CSmsMessage::NewL(fileServer,CSmsPDU::ESmsSubmit,buffer);
        CleanupStack::Pop(buffer);
        if (smsAddress->Length()> 0)
        {
            // set the destination address
            mSendMessage->SetToFromAddressL((const TPtrC&)*smsAddress);
            // Set SMS port addresing
            if (aHostPort != 0)
            {
                PortAddressing = ETrue;
            }
            else
            {
                PortAddressing = EFalse;
            }
            (mSendMessage->SmsPDU()).SetApplicationPortAddressingL(
                PortAddressing,aHostPort,receiveIntoPort,KUse16BitPortAddressing);
        }
        else
        {
            // Nothing to do
        }

        // Get the encoding for the message that is to be sent
        TSmsDataCodingScheme::TSmsAlphabet smsEncoding = getEncodingSchemeL(
                    *smsData,aMsgType,fileServer);
        // sets the encoding

        (mSendMessage->SmsPDU()).SetAlphabet(smsEncoding);
        (mSendMessage->SmsPDU()).SetTextCompressed(EFalse);
        (mSendMessage->SmsPDU()).SetTextConcatenatedL(ETrue,ETrue);

        (mSendMessage->Buffer()).Reset();
        (mSendMessage->Buffer()).InsertL(0,*smsData);

        mSendMessage->OptimizeSettingsL(CSmsMessage::
                                        ESmsFlagOptimizeConcatenation16BitReference);
        // calculate the number of message PDUs required to send this message
        numberOfSegments = (int)mSendMessage->NumMessagePDUsL();
        LOG2(EWMA, EInfo,"SMS :number of segments %d data length %d",
             numberOfSegments, aLength);
        CleanupStack::PopAndDestroy(smsData);
    });
    return (error == KErrNone)? numberOfSegments : error;
}

/**
 * Gets the best Message encoding for the message.
 */
TSmsDataCodingScheme::TSmsAlphabet CSmsPlatformServiceS60Impl ::
getEncodingSchemeL(const TDesC& aSmsData,const TInt aMsgType,RFs& aFs)
{
    JELOG2(EWMA);
    TSmsDataCodingScheme::TSmsAlphabet msgEncoding;
    if (aMsgType == MESSAGE_TEXT)
    {
        TBool isGSM7Convertible = EFalse;
        TPtrC tempData(aSmsData);
        TBuf8<KCharacterConversionBufferSize> tempBuf;
        TInt charsToBeConverted = aSmsData.Length();
        TInt nonConvertibleCharacters;
        CCnvCharacterSetConverter* cConverter =
            CCnvCharacterSetConverter::NewL();
        CleanupStack::PushL(cConverter);
        CCnvCharacterSetConverter::TAvailability cnvAvailable =
            cConverter->PrepareToConvertToOrFromL(
                KCharacterSetIdentifierSms7Bit, aFs);

        if (cnvAvailable == CCnvCharacterSetConverter::EAvailable)
        {
            isGSM7Convertible = ETrue;
            while (charsToBeConverted> 0)
            {
                charsToBeConverted = cConverter->ConvertFromUnicode(
                                         tempBuf,tempData, nonConvertibleCharacters);

                if (nonConvertibleCharacters> 0)
                {
                    isGSM7Convertible = EFalse;
                    break;
                }
                else
                {
                    // Nothing to do
                }

                tempBuf.Zero();
                tempData.Set(tempData.Right(charsToBeConverted));
            }
        }
        else
        {
            // Nothing to do
        }
        (isGSM7Convertible)?msgEncoding = TSmsDataCodingScheme::ESmsAlphabet7Bit
                                          :msgEncoding = TSmsDataCodingScheme::ESmsAlphabetUCS2;
        CleanupStack::PopAndDestroy(cConverter);
    }
    else
    {
        msgEncoding = TSmsDataCodingScheme::ESmsAlphabet8Bit;
    }
    return msgEncoding;
}
/**
 * Method to send the message.
 */
int CSmsPlatformServiceS60Impl::send()
{
    JELOG2(EWMA);
    int error =KErrNone;
    TRAP(error,
    {
        TBuf<RMobilePhone::KMaxMobileTelNumberSize>ServiceCentreNumber;
        //get the service centre number
        CServiceCentreNumRetrieverS60Impl::retrieveServiceCentreNumberL(
            ServiceCentreNumber);
        (mSendMessage->SmsPDU()).SetServiceCenterAddressL(ServiceCentreNumber);
        RSmsSocketWriteStream socketWrite(mSmsSendSocket);
        CleanupClosePushL(socketWrite);
        socketWrite << *mSendMessage;
        socketWrite.CommitL();
        CleanupStack::PopAndDestroy(&socketWrite);
        TRequestStatus status;
        mSmsSendSocket.Ioctl(KIoctlSendSmsMessage,status,&mSmsSendDummyBuf,
                             KSolSmsProv);
        User::WaitForRequest(status);
        User::LeaveIfError(status.Int());
    });
    return error;
}

/**
 * Gets the Message type of the received Message
 */
int CSmsPlatformServiceS60Impl :: receivedMessageType(ServerConnectionBase&
        aServerConn)
{
    JELOG2(EWMA);
    int messageType = KErrNone;
    if (0 == mMessageParameters)
    {
        mMessageParameters = new TJavaMessageParametersBuf();
    }
    else
    {
        // Nothing to do
    }
    int error = aServerConn.retrieveMessage(*mMessageParameters);
    if (error != KErrNone)
    {
        ELOG1(EWMA, "WMA :: receivedMessageType error: %d", error);
        return error;
    }
    else
    {
        switch ((*mMessageParameters)().mEncoding)
        {
        case TSmsDataCodingScheme::ESmsAlphabet7Bit:
        case TSmsDataCodingScheme::ESmsAlphabetUCS2:
        case TSmsDataCodingScheme::ESmsAlphabetReserved:
        {
            messageType = MESSAGE_TEXT;
            break;
        }
        case TSmsDataCodingScheme::ESmsAlphabet8Bit:
        {
            messageType = MESSAGE_BINARY;
            break;
        }
        default:
        {
            messageType = KErrNotSupported;
            ELOG(EWMA,"WMA : Invalid Message Type");
            break;
        }
        }
    }
    return messageType;
}
/**
 * Gets the Remote Host Address.
 */
jstring CSmsPlatformServiceS60Impl::getHostAddress(JNIEnv& aJni)
{
    JELOG2(EWMA);
    TBuf<KMaxUriSize> Uri;
    const TDesC& address = (*mMessageParameters)().mAddress;
    TUint16 port = (*mMessageParameters)().mPort;
    if (mUri.find(L"cbs://:") == std::wstring::npos)
    {
        Uri.Append(KSmsProtocol);
        Uri.Append(KUriColonAndSlashes);
        Uri.Append(address);
    }
    else
    {
        Uri.Append(KCbsProtocol);
        Uri.Append(KUriColonAndSlashes);
        Uri.Append(KCBSEmptyAddress);
    }
    Uri.Append(':');
    Uri.AppendNum(port);
    return aJni.NewString((jchar*)Uri.Ptr(),Uri.Length());
}
/**
 * gets the received message as jobject to java side.
 */
jobject CSmsPlatformServiceS60Impl::getMessageData(
    JNIEnv& aJni,const int aMessageType)
{
    JELOG2(EWMA);
    jobject javaSmsData = 0;
    if (aMessageType ==MESSAGE_TEXT)
    {
        javaSmsData = aJni.NewString(
                          (jchar*)((*mMessageParameters)().mData).Ptr(),
                          ((*mMessageParameters)().mData).Length());
    }
    else if (aMessageType == MESSAGE_BINARY)
    {
        TInt length = ((*mMessageParameters)().mData).Length();
        TBuf8<KSmsMaxDataSize> dataBuf;
        dataBuf.SetLength(length);
        dataBuf.Copy(((const TDesC16&)((*mMessageParameters)().mData)));
        jbyteArray javaSmsBinaryData = aJni.NewByteArray(dataBuf.Length());
        if (javaSmsBinaryData)
        {
            TInt nativeBufferLength = dataBuf.Length();
            TUint8* nativeBufferPtr = const_cast<TUint8*>(dataBuf.Ptr());
            jbyte* jNativeBufferPtr = reinterpret_cast<jbyte*>(
                                          nativeBufferPtr);
            aJni.SetByteArrayRegion(javaSmsBinaryData, 0,
                                    nativeBufferLength,jNativeBufferPtr);
            javaSmsData = javaSmsBinaryData;
        }
        else
        {
            // Noting to do
        }
    }
    else
    {
        // Not a supported message type, It is already handled
    }
    return javaSmsData;
}
/**
 * Gets the Time stamp of the received message.
 */
jlong CSmsPlatformServiceS60Impl::getTimeStamp()
{
    JELOG2(EWMA);
    if (mUri.find(L"cbs://:") != std::wstring::npos)
    {
        return 0;
    }
    else
    {
        return java::util::S60CommonUtils::
               TTimeToJavaTime((*mMessageParameters)().mTimestamp);
    }

}
} //namespace wma
} //namespace java


