/*

  Copyright (C) 2006 Enrico Ros <enrico.ros@m31engineering.it>

  Copyright (C) 2007 Trolltech ASA

  Copyright (C) 2007 Staikos Computing Services Inc.  <info@staikos.net>

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Library General Public

  License as published by the Free Software Foundation; either

  version 2 of the License, or (at your option) any later version.

  This library 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

  Library General Public License for more details.

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

  along with this library; see the file COPYING.LIB.  If not, write to

  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

  Boston, MA 02110-1301, USA.

  This class provides all functionality needed for loading images, style sheets and html

  pages from the web. It has a memory cache for these objects.

*/

#include <qglobal.h>

#include "qwebframe.h"

#include "qwebnetworkinterface.h"

#include "qwebnetworkinterface_p.h"

#include "qwebobjectpluginconnector.h"

#include "qwebpage.h"

#include <qdebug.h>

#include <qfile.h>

#include <qnetworkproxy.h>

#include <qurl.h>

#include <QAuthenticator>

#include <QCoreApplication>

#include <QSslError>

#include "ResourceHandle.h"

#include "ResourceHandleClient.h"

#include "ResourceHandleInternal.h"

#include "MIMETypeRegistry.h"

#include "CookieJar.h"

#define notImplemented() qDebug("FIXME: UNIMPLEMENTED: %s:%d (%s)", __FILE__, __LINE__, __FUNCTION__)

#if 0

#define DEBUG qDebug

#else

#define DEBUG if (1) {} else qDebug

#endif

static QWebNetworkInterface *default_interface = 0;

static QWebNetworkManager *manager = 0;

using namespace WebCore;

uint qHash(const HostInfo &info)

{

    return qHash(info.host) + info.port;

}

static bool operator==(const HostInfo &i1, const HostInfo &i2)

{

    return i1.port == i2.port && i1.host == i2.host;

}

void QWebNetworkRequestPrivate::init(const WebCore::ResourceRequest &resourceRequest)

{

    KURL url = resourceRequest.url();

    QUrl qurl = QString(url.url());

    init(resourceRequest.httpMethod(), qurl, &resourceRequest);

}

void QWebNetworkRequestPrivate::init(const QString &method, const QUrl &url, const WebCore::ResourceRequest *resourceRequest)

{

    httpHeader = QHttpRequestHeader(method, url.toString(QUrl::RemoveScheme|QUrl::RemoveAuthority));

    httpHeader.setValue(QLatin1String("User-Agent"),

                         QLatin1String("Mozilla/5.0 (PC; U; Intel; Linux; en) AppleWebKit/420+ (KHTML, like Gecko)"));

    httpHeader.setValue(QLatin1String("Connection"), QLatin1String("Keep-Alive"));

    setURL(url);

    if (resourceRequest) {

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

        if (scheme == QLatin1String("http") || scheme == QLatin1String("https")) {

            QString cookies = WebCore::cookies(resourceRequest->url());

            if (!cookies.isEmpty())

                httpHeader.setValue(QLatin1String("Cookie"), cookies);

        }

        const HTTPHeaderMap& loaderHeaders = resourceRequest->httpHeaderFields();

        HTTPHeaderMap::const_iterator end = loaderHeaders.end();

        for (HTTPHeaderMap::const_iterator it = loaderHeaders.begin(); it != end; ++it)

            httpHeader.setValue(it->first, it->second);

        // handle and perform a 'POST' request

        if (method == "POST") {

            DeprecatedString pd = resourceRequest->httpBody()->flattenToString().deprecatedString();

            postData = QByteArray(pd.ascii(), pd.length());

            httpHeader.setValue(QLatin1String("content-length"), QString::number(postData.size()));

        }

    }

}

void QWebNetworkRequestPrivate::setURL(const QUrl &u)

{

    url = u;

    int port = url.port();

    const QString scheme = u.scheme();

    if (port > 0 && (port != 80 || scheme != "http") && (port != 443 || scheme != "https"))

        httpHeader.setValue(QLatin1String("Host"), url.host() + QLatin1Char(':') + QString::number(port));

    else

        httpHeader.setValue(QLatin1String("Host"), url.host());

}

/*!

  \class QWebNetworkRequest

  The QWebNetworkRequest class represents a request for data from the network with all the

  necessary information needed for retrieval. This includes the url, extra HTTP header fields

  as well as data for a HTTP POST request.

*/

QWebNetworkRequest::QWebNetworkRequest()

    : d(new QWebNetworkRequestPrivate)

{

}

QWebNetworkRequest::QWebNetworkRequest(const QUrl &url, Method method, const QByteArray &postData)

    : d(new QWebNetworkRequestPrivate)

{

    d->init(method == Get ? "GET" : "POST", url);

    d->postData = postData;

}

QWebNetworkRequest::QWebNetworkRequest(const QWebNetworkRequest &other)

    : d(new QWebNetworkRequestPrivate(*other.d))

{

}

QWebNetworkRequest &QWebNetworkRequest::operator=(const QWebNetworkRequest &other)

{

    *d = *other.d;

    return *this;

}

/*!

  \internal

*/

QWebNetworkRequest::QWebNetworkRequest(const QWebNetworkRequestPrivate &priv)

    : d(new QWebNetworkRequestPrivate(priv))

{

}

/*!

  \internal

*/

QWebNetworkRequest::QWebNetworkRequest(const WebCore::ResourceRequest &request)

    : d(new QWebNetworkRequestPrivate)

{

    d->init(request);

}

QWebNetworkRequest::~QWebNetworkRequest()

{

    delete d;

}

/*!

  The requested URL

*/

QUrl QWebNetworkRequest::url() const

{

    return d->url;

}

/*!

   Sets the URL to request.

   Note that setting the URL also sets the "Host" field in the HTTP header.

*/

void QWebNetworkRequest::setUrl(const QUrl &url)

{

    d->setURL(url);

}

/*!

   The http request header information.

*/

QHttpRequestHeader QWebNetworkRequest::httpHeader() const

{

    return d->httpHeader;

}

void QWebNetworkRequest::setHttpHeader(const QHttpRequestHeader &header) const

{

    d->httpHeader = header;

}

QString QWebNetworkRequest::httpHeaderField(const QString &key) const

{

    return d->httpHeader.value(key);

}

void QWebNetworkRequest::setHttpHeaderField(const QString &key, const QString &value)

{

    d->httpHeader.setValue(key, value);

}

/*!

    Post data sent with HTTP POST requests.

*/

QByteArray QWebNetworkRequest::postData() const

{

    return d->postData;

}

void QWebNetworkRequest::setPostData(const QByteArray &data)

{

    d->postData = data;

}

/*!

  \class QWebNetworkJob

  The QWebNetworkJob class represents a network job, that needs to be

  processed by the QWebNetworkInterface.

  This class is only required when implementing a new network layer (or

  support for a special protocol) using QWebNetworkInterface.

  QWebNetworkJob objects are created and owned by the QtWebKit library.

  Most of it's properties are read-only.

  The job is reference counted. This can be used to ensure that the job doesn't

  get deleted while it's still stored in some data structure.

*/

/*!

  \internal

*/

QWebNetworkJob::QWebNetworkJob()

    : d(new QWebNetworkJobPrivate)

{

    d->ref = 1;

    d->redirected = false;

    d->interface = 0;

}

/*!

  \internal

*/

QWebNetworkJob::~QWebNetworkJob()

{

    delete d;

}

/*!

  The requested URL

*/

QUrl QWebNetworkJob::url() const

{

    return d->request.url;

}

/*!

  Post data associated with the job

*/

QByteArray QWebNetworkJob::postData() const

{

    return d->request.postData;

}

/*!

  The HTTP request header that should be used to download the job.

*/

QHttpRequestHeader QWebNetworkJob::httpHeader() const

{

    return d->request.httpHeader;

}

/*!

  The complete network request that should be used to download the job.

*/

QWebNetworkRequest QWebNetworkJob::request() const

{

    return QWebNetworkRequest(d->request);

}

/*!

  The HTTP response header received from the network.

*/

QHttpResponseHeader QWebNetworkJob::response() const

{

    return d->response;

}

/*!

  Sets the HTTP reponse header. The response header has to be called before

  emitting QWebNetworkInterface::started.

*/

void QWebNetworkJob::setResponse(const QHttpResponseHeader &response)

{

    d->response = response;

}

/*!

  returns true if the job has been cancelled by the WebKit framework

*/

bool QWebNetworkJob::cancelled() const

{

    return !d->resourceHandle && !d->connector;

}

/*!

  reference the job.

*/

void QWebNetworkJob::ref()

{

    ++d->ref;

}

/*!

  derefence the job.

  If the reference count drops to 0 this method also deletes the job.

  Returns false if the reference count has dropped to 0.

*/

bool QWebNetworkJob::deref()

{

    if (!--d->ref) {

        delete this;

        return false;

    }

    return true;

}

/*!

   Returns the network interface that is associated with this job.

*/

QWebNetworkInterface *QWebNetworkJob::networkInterface() const

{

    return d->interface;

}

/*!

   Returns the network interface that is associated with this job.

*/

QWebFrame *QWebNetworkJob::frame() const

{

    if (d->resourceHandle) {

        ResourceHandleInternal *rhi = d->resourceHandle->getInternal();

        if (rhi) {

            return rhi->m_frame;

        }

    }

    return 0;

}

/*!

  \class QWebNetworkManager

  \internal

*/

QWebNetworkManager::QWebNetworkManager()

    : QObject(0)

{

}

QWebNetworkManager *QWebNetworkManager::self()

{

    // ensure everything's constructed and connected

    QWebNetworkInterface::defaultInterface();

    return manager;

}

bool QWebNetworkManager::add(ResourceHandle *handle, QWebNetworkInterface *interface)

{

    if (!interface)

        interface = default_interface;

    ASSERT(interface);

    QWebNetworkJob *job = new QWebNetworkJob();

    handle->getInternal()->m_job = job;

    job->d->resourceHandle = handle;

    job->d->interface = interface;

    job->d->connector = 0;

    job->d->request.init(handle->request());

    const QString method = handle->getInternal()->m_request.httpMethod();

    if (method != "POST" && method != "GET") {

        // don't know what to do! (probably a request error!!)

        // but treat it like a 'GET' request

        qWarning("REQUEST: [%s]\n", qPrintable(job->d->request.httpHeader.toString()));

    }

    DEBUG() << "QWebNetworkManager::add:" <<  job->d->request.httpHeader.toString();

    interface->addJob(job);

    return true;

}

void QWebNetworkManager::cancel(ResourceHandle *handle)

{

    QWebNetworkJob *job = handle->getInternal()->m_job;

    if (!job)

        return;

    DEBUG() << "QWebNetworkManager::cancel:" <<  job->d->request.httpHeader.toString();

    job->d->resourceHandle = 0;

    job->d->connector = 0;

    job->d->interface->cancelJob(job);

    handle->getInternal()->m_job = 0;

}

void QWebNetworkManager::started(QWebNetworkJob *job)

{

    ResourceHandleClient* client = 0;

    if (job->d->resourceHandle) {

        client = job->d->resourceHandle->client();

        if (!client)

            return;

    } else if (!job->d->connector) {

        return;

    }

    DEBUG() << "ResourceHandleManager::receivedResponse:";

    DEBUG() << job->d->response.toString();

    QStringList cookies = job->d->response.allValues("Set-Cookie");

    KURL url(job->url().toString());

    foreach (QString c, cookies) {

        setCookies(url, url, c);

    }

    QString contentType = job->d->response.value("Content-Type");

    QString encoding;

    int idx = contentType.indexOf(QLatin1Char(';'));

    if (idx > 0) {

        QString remainder = contentType.mid(idx + 1).toLower();

        contentType = contentType.left(idx).trimmed();

        idx = remainder.indexOf("charset");

        if (idx >= 0) {

            idx = remainder.indexOf(QLatin1Char('='), idx);

            if (idx >= 0)

                encoding = remainder.mid(idx + 1).trimmed();

        }

    }

    if (contentType.isEmpty()) {

        // let's try to guess from the extension

        QString extension = job->d->request.url.path();

        int index = extension.lastIndexOf(QLatin1Char('.'));

        if (index > 0) {

            extension = extension.mid(index + 1);

            contentType = MIMETypeRegistry::getMIMETypeForExtension(extension);

        }

    }

//     qDebug() << "Content-Type=" << contentType;

//     qDebug() << "Encoding=" << encoding;

    ResourceResponse response(url, contentType,

                              0 /* FIXME */,

                              encoding,

                              String() /* FIXME */);

    int statusCode = job->d->response.statusCode();

    response.setHTTPStatusCode(statusCode);

    /* Fill in the other fields */

    if (statusCode >= 300 && statusCode < 400) {

        // we're on a redirect page! if the 'Location:' field is valid, we redirect

        QString location = job->d->response.value("location");

        DEBUG() << "Redirection";

        if (!location.isEmpty()) {

            QUrl newUrl = job->d->request.url.resolved(location);

            if (job->d->resourceHandle) {

                ResourceRequest newRequest = job->d->resourceHandle->request();

                newRequest.setURL(KURL(newUrl.toString()));

                if (client)

                    client->willSendRequest(job->d->resourceHandle, newRequest, response);

            }

            job->d->request.httpHeader.setRequest(job->d->request.httpHeader.method(),

                                                  newUrl.toString(QUrl::RemoveScheme|QUrl::RemoveAuthority));

            job->d->request.setURL(newUrl);

            job->d->redirected = true;

            return;

        }

    }

    if (client)

        client->didReceiveResponse(job->d->resourceHandle, response);

    if (job->d->connector)

        emit job->d->connector->started(job);

}

void QWebNetworkManager::data(QWebNetworkJob *job, const QByteArray &data)

{

    ResourceHandleClient* client = 0;

    if (job->d->resourceHandle) {

        client = job->d->resourceHandle->client();

        if (!client)

            return;

    } else if (!job->d->connector) {

        return;

    }

    if (job->d->redirected)

        return; // don't emit the "Document has moved here" type of HTML

    DEBUG() << "receivedData" << job->d->request.url.path();

    if (client)

        client->didReceiveData(job->d->resourceHandle, data.constData(), data.length(), data.length() /*FixMe*/);

    if (job->d->connector)

        emit job->d->connector->data(job, data);

}

void QWebNetworkManager::finished(QWebNetworkJob *job, int errorCode)

{

    ResourceHandleClient* client = 0;

    if (job->d->resourceHandle) {

        client = job->d->resourceHandle->client();

        if (!client)