/**
* Copyright (c) 2010 Sasken Communication Technologies Ltd.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "{License}"
* which accompanies  this distribution, and is available
* at the URL "{LicenseUrl}".
*
* Initial Contributors:
* Narasimhulu Kavadapu, Sasken Communication Technologies Ltd - Initial contribution
*
* Contributors:
* Siddhartha Chandra, Satish Kanteti Sasken Communication Technologies Ltd
* Description:
* Login Dialog class of Authentication Application
*/

#include <qdebug.h>

#include "authAppConstants.h"
#include "sessionSP.h"
#include "errorCodes.h"
#include "loginDialog.h"
#include "keys.h"
#include <QNetworkCookie>
#include <QInputDialog>
#include <QSslConfiguration>

static const QString kStringBoundary = "3i2ndDfv2rTHiSisAbouNdArYfORhtTPEefj3q2f";
///////////////////////////////////////////////////////////////////////////////////////////////////
// global

//static const QString kLoginURL = "http://www.facebook.com/login.php";

///////////////////////////////////////////////////////////////////////////////////////////////////
void FBLoginDialog::connectToGetSession(const QString& aToken)
{
	qDebug()<<"Inside FBLoginDialog::connectToGetSession()";
    iGetSessionRequest = FBRequest::requestWithSession(iSession);
    
    //connect(iGetSessionRequest, SIGNAL(LoadLoginPage()), this, SLOT(LoadLoginPage()));
    connect(iGetSessionRequest, SIGNAL(requestDidLoad(QVariant)), this, SLOT(requestDidLoad(QVariant)));
    connect(iGetSessionRequest, SIGNAL(requestFailedWithNetworkError(QNetworkReply::NetworkError)), this, SLOT(requestFailedWithNetworkError(QNetworkReply::NetworkError)));
    connect(iGetSessionRequest, SIGNAL(requestFailedWithFacebookError(FBError)), this, SLOT(requestFailedWithFacebookError(FBError)));

    Dictionary params;
    params["auth_token"] = aToken;

    if (iSession->apiSecret().length())
    {
        params["generate_session_secret"]="1";
    }

    if (iSession->getSessionProxy().length())
    {
        iGetSessionRequest->post(iSession->getSessionProxy(),params);
    }
    else
    {
        iGetSessionRequest->call("facebook.auth.getSession", params);
    }
}
void FBLoginDialog::connectToGetToken()
	{
		qDebug()<<"Inside FBLoginDialog::connectToGetToken()";
	    iGetSessionRequest = FBRequest::requestWithSession(iSession);

	   // connect(iGetSessionRequest, SIGNAL(requestDidLoad(QVariant)), this, SLOT(requestDidLoad(QVariant)));
	 //   connect(iGetSessionRequest, SIGNAL(requestFailedWithNetworkError(QNetworkReply::NetworkError)), this, SLOT(requestFailedWithNetworkError(QNetworkReply::NetworkError)));
	  //  connect(iGetSessionRequest, SIGNAL(requestFailedWithFacebookError(FBError)), this, SLOT(requestFailedWithFacebookError(FBError)));

	    Dictionary postParams;
		iSession->stroauth_nonce = generateNONCE(43);
		iSession->stroauth_timestamp = generateTimeStamp();//QString::number(generateTimeStamp());
		qDebug()<<"iSession->stroauth_timestamp"<<iSession->stroauth_timestamp;
		//postParams["oauth_callback"] = kBase;
		postParams["oauth_consumer_key"] = kConsumerKey;
		postParams["oauth_signature_method"] = "HMAC-SHA1";
		postParams["oauth_timestamp"] = iSession->stroauth_timestamp;
		postParams["oauth_nonce"] = iSession->stroauth_nonce;
		postParams["oauth_version"] = "1.0";
		FBRequest* req = FBRequest::requestWithSession(iSession);
		iSession->stroauth_signature = req->generateSig(postParams);
	    iGetSessionRequest->call("/uas/oauth/accessToken", postParams);
	    
	}
void FBLoginDialog::loadLoginPage()
{
    iGetSessionRequest = FBRequest::requestWithSession(iSession);
	qDebug()<<"Inside FBLoginDialog::loadLoginPage()";
    Dictionary getParams, postParams;
    iSession->stroauth_nonce = generateNONCE(43);
	iSession->stroauth_timestamp = generateTimeStamp();//QString::number(generateTimeStamp());
	qDebug()<<"iSession->stroauth_timestamp"<<iSession->stroauth_timestamp;
    postParams["oauth_callback"] = "oob";
    postParams["oauth_consumer_key"] = kConsumerKey;
    postParams["oauth_signature_method"] = "HMAC-SHA1";
    postParams["oauth_timestamp"] = iSession->stroauth_timestamp;
    postParams["oauth_nonce"] = iSession->stroauth_nonce;
    postParams["oauth_version"] = "1.0";
   /* FBRequest* req = FBRequest::requestWithSession(iSession);*/
    iSession->stroauth_signature = iGetSessionRequest->generateSig(postParams);
    
    connect(iGetSessionRequest, SIGNAL(LoadLoginPage()), this, SLOT(LoadLoginPage()));
    
    iGetSessionRequest->connect();
    
    
    
    
    
  
    //loadURL(kRequestTokenUrl,QNetworkAccessManager::PostOperation, getParams, postParams);

}
/*int FBLoginDialog::generateTimeStamp()
	{
		QDate oldDate;
		oldDate.setYMD(1970,1,1);
	
		QDateTime OldDateTime;
		OldDateTime.setDate(oldDate);
		QTime temp;
		temp.setHMS(0,0,0,0);
		OldDateTime.setTime(temp);
		QDateTime CurTime = QDateTime::currentDateTime();
		
		int timestamp = OldDateTime.secsTo(CurTime);
		return timestamp;
	}*/
QByteArray FBLoginDialog::generateTimeStamp()
	{
		uint time = QDateTime::currentDateTime().toTime_t();
	    QByteArray timestamp = QByteArray::number( time );
	    return timestamp;
	}
QString FBLoginDialog::generateNONCE(const qint64 Length)
	{
	srand(time(0));
	//QDateTime UniqueNumber = QDateTime::currentDateTime();

	//read upto milliseconds
	QString RetString;//(UniqueNumber.toString("hh/mm/ss/zzz"));

	QString Letters(
			"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");

	//append a randomly generated string to RetString
	for (int i = 0; i < Length; i++)
		{
		RetString.insert((i), Letters.at(rand() % Letters.size()));
		}

	return RetString;
	}
///////////////////////////////////////////////////////////////////////////////////////////////////

FBLoginDialog::FBLoginDialog() : FBDialog () {}

FBLoginDialog::FBLoginDialog(FBSession* aSession) : FBDialog(aSession) {}

///////////////////////////////////////////////////////////////////////////////////////////////////
// FBDialog

void FBLoginDialog::load()
{
	qDebug()<<"Inside FBLoginDialog::load()";
    loadLoginPage();
}

void FBLoginDialog::dialogWillDisappear()
{
	qDebug()<<"Inside FBLoginDialog::dialogWillDisappear()";
  iGetSessionRequest->cancel();

  if (!iSession->isConnected())
  {
      iSession->cancelLogin();
  }
}

void FBLoginDialog::GetSessionKey(const QUrl& aUrl)
{
	qDebug()<<"Inside FBLoginDialog::GetSessionKey()";
    const QString authToken = "auth_token=";
    const QString url ( aUrl.toString() );

    int start = url.indexOf(authToken);
    if (start != -1)
    {
        QString token;
        int end = url.indexOf("&", start);
        int delta = start + authToken.size() + 1;
        if (end != -1)
        {
            token = url.mid(delta, end - delta );
        }
        else
        {
            token = url.right(url.size() - delta + 1);
        }

        connectToGetSession(token);
    }
}
void FBLoginDialog::FetchKeyFromUrl(const QUrl& aUrl)
{
    const QString url ( aUrl.toString() );
    QStringList varList = url.split("{");
    QString newvar = varList[1];
    varList.clear();
    varList = newvar.split(",");
    QString session_key = varList[0];
    QString uid = varList[1];
    QString expires = varList[2];
    QString secret = varList[3];
    varList.clear();
    varList = session_key.split(":");
    session_key = varList[1];
    session_key = session_key.mid(1,session_key.length()-2);
    varList.clear();
    varList = uid.split(":");
    uid = varList[1];
	varList.clear();
	varList = expires.split(":");
	expires = varList[1];
	varList.clear();
	varList = secret.split(":");
	secret = varList[1];
	secret = secret.mid(1,secret.length()-2);
	varList.clear();
    qDebug()<<"session_key"<<session_key<<"\n";
    qDebug()<<"uid"<<uid<<"\n";
    qDebug()<<"expires"<<expires<<"\n";
    qDebug()<<"secret"<<secret<<"\n";
    uint expiry = expires.toUInt();//.toUInt(&conversionError);
    QDateTime expiration; expiration.setTime_t( expiry );
    iSession->beginSession(session_key, secret,expiration);
    iSession->resume();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// slots for signals from FBRequest

void FBLoginDialog::requestDidLoad(const QVariant& aResult)
{
	qDebug()<<"Inside FBLoginDialog::requestDidLoad";
    bool conversionError = false;
    QVariantHash object = aResult.toHash();
    QString sessionKey = object.value("session_key").toString();
    QString sessionSecret = object.value("secret").toString();

    QVariant ex = object.value("expires");
    uint expires = object.value("expires").toUInt(&conversionError);
    QDateTime expiration; expiration.setTime_t( expires );

    iSession->beginSession(sessionKey, sessionSecret,expiration);
    iSession->resume();

    dismissWithSuccess(true, true);
}

void FBLoginDialog::requestFailedWithFacebookError (const FBError& aCode )
{
	qDebug()<<"Inside FBLoginDialog::requestFailedWithFacebookError()";
    dismissWithError(aCode, true);
}

void FBLoginDialog::requestFailedWithNetworkError( QNetworkReply::NetworkError aCode )
{
	qDebug()<<"Inside FBLoginDialog::requestFailedWithNetworkError()";
    dismissWithError(aCode, true);
}
void FBLoginDialog::LoadLoginPage()
	{
	
	qDebug()<<"Enter: LoadLoginPage()";
	QString LoginUrl = "https://api.linkedin.com/uas/oauth/authorize?oauth_token=";//94ab03c4-ae2c-45e4-8732-0e6c4899db63";
	LoginUrl += iSession->stroauth_Token;
    proxysettings();
	qDebug()<<"LoginUrl:"<<LoginUrl;
	//TBuf<1024> sid(LoginUrl.utf16()); //uncomment to invoke browser
	//LaunchBrowserL(sid); //uncomment to invoke browser
	QNetworkRequest request;
	QSslConfiguration config = request.sslConfiguration();
	config.setProtocol(QSsl::SslV3);
	request.setSslConfiguration(config);
	request.setUrl(QUrl(LoginUrl));
	iWebView->load(request,QNetworkAccessManager::PostOperation); //uncomment to invoke browser


	qDebug()<<"Exit: LoadLoginPage()";
	   
	}
void FBLoginDialog::LaunchBrowserL(const TDesC& aUrl)
{
	qDebug()<<"Enter: LaunchBrowserL()";
	const TInt KWmlBrowserUid = 0x10008D39;
	TUid id( TUid::Uid( KWmlBrowserUid ) );
	TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
	TApaTask task = taskList.FindApp( id );
	if ( task.Exists() )
	{
		qDebug()<<"Inside: if()";
		HBufC8* param = HBufC8::NewLC( aUrl.Length() + 2);
                //"4 " is to Start/Continue the browser specifying a URL
		param->Des().Append(_L("4 "));
		param->Des().Append(aUrl);
		task.SendMessage( TUid::Uid( 0 ), *param ); // Uid is not used
		CleanupStack::PopAndDestroy(param);
	}
	else
	{
		qDebug()<<"Inside: else()";
		HBufC16* param = HBufC16::NewLC( aUrl.Length() + 2);
                //"4 " is to Start/Continue the browser specifying a URL
		param->Des().Append(_L("4 "));
		param->Des().Append(aUrl);
		RApaLsSession appArcSession;
                // connect to AppArc server 
		User::LeaveIfError(appArcSession.Connect()); 
		TThreadId id;
		appArcSession.StartDocument( *param, TUid::Uid( KWmlBrowserUid)
                                                                       , id );
		appArcSession.Close(); 
		CleanupStack::PopAndDestroy(param);
	}
}
void FBLoginDialog::GetAccessToken()
	{
		/*qDebug()<<"Inside FBLoginDialog::GetAccessToken()";
	    Dictionary getParams, postParams;
	    iSession->stroauth_nonce = generateNONCE(43);
		iSession->stroauth_timestamp = generateTimeStamp();//QString::number(generateTimeStamp());
		qDebug()<<"iSession->stroauth_timestamp"<<iSession->stroauth_timestamp;
	  
	    postParams["oauth_consumer_key"] = kConsumerKey;
	    postParams["oauth_signature_method"] = "HMAC-SHA1";
	    postParams["oauth_timestamp"] = iSession->stroauth_timestamp;
	    postParams["oauth_nonce"] = iSession->stroauth_nonce;
	    postParams["oauth_version"] = "1.0";
	
	    iSession->stroauth_signature = iGetSessionRequest->generateSig(postParams);*/
	}