/*

* 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 <QNetworkRequest>

#include <QNetworkReply>

#include <QAuthenticator>

#include <QNetworkInterface>

#if QT_VERSION >= 0x040500

#include <QNetworkDiskCache>

#endif

#include "bedrockprovisioning.h"

#include "wrtbrowsercontainer.h"

#include "webcookiejar.h"

#include "webnetworkaccessmanager.h"

#include "WebDialogProvider.h"

#include "networkerrorreply.h"

#include "SchemeHandlerBr.h"

#include <QWebFrame>

namespace WRT {

WebNetworkAccessManager::WebNetworkAccessManager(WrtBrowserContainer* container, QObject* parent) : QNetworkAccessManager(container), m_browserContainer(container)

{

    m_cookieJar = new CookieJar();

    m_reply = NULL;

    this->setCookieJar(m_cookieJar);

    connect(this, SIGNAL(authenticationRequired(QNetworkReply *, QAuthenticator *)), m_browserContainer, SLOT(slotAuthenticationRequired(QNetworkReply *, QAuthenticator *)));

    connect(this, SIGNAL(proxyAuthenticationRequired(const QNetworkProxy & , QAuthenticator * )), m_browserContainer, SLOT(slotProxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *)));

    connect(this, SIGNAL(finished(QNetworkReply *)), this, SLOT(onfinished(QNetworkReply *)));

    setupCache();

    setupNetworkProxy();

}

int WebNetworkAccessManager::activeNetworkInterfaces()

{

  int count = 0;

  QList<QNetworkInterface> allNIFs = QNetworkInterface::allInterfaces();

  foreach (QNetworkInterface aNIF, allNIFs) {

    if (aNIF.isValid() && aNIF.flags() & QNetworkInterface::IsUp && !(aNIF.flags() & QNetworkInterface::IsLoopBack))

        count++;

  }

  return count;

}

void WebNetworkAccessManager::onfinished(QNetworkReply* reply)

{

    QNetworkReply::NetworkError networkError = reply->error();

    QString requestUrl = reply->request().url().toString(); 

    if ( networkError != QNetworkReply::OperationCanceledError && 

        networkError != QNetworkReply::NoError )

    {

        QString errorMsg = reply->errorString();

        if ( activeNetworkInterfaces() == 0 ) {

            errorMsg = "Network not available";

        } else {

            int httpErrorCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();

            if ( httpErrorCode ) {

                QString httpErrorStr = QString ("HTTP %1 ").arg(httpErrorCode);

                QString httpReasonStr = reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();

                errorMsg = httpErrorStr + httpReasonStr;

	          }	  

        }

        emit networkErrorHappened(errorMsg); 

        emit networkErrorUrl(requestUrl);

    }

}

WebNetworkAccessManager::~WebNetworkAccessManager()

{

    delete m_cookieJar;

    setCache(NULL);

}

QNetworkReply* WebNetworkAccessManager::createRequest(Operation op, const QNetworkRequest &request, QIODevice *outgoingData)

{

    QNetworkRequest req = request;

    req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);

	// improve performance by

	// load from cache if available, otherwise load from network. 

	// Note that this can return possibly stale (but not expired) items from cache.

	// QNetworkRequest::PreferNetwork is default value

	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);

    if (m_reply != NULL) {

        delete m_reply;

        m_reply = NULL;

    }

    QNetworkReply* reply = NULL;

    if(m_browserContainer->mainFrame()) {

        if(m_browserContainer->mainFrame()->url().scheme() == "https") {

            if (op == QNetworkAccessManager::PostOperation && req.url().scheme() == "http") {

                m_text = tr("Secure Page Warning:");

                m_informativeText = tr("Do you want to continue?");

                m_detailedText = tr("Submit your data over an unencrypted connection.");

                m_buttons = QMessageBox::Yes | QMessageBox::No;

                m_defaultButton = QMessageBox::Yes;

                m_icon = QMessageBox::Warning;

                m_req = &req;

                emit showMessageBox(this);

                reply =  m_reply;

            }

        }

    }

    if(request.url().scheme() == "qrc")

        { 

            reply = new NetworkErrorReply(QNetworkReply::ProtocolUnknownError, "Unknown scheme", request.url());

            QMetaObject::invokeMethod(reply, "finished", Qt::QueuedConnection);

        }

    if (reply == NULL) {

		reply = createRequestHelper(op, req, outgoingData);

    }

    return reply;

}

void WebNetworkAccessManager::onMessageBoxResponse(int retValue)

{

    if (retValue == QMessageBox::No) {

        m_reply = new NetworkErrorReply(QNetworkReply::ContentAccessDenied, "Not allowed", m_req->url());

        //a finished signal will be sent and the member is invoked as soon as the application enters the main event loop

        QMetaObject::invokeMethod(m_reply, "finished", Qt::QueuedConnection);

    }

}

QNetworkReply* WebNetworkAccessManager::createRequestHelper(Operation op, const QNetworkRequest &request, QIODevice *outgoingData)

{

    QNetworkRequest req = request;

    // Don't load the content if we are restoring the session 

    if (m_browserContainer->restoreSession()) {

        // handled in scheme handler - block network access

        QNetworkReply* reply = new NetworkErrorReply(QNetworkReply::OperationCanceledError, "Page Restored", req.url());

        QMetaObject::invokeMethod(reply, "finished", Qt::QueuedConnection);

        return reply;

    }

    if (m_browserContainer->schemeHandler()->HandleSpecialScheme(req.url())) {

        // handled in scheme handler - block network access

        QNetworkReply* reply = new NetworkErrorReply(QNetworkReply::OperationCanceledError, "Scheme Handled", req.url());

        QMetaObject::invokeMethod(reply, "finished", Qt::QueuedConnection);

        return reply;

    }

    //Accept-Language header

    QLocale language;

    QString langCountryCode = language.name();

    //QLocale::name returns the language and country as a  string of the form "language_country", where

    //language is a lowercase, two-letter ISO 639 language code, and country is an uppercase, two-letter 

    //ISO 3166 country code. But the format is expected to be "language-country". Note that hyphen is expected 

    //instead of underscore.

    langCountryCode.replace(QString("_"), QString("-"));

    req.setRawHeader("Accept-Language", langCountryCode.toUtf8());

    return QNetworkAccessManager::createRequest(op, req, outgoingData);

}

void WebNetworkAccessManager::setupNetworkProxy()

{

   QNetworkProxy proxy;

   QString proxyString = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsString("NetworkProxy");

   QString portString = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsString("NetworkPort");

   if (proxyString.isEmpty())

   	{

      proxy.setType(QNetworkProxy::NoProxy);

      proxy.setHostName("");

      proxy.setPort(0);

   	}

   	else

		{

      proxy.setType(QNetworkProxy::HttpProxy);

      proxy.setHostName(proxyString);

      proxy.setPort(portString.toInt());

 		}

   	setProxy(proxy);

}

// Setup cache

// Need to use WrtSettingsUI to setup Disk Cache Directory Path

void WebNetworkAccessManager::setupCache()

{

#if QT_VERSION >= 0x040500

    qDiskCache = new QNetworkDiskCache(this);

    if ( !BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->value("DiskCacheEnabled").toBool() ) 

		return;

    QString diskCacheDir = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->value("DiskCacheDirectoryPath").toString();

    if(diskCacheDir.isEmpty()) return;

    // setup cache

    qDiskCache->setCacheDirectory(diskCacheDir);

    int cacheMaxSize = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->value("DiskCacheMaxSize").toInt();

    qDiskCache->setMaximumCacheSize(cacheMaxSize);

    setCache(qDiskCache);

#endif

}

}