/**
* 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, Sasken Communication Technologies Ltd
* Description:
* class to maintian session & all credential keys.
*/

#include "sessionSP.h"
#include "requestSP.h"
#include <qfile.h>
#include <QTimer>
#include <qdebug.h>

#include "keys.h"

///////////////////////////////////////////////////////////////////////////////////////////////////
// global

static const QString kAPIRestURL = "http://api.facebook.com/restserver.php";
static const QString kAPIRestSecureURL = "https://api.facebook.com/restserver.php";


static const int kMaxBurstRequests = 3;
static const int kBurstDuration = 2;

static FBSession* sharedSession = NULL;

///////////////////////////////////////////////////////////////////////////////////////////////////
// Static class functions
FBSession* FBSession::session()
{
    return sharedSession;
}

void FBSession::setSession(FBSession* aSession)
{
    sharedSession = aSession;
}


FBSession* FBSession::sessionForApplication ( const QString& aAppKey, const QString& aAppSecret, const QString& aSessionProxy)
{
    FBSession* session = new FBSession ( aAppKey, aAppSecret, aSessionProxy );
    
    return session;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// instance public functions
FBSession::FBSession( const QString& aAppKey, const QString& aAppSecret, const QString& aGetSessionProxy ) :
        iApiKey (aAppKey),
        iApiSecret ( aAppSecret ),
        iGetSessionProxy ( aGetSessionProxy ),
        iRequestBurstCount(0),
        m_Client(new SmfCredMgrClient(this))	
{
    if (!sharedSession)
    {
        sharedSession = this;
    }
    
}

FBSession::~FBSession()
{
	if(m_Client){
		delete m_Client;
		m_Client = NULL;
	}
}

const QString& FBSession::apiURL() const
{
    return kBase;
}

const QString& FBSession::apiSecureURL() const
{
    return kAPIRestSecureURL;
}

bool FBSession::isConnected() const
{
    return iSessionKey.length() > 0 ;
}


void FBSession::beginSession (const QString& aSessionKey, const QString& aSessionSecret, const QDateTime& aExpires )
{
	qDebug()<<"Inside FBSession::beginSession()";
    iSessionKey = aSessionKey;
    iSessionSecret = aSessionSecret;


    iExpirationDate = aExpires;

    save();
}

bool FBSession::resume()
{
	qDebug()<<"Inside FBSession::resume()";
	QString fbCMRegToken = iSettings.value("FBCMRegToken").toString();
	QDateTime fbExpiryTime = iSettings.value("FBExpiryTime").toDateTime();
	SmfAuthParams Params;
	if(m_Client->AuthDataSet(fbCMRegToken,fbExpiryTime,Params))
	{
		QByteArray accessToken = Params.value("accessToken");
		emit sessionDidLogin( accessToken );
        return true;
    }
    return false;
}

void FBSession::cancelLogin() {
	qDebug()<<"Inside FBSession::cancelLogin()";
    if (!isConnected()) {
        emit sessionDidNotLogin();
    }
}

void FBSession::logout() {
	qDebug()<<"Inside FBSession::logout()";
	iExpirationDate = QDateTime();
	iSessionKey.clear();
	iSessionSecret.clear();
	
	unsave();
	
	emit sessionDidLogout();
}

void FBSession::send (FBRequest* aRequest) {
	qDebug()<<"Inside FBSession::send()";
    performRequest (aRequest, true);
}


///////////////////////////////////////////////////////////////////////////////////////////////////
// instance private functions
void FBSession::save()
{
	qDebug()<<"Inside FBSession::save()";
    SmfAuthParams Params;
    Params.insert("ApiKey",kApiKey.toAscii());
    Params.insert("ConsumerKey",kConsumerKey.toAscii());
    Params.insert("ConsumerSecret",kConsumerSecret.toAscii());
    Params.insert("oauth_Token",stroauth_Token.toAscii());
    Params.insert("oauth_TokenSecret",stroauth_TokenSecret.toAscii());
    Params.insert("oauth_verifier",stroauth_verifier.toAscii());
    
    QList<QUrl> UrlList;
    UrlList.append(QUrl("https://api.twitter.com/oauth/"));

    QStringList PluginList;
    PluginList.append(QString("twitter.qtplugin"));

    QString UID("0xEFE2EF23");
    
    //Currently Hardcoded with current time bcoz CM is not handling expiry time as '0' value
    iExpirationDate = QDateTime::currentDateTime();
    iExpirationDate.addYears(1);
    
    QString twCMRegToken = m_Client->StoreAuthData(Params,iExpirationDate,UrlList,PluginList,UID,true);
    qDebug()<<"Reg token returned by auth app = "<<twCMRegToken;
    
    iSettings.remove("twCMRegToken");
    iSettings.remove("twExpiryTime");
    
    if(twCMRegToken.size()){
    	iSettings.setValue("twCMRegToken", twCMRegToken);
    	iSettings.setValue("twExpiryTime", iExpirationDate);
    }
}

void FBSession::unsave()
{
	qDebug()<<"Inside FBSession::unsave()";
	//Delete saved keys from Credential Manager.
}

void FBSession::startFlushTimer()
{
	int t = kBurstDuration;
    QTimer::singleShot( t, this, SLOT(requestTimerReady()));
}

void FBSession::enqueueRequest(FBRequest* aRequest)
{
    iRequestQueue.append(aRequest);
    startFlushTimer();
}

bool FBSession::performRequest(FBRequest* aRequest, bool aEnqueue) {
    // Stagger requests that happen in short bursts to prevent the server from rejecting
    // them for making too many requests in a short time

    int seconds = iLastRequestTime.secsTo( QDateTime::currentDateTime() );
	bool burst = seconds && (seconds < kBurstDuration);

	if (burst && (iRequestBurstCount > kMaxBurstRequests))
    {
        if (aEnqueue)
        {
            enqueueRequest(aRequest);
        }
        return false;
    }
    else
    {
        aRequest->connect();
		if (burst) {
			iRequestBurstCount++;
		} else {
            iRequestBurstCount = 1;
            iLastRequestTime = aRequest->timeStamp();
        }
    }
    return true;
}

void FBSession::flushRequestQueue()
{
    while ( iRequestQueue.count() ) {
      FBRequest* request = iRequestQueue.at(0);
      if (performRequest(request, false)) {
          iRequestQueue.removeAt(0);
      } else {
        startFlushTimer();
        break;
      }
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// instance provate slots
void FBSession::requestTimerReady()
{
    flushRequestQueue();
}
void FBSession::send_req (QString uri,FBRequest* aRequest)
	{
		aRequest->connect_req(uri);
	}