/*

 * Copyright (C) 2008 Collabora Ltd.

 * Copyright (C) 2009 Gustavo Noronha Silva <gns@gnome.org>

 *

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

 */

#include "config.h"

#include <glib/gi18n-lib.h>

#include "GRefPtr.h"

#include "Noncopyable.h"

#include "NotImplemented.h"

#include "ResourceHandleClient.h"

#include "ResourceHandleInternal.h"

#include "ResourceRequest.h"

#include "ResourceResponse.h"

#include "webkitdownload.h"

#include "webkitenumtypes.h"

#include "webkitmarshal.h"

#include "webkitnetworkresponse.h"

#include "webkitprivate.h"

#include <wtf/text/CString.h>

#include <glib/gstdio.h>

#ifdef ERROR

#undef ERROR

#endif

using namespace WebKit;

using namespace WebCore;

/**

 * SECTION:webkitdownload

 * @short_description: Object used to communicate with the application when downloading.

 *

 * #WebKitDownload carries information about a download request,

 * including a #WebKitNetworkRequest object. The application may use

 * this object to control the download process, or to simply figure

 * out what is to be downloaded, and do it itself.

 */

class DownloadClient : public Noncopyable, public ResourceHandleClient {

    public:

        DownloadClient(WebKitDownload*);

        virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);

        virtual void didReceiveData(ResourceHandle*, const char*, int, int);

        virtual void didFinishLoading(ResourceHandle*);

        virtual void didFail(ResourceHandle*, const ResourceError&);

        virtual void wasBlocked(ResourceHandle*);

        virtual void cannotShowURL(ResourceHandle*);

    private:

        WebKitDownload* m_download;

};

#define WEBKIT_DOWNLOAD_GET_PRIVATE(obj)    (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_DOWNLOAD, WebKitDownloadPrivate))

struct _WebKitDownloadPrivate {

    gchar* destinationURI;

    gchar* suggestedFilename;

    guint64 currentSize;

    GTimer* timer;

    WebKitDownloadStatus status;

    GFileOutputStream* outputStream;

    DownloadClient* downloadClient;

    WebKitNetworkRequest* networkRequest;

    WebKitNetworkResponse* networkResponse;

    RefPtr<ResourceHandle> resourceHandle;

};

enum {

    // Normal signals.

    ERROR,

    LAST_SIGNAL

};

static guint webkit_download_signals[LAST_SIGNAL] = { 0 };

enum {

    PROP_0,

    PROP_NETWORK_REQUEST,

    PROP_DESTINATION_URI,

    PROP_SUGGESTED_FILENAME,

    PROP_PROGRESS,

    PROP_STATUS,

    PROP_CURRENT_SIZE,

    PROP_TOTAL_SIZE,

    PROP_NETWORK_RESPONSE

};

G_DEFINE_TYPE(WebKitDownload, webkit_download, G_TYPE_OBJECT);

static void webkit_download_set_response(WebKitDownload* download, const ResourceResponse& response);

static void webkit_download_set_status(WebKitDownload* download, WebKitDownloadStatus status);

static void webkit_download_dispose(GObject* object)

{

    WebKitDownload* download = WEBKIT_DOWNLOAD(object);

    WebKitDownloadPrivate* priv = download->priv;

    if (priv->outputStream) {

        g_object_unref(priv->outputStream);

        priv->outputStream = NULL;

    }

    if (priv->networkRequest) {

        g_object_unref(priv->networkRequest);

        priv->networkRequest = NULL;

    }

    if (priv->networkResponse) {

        g_object_unref(priv->networkResponse);

        priv->networkResponse = NULL;

    }

    G_OBJECT_CLASS(webkit_download_parent_class)->dispose(object);

}

static void webkit_download_finalize(GObject* object)

{

    WebKitDownload* download = WEBKIT_DOWNLOAD(object);

    WebKitDownloadPrivate* priv = download->priv;

    // We don't call webkit_download_cancel() because we don't want to emit

    // signals when finalizing an object.

    if (priv->resourceHandle) {

        if (priv->status == WEBKIT_DOWNLOAD_STATUS_STARTED) {

            priv->resourceHandle->setClient(0);

            priv->resourceHandle->cancel();

        }

        priv->resourceHandle.release();

    }

    delete priv->downloadClient;

    // The download object may never have _start called on it, so we

    // need to make sure timer is non-NULL.

    if (priv->timer) {

        g_timer_destroy(priv->timer);

        priv->timer = NULL;

    }

    g_free(priv->destinationURI);

    g_free(priv->suggestedFilename);

    G_OBJECT_CLASS(webkit_download_parent_class)->finalize(object);

}

static void webkit_download_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)

{

    WebKitDownload* download = WEBKIT_DOWNLOAD(object);

    switch(prop_id) {

    case PROP_NETWORK_REQUEST:

        g_value_set_object(value, webkit_download_get_network_request(download));

        break;

    case PROP_NETWORK_RESPONSE:

        g_value_set_object(value, webkit_download_get_network_response(download));

        break;

    case PROP_DESTINATION_URI:

        g_value_set_string(value, webkit_download_get_destination_uri(download));

        break;

    case PROP_SUGGESTED_FILENAME:

        g_value_set_string(value, webkit_download_get_suggested_filename(download));

        break;

    case PROP_PROGRESS:

        g_value_set_double(value, webkit_download_get_progress(download));

        break;

    case PROP_STATUS:

        g_value_set_enum(value, webkit_download_get_status(download));

        break;

    case PROP_CURRENT_SIZE:

        g_value_set_uint64(value, webkit_download_get_current_size(download));

        break;

    case PROP_TOTAL_SIZE:

        g_value_set_uint64(value, webkit_download_get_total_size(download));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static void webkit_download_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec *pspec)

{

    WebKitDownload* download = WEBKIT_DOWNLOAD(object);

    WebKitDownloadPrivate* priv = download->priv;

    switch(prop_id) {

    case PROP_NETWORK_REQUEST:

        priv->networkRequest = WEBKIT_NETWORK_REQUEST(g_value_dup_object(value));

        break;

    case PROP_NETWORK_RESPONSE:

        priv->networkResponse = WEBKIT_NETWORK_RESPONSE(g_value_dup_object(value));

        break;

    case PROP_DESTINATION_URI:

        webkit_download_set_destination_uri(download, g_value_get_string(value));

        break;

    case PROP_STATUS:

        webkit_download_set_status(download, static_cast<WebKitDownloadStatus>(g_value_get_enum(value)));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static void webkit_download_class_init(WebKitDownloadClass* downloadClass)

{

    GObjectClass* objectClass = G_OBJECT_CLASS(downloadClass);

    objectClass->dispose = webkit_download_dispose;

    objectClass->finalize = webkit_download_finalize;

    objectClass->get_property = webkit_download_get_property;

    objectClass->set_property = webkit_download_set_property;

    webkit_init();

    /**

     * WebKitDownload::error:

     * @download: the object on which the signal is emitted

     * @error_code: the corresponding error code

     * @error_detail: detailed error code for the error, see

     * #WebKitDownloadError

     * @reason: a string describing the error

     *

     * Emitted when @download is interrupted either by user action or by

     * network errors, @error_detail will take any value of

     * #WebKitDownloadError.

     *

     * Since: 1.1.2

     */

    webkit_download_signals[ERROR] = g_signal_new("error",

            G_TYPE_FROM_CLASS(downloadClass),

            (GSignalFlags)G_SIGNAL_RUN_LAST,

            0,

            g_signal_accumulator_true_handled,

            NULL,

            webkit_marshal_BOOLEAN__INT_INT_STRING,

            G_TYPE_BOOLEAN, 3,

            G_TYPE_INT,

            G_TYPE_INT,

            G_TYPE_STRING);

    // Properties.

    /**

     * WebKitDownload:network-request

     *

     * The #WebKitNetworkRequest instance associated with the download.

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass,

                                    PROP_NETWORK_REQUEST,

                                    g_param_spec_object("network-request",

                                                        _("Network Request"),

                                                        _("The network request for the URI that should be downloaded"),

                                                        WEBKIT_TYPE_NETWORK_REQUEST,

                                                        (GParamFlags)(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));

    /**

     * WebKitDownload:network-response

     *

     * The #WebKitNetworkResponse instance associated with the download.

     *

     * Since: 1.1.16

     */

    g_object_class_install_property(objectClass,

                                    PROP_NETWORK_RESPONSE,

                                    g_param_spec_object("network-response",

                                                        _("Network Response"),

                                                        _("The network response for the URI that should be downloaded"),

                                                        WEBKIT_TYPE_NETWORK_RESPONSE,

                                                        (GParamFlags)(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));

    /**

     * WebKitDownload:destination-uri

     *

     * The URI of the save location for this download.

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass,

                                    PROP_DESTINATION_URI,

                                    g_param_spec_string("destination-uri",

                                                        _("Destination URI"),

                                                        _("The destination URI where to save the file"),

                                                        "",

                                                        WEBKIT_PARAM_READWRITE));

    /**

     * WebKitDownload:suggested-filename

     *

     * The file name suggested as default when saving

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass,

                                    PROP_SUGGESTED_FILENAME,

                                    g_param_spec_string("suggested-filename",

                                                        _("Suggested Filename"),

                                                        _("The filename suggested as default when saving"),

                                                        "",

                                                        WEBKIT_PARAM_READABLE));

    /**

     * WebKitDownload:progress:

     *

     * Determines the current progress of the download. Notice that,

     * although the progress changes are reported as soon as possible,

     * the emission of the notify signal for this property is

     * throttled, for the benefit of download managers. If you care

     * about every update, use WebKitDownload:current-size.

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass, PROP_PROGRESS,

                                    g_param_spec_double("progress",

                                                        _("Progress"),

                                                        _("Determines the current progress of the download"),

                                                        0.0, 1.0, 1.0,

                                                        WEBKIT_PARAM_READABLE));

    /**

     * WebKitDownload:status:

     *

     * Determines the current status of the download.

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass, PROP_STATUS,

                                    g_param_spec_enum("status",

                                                      _("Status"),

                                                      _("Determines the current status of the download"),

                                                      WEBKIT_TYPE_DOWNLOAD_STATUS,

                                                      WEBKIT_DOWNLOAD_STATUS_CREATED,

                                                      WEBKIT_PARAM_READABLE));

    /**

     * WebKitDownload:current-size

     *

     * The length of the data already downloaded

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass,

                                    PROP_CURRENT_SIZE,

                                    g_param_spec_uint64("current-size",

                                                        _("Current Size"),

                                                        _("The length of the data already downloaded"),

                                                        0, G_MAXUINT64, 0,

                                                        WEBKIT_PARAM_READABLE));

    /**

     * WebKitDownload:total-size

     *

     * The total size of the file

     *

     * Since: 1.1.2

     */

    g_object_class_install_property(objectClass,

                                    PROP_CURRENT_SIZE,

                                    g_param_spec_uint64("total-size",

                                                        _("Total Size"),

                                                        _("The total size of the file"),

                                                        0, G_MAXUINT64, 0,

                                                        WEBKIT_PARAM_READABLE));

    g_type_class_add_private(downloadClass, sizeof(WebKitDownloadPrivate));

}

static void webkit_download_init(WebKitDownload* download)

{

    WebKitDownloadPrivate* priv = WEBKIT_DOWNLOAD_GET_PRIVATE(download);

    download->priv = priv;

    priv->downloadClient = new DownloadClient(download);

    priv->currentSize = 0;

    priv->status = WEBKIT_DOWNLOAD_STATUS_CREATED;

}

/**

 * webkit_download_new:

 * @request: a #WebKitNetworkRequest

 *

 * Creates a new #WebKitDownload object for the given

 * #WebKitNetworkRequest object.

 *

 * Returns: the new #WebKitDownload

 *

 * Since: 1.1.2

 */

WebKitDownload* webkit_download_new(WebKitNetworkRequest* request)

{

    g_return_val_if_fail(request, NULL);

    return WEBKIT_DOWNLOAD(g_object_new(WEBKIT_TYPE_DOWNLOAD, "network-request", request, NULL));

}

// Internal usage only

WebKitDownload* webkit_download_new_with_handle(WebKitNetworkRequest* request, WebCore::ResourceHandle* handle, const WebCore::ResourceResponse& response)

{

    g_return_val_if_fail(request, NULL);

    ResourceHandleInternal* d = handle->getInternal();

    if (d->m_msg)

        soup_session_pause_message(webkit_get_default_session(), d->m_msg);

    WebKitDownload* download = WEBKIT_DOWNLOAD(g_object_new(WEBKIT_TYPE_DOWNLOAD, "network-request", request, NULL));

    WebKitDownloadPrivate* priv = download->priv;

    handle->ref();

    priv->resourceHandle = handle;

    webkit_download_set_response(download, response);

    return download;

}

static gboolean webkit_download_open_stream_for_uri(WebKitDownload* download, const gchar* uri, gboolean append=FALSE)

{

    g_return_val_if_fail(uri, FALSE);

    WebKitDownloadPrivate* priv = download->priv;

    GFile* file = g_file_new_for_uri(uri);

    GError* error = NULL;

    if (append)

        priv->outputStream = g_file_append_to(file, G_FILE_CREATE_NONE, NULL, &error);

    else

        priv->outputStream = g_file_replace(file, NULL, TRUE, G_FILE_CREATE_NONE, NULL, &error);

    g_object_unref(file);

    if (error) {

        gboolean handled;

        g_signal_emit_by_name(download, "error", 0, WEBKIT_DOWNLOAD_ERROR_DESTINATION, error->message, &handled);

        g_error_free(error);

        return FALSE;

    }

    return TRUE;

}

static void webkit_download_close_stream(WebKitDownload* download)

{

    WebKitDownloadPrivate* priv = download->priv;

    if (priv->outputStream) {

        g_object_unref(priv->outputStream);

        priv->outputStream = NULL;

    }

}

/**

 * webkit_download_start:

 * @download: the #WebKitDownload

 *

 * Initiates the download. Notice that you must have set the

 * destination-uri property before calling this method.

 *

 * Since: 1.1.2

 */

void webkit_download_start(WebKitDownload* download)

{

    g_return_if_fail(WEBKIT_IS_DOWNLOAD(download));

    WebKitDownloadPrivate* priv = download->priv;

    g_return_if_fail(priv->destinationURI);

    g_return_if_fail(priv->status == WEBKIT_DOWNLOAD_STATUS_CREATED);

    g_return_if_fail(priv->timer == NULL);

    if (!priv->resourceHandle)

        priv->resourceHandle = ResourceHandle::create(core(priv->networkRequest), priv->downloadClient, 0, false, false);

    else {

        priv->resourceHandle->setClient(priv->downloadClient);

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

        if (d->m_msg)

            soup_session_unpause_message(webkit_get_default_session(), d->m_msg);

    }

    priv->timer = g_timer_new();

    webkit_download_open_stream_for_uri(download, priv->destinationURI);

}

/**

 * webkit_download_cancel:

 * @download: the #WebKitDownload

 *

 * Cancels the download. Calling this will not free the

 * #WebKitDownload object, so you still need to call

 * g_object_unref() on it, if you are the owner of a reference. Notice

 * that cancelling the download provokes the emission of the

 * WebKitDownload::error signal, reporting that the download was

 * cancelled.

 *

 * Since: 1.1.2

 */

void webkit_download_cancel(WebKitDownload* download)

{

    g_return_if_fail(WEBKIT_IS_DOWNLOAD(download));

    WebKitDownloadPrivate* priv = download->priv;

    // Cancel may be called even if start was not called, so we need

    // to make sure timer is non-NULL.

    if (priv->timer)

        g_timer_stop(priv->timer);

    if (priv->resourceHandle)

        priv->resourceHandle->cancel();