/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

// INCLUDE FILES

#include <QUrl>

#include <QDesktopServices>

#include <QStringList>

#if defined(Q_OS_SYMBIAN)

#include <miutset.h>                // KUidMsgTypeSMTP

#include <sendui.h>                 // CSendUi

#include <cmessagedata.h>           // CMessageData

//For Rtsp Scheme

#include <aiwgenericparam.h> 

#include <DocumentHandler.h>

#include <apparc.h>

_LIT( KRtspFileName, "c:\\system\\temp\\RtspTemp.ram" );

#endif // defined(Q_OS_SYMBIAN)

#include "SchemeHandlerBr_p.h"

#include "SchemeHandlerBrDefault_p.h"

#define MAILTO_SCHEME "mailto"

#define TEL_SCHEME "tel"

#define RTSP_SCHEME "rtsp"

#define SIP_SCHEME "sip"

#define WTAI_SCHEME "wtai"

#define WTAI_MC "/mc;"

#define WTAI_AP "/ap;"

namespace WRT {

/*!

 * HandleUrl

 * @return true/false

 */

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleUrl(const QUrl &url, bool confirmDTMF)

{

    return SchemeHandlerPrivate::HandleUrl(url, confirmDTMF);

}

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleScheme(const QUrl &url)

{

    QString scheme = url.scheme().toLower();

    SchemeHandler::SchemeHandlerError retVal = SchemeHandler::SchemeUnsupported;

    if (scheme == MAILTO_SCHEME) {

        // launch associated program

        retVal = HandleMailtoScheme(url);

    }

    else if (scheme == RTSP_SCHEME) {

        // launch associated program

        retVal = HandleRtspScheme(url);

    }

#if defined(Q_OS_SYMBIAN) 

    else if (scheme == TEL_SCHEME) {

        // launch associated program

        retVal = HandleTelScheme(url);

    }

    else if (scheme == SIP_SCHEME) {

        // launch associated program

        retVal = HandleSipScheme(url);

    }

    else if (scheme == WTAI_SCHEME) {

        QString path = url.path();

        if (path.startsWith(WTAI_MC)) {

            // launch associated program

            retVal = HandleWtaiMcScheme(url);

        }

    }

#endif

    return retVal;

}

#if !defined(Q_OS_SYMBIAN) 

/*

 * HandleMailtoScheme

 * @return  true/false

 */

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleMailtoScheme(const QUrl &url)

{

    SchemeHandler::SchemeHandlerError retVal = SchemeHandler::NoError;

#ifndef QT_NO_DESKTOPSERVICES

    if (!QDesktopServices::openUrl(url)) {

        // Failed to handle scheme

        retVal = SchemeHandler::LaunchFailed;

    }

#else

    retVal = SchemeHandler::SchemeUnsupported;

#endif

    return (retVal);

}

#else // Q_OS_SYMBIAN

/*

 * HandleMailtoScheme

 * @return  true/false

 */

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleMailtoScheme(const QUrl &url)

{

    TRAPD(err, HandleMailtoSchemeL(url));

    return err ? SchemeHandler::LaunchFailed : SchemeHandler::NoError;

}

void DefSchemeHandlerPrivate::HandleMailtoSchemeL(const QUrl &url)

{

    QString recipient = url.path();

    QString subject = url.queryItemValue("subject");

    QString body = url.queryItemValue("body");

    QString to = url.queryItemValue("to");

    QString cc = url.queryItemValue("cc");

    QString bcc = url.queryItemValue("bcc");

    // these fields might have comma separated addresses

    QStringList recipients = recipient.split(",");

    QStringList tos = to.split(",");

    QStringList ccs = cc.split(",");

    QStringList bccs = bcc.split(",");

    CSendUi* sendUi = CSendUi::NewLC();

    // Construct symbian sendUI data holder

    CMessageData* messageData = CMessageData::NewLC();

    // Subject

    TPtrC subj( qt_QString2TPtrC(subject) );

    messageData->SetSubjectL( &subj );

    // Body

    CParaFormatLayer* paraFormat = CParaFormatLayer::NewL();

    CleanupStack::PushL( paraFormat );

    CCharFormatLayer* charFormat = CCharFormatLayer::NewL();

    CleanupStack::PushL( charFormat );

    CRichText* bodyRichText = CRichText::NewL( paraFormat, charFormat );

    CleanupStack::PushL( bodyRichText );

    TPtrC bodyPtr( qt_QString2TPtrC(body) );

    if( bodyPtr.Length() )

        bodyRichText->InsertL( 0, bodyPtr );

    else

        bodyRichText->InsertL( 0, KNullDesC );

    messageData->SetBodyTextL( bodyRichText );

    // To

    foreach(QString item, recipients)

        messageData->AppendToAddressL(qt_QString2TPtrC(item));

    foreach(QString item, tos)

        messageData->AppendToAddressL(qt_QString2TPtrC(item));

    // Cc

    foreach(QString item, ccs)

        messageData->AppendCcAddressL(qt_QString2TPtrC(item));

    // Bcc

    foreach(QString item, bccs)

        messageData->AppendBccAddressL(qt_QString2TPtrC(item));

    TRAP_IGNORE(sendUi->CreateAndSendMessageL( KUidMsgTypeSMTP, messageData ));

    CleanupStack::PopAndDestroy( 5 ); // bodyRichText, charFormat, paraFormat, messageData, sendUi

}

// Returned TPtrC is valid as long as the given parameter is valid and unmodified

TPtrC DefSchemeHandlerPrivate::qt_QString2TPtrC( const QString& string )

{

    return reinterpret_cast<const TUint16*>(string.utf16());

}

#endif // Q_OS_SYMBIAN

#if !defined(Q_OS_SYMBIAN) 

/*

 * HandleRtspScheme

 * @return  true/false

 */

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleRtspScheme(const QUrl &url)

{

    SchemeHandler::SchemeHandlerError retVal = SchemeHandler::NoError;

#ifndef QT_NO_DESKTOPSERVICES

    if (!QDesktopServices::openUrl(url)) {

        // Failed to handle scheme

        retVal = SchemeHandler::LaunchFailed;

    }

#else

    retVal = SchemeHandler::SchemeUnsupported;

#endif

    return (retVal);

}

#else // Q_OS_SYMBIAN

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleTelScheme(const QUrl &url)

{

    QDesktopServices::openUrl(url);

    return SchemeHandler::NoError;

}

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleSipScheme(const QUrl &url)

{

    QDesktopServices::openUrl(url);

    return SchemeHandler::NoError;

}

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleWtaiMcScheme(const QUrl &url)

{

    QString path = url.path();

    QString number = path.mid(path.indexOf(';') + 1);

    number = "tel:" + number;

    QUrl dialUrl(number);

    QDesktopServices::openUrl(dialUrl);

    return SchemeHandler::NoError;

}

/*

 * HandleRtspSchemeL

 * @return  true/false

 */

SchemeHandler::SchemeHandlerError DefSchemeHandlerPrivate::HandleRtspScheme(const QUrl &url)

{

    TRAPD(err, HandleRtspSchemeL(url));

    return (err ? SchemeHandler::LaunchFailed : SchemeHandler::NoError);

}

void DefSchemeHandlerPrivate::HandleRtspSchemeL(const QUrl &url)

{

    //Launch the appropriate application in embedded mode 

    RFs rfs;

    RFile ramFile;

    HBufC* urlBuf = qt_QString2HBufC(url.toString());

    CleanupStack::PushL(urlBuf);

    // 8-bit buffer is required.

    HBufC8* urlBuf8 = HBufC8::NewLC( urlBuf->Size() );

    urlBuf8->Des().Copy( *urlBuf );

    // Open the file.

    User::LeaveIfError(rfs.Connect());

    CleanupClosePushL(rfs);

    // Replace file if exists or Create file if not exist yet

    User::LeaveIfError( ramFile.Replace( rfs, KRtspFileName, EFileWrite | EFileShareAny ) );

    CleanupClosePushL(ramFile);

    // Write to file      

    User::LeaveIfError( ramFile.Write(*urlBuf8) );

    ramFile.Flush();

    CleanupStack::PopAndDestroy(/*ramFile*/);

    CleanupStack::PopAndDestroy(/*rfs*/);

    CleanupStack::PopAndDestroy( /*urlBuf8*/ );

    CleanupStack::PopAndDestroy( /*urlBuf*/ );

    RFile ramDocTempFile;

    CDocumentHandler* docHandler = CDocumentHandler::NewL();

    docHandler->OpenTempFileL( KRtspFileName, ramDocTempFile );

    CleanupClosePushL( ramDocTempFile );

    TDataType dataType( _L8("audio/x-pn-realaudio-plugin") );

    CAiwGenericParamList* paramList = CAiwGenericParamList::NewLC();

    TAiwVariant filename( _L8("c:\\system\\temp\\RtspTemp.ram") );

    TAiwGenericParam param( EGenericParamFile, filename );

    paramList->AppendL( param );    

    // Allow save among Options

    TBool allowSave( ETrue );

    TAiwVariant allowSaveVariant( allowSave );

    TAiwGenericParam genericParamAllowSave

                     ( EGenericParamAllowSave, allowSaveVariant );

    paramList->AppendL( genericParamAllowSave );

    // launch RAM file via DocHandler

    docHandler->OpenFileEmbeddedL( ramDocTempFile, dataType, *paramList );

    CleanupStack::PopAndDestroy( paramList );

    CleanupStack::PopAndDestroy( &ramDocTempFile );

}

HBufC* DefSchemeHandlerPrivate::qt_QString2HBufC(const QString& string) {

    TPtrC16 str(reinterpret_cast<const TUint16*>(string.utf16()));

    return str.Alloc();

}

#endif // Q_OS_SYMBIAN

} // WRT