/*

 * Copyright (C) 2009 Martin Robinson

 *

 * 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 "webkitwebdatabase.h"

#include "webkitprivate.h"

#include "DatabaseDetails.h"

#include "DatabaseTracker.h"

#include <wtf/text/CString.h>

#include <glib/gi18n-lib.h>

/**

 * SECTION:webkitwebdatabase

 * @short_description: A WebKit web application database

 *

 * #WebKitWebDatabase is a representation of a Web Database database. The

 * proposed Web Database standard introduces support for SQL databases that web

 * sites can create and access on a local computer through JavaScript.

 *

 * To get access to all databases defined by a security origin, use

 * #webkit_security_origin_get_databases. Each database has a canonical

 * name, as well as a user-friendly display name.

 * 

 * WebKit uses SQLite to create and access the local SQL databases. The location

 * of a #WebKitWebDatabase can be accessed wth #webkit_web_database_get_filename.

 * You can configure the location of all databases with

 * #webkit_set_database_directory_path.

 * 

 * For each database the web site can define an estimated size which can be

 * accessed with #webkit_web_database_get_expected_size. The current size of the

 * database in bytes is returned by #webkit_web_database_get_size.

 * 

 * For more information refer to the Web Database specification proposal at

 * http://dev.w3.org/html5/webdatabase

 */

using namespace WebKit;

enum {

    PROP_0,

    PROP_SECURITY_ORIGIN,

    PROP_NAME,

    PROP_DISPLAY_NAME,

    PROP_EXPECTED_SIZE,

    PROP_SIZE,

    PROP_PATH

};

G_DEFINE_TYPE(WebKitWebDatabase, webkit_web_database, G_TYPE_OBJECT)

struct _WebKitWebDatabasePrivate {

    WebKitSecurityOrigin* origin;

    gchar* name;

    gchar* displayName;

    gchar* filename;

};

static gchar* webkit_database_directory_path = NULL;

static guint64 webkit_default_database_quota = 5 * 1024 * 1024;

#define WEBKIT_WEB_DATABASE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_DATABASE, WebKitWebDatabasePrivate))

static void webkit_web_database_set_security_origin(WebKitWebDatabase* webDatabase, WebKitSecurityOrigin* security_origin);

static void webkit_web_database_set_name(WebKitWebDatabase* webDatabase, const gchar* name);

static void webkit_web_database_finalize(GObject* object)

{

    WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    g_free(priv->name);

    g_free(priv->displayName);

    g_free(priv->filename);

    G_OBJECT_CLASS(webkit_web_database_parent_class)->finalize(object);

}

static void webkit_web_database_dispose(GObject* object)

{

    WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    if (priv->origin) {

        g_object_unref(priv->origin);

        priv->origin = NULL;

    }

    G_OBJECT_CLASS(webkit_web_database_parent_class)->dispose(object);

}

static void webkit_web_database_set_property(GObject* object, guint propId, const GValue* value, GParamSpec* pspec)

{

    WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

    switch (propId) {

    case PROP_SECURITY_ORIGIN:

        webkit_web_database_set_security_origin(webDatabase, WEBKIT_SECURITY_ORIGIN(g_value_get_object(value)));

        break;

    case PROP_NAME:

        webkit_web_database_set_name(webDatabase, g_value_get_string(value));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);

        break;

    }

}

static void webkit_web_database_get_property(GObject* object, guint propId, GValue* value, GParamSpec* pspec)

{

    WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    switch (propId) {

    case PROP_SECURITY_ORIGIN:

        g_value_set_object(value, priv->origin);

        break;

    case PROP_NAME:

        g_value_set_string(value, webkit_web_database_get_name(webDatabase));

        break;

    case PROP_DISPLAY_NAME:

        g_value_set_string(value, webkit_web_database_get_display_name(webDatabase));

        break;

    case PROP_EXPECTED_SIZE:

        g_value_set_uint64(value, webkit_web_database_get_expected_size(webDatabase));

        break;

    case PROP_SIZE:

        g_value_set_uint64(value, webkit_web_database_get_size(webDatabase));

        break;

    case PROP_PATH:

        g_value_set_string(value, webkit_web_database_get_filename(webDatabase));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);

        break;

    }

}

static void webkit_web_database_class_init(WebKitWebDatabaseClass* klass)

{

    GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);

    gobjectClass->dispose = webkit_web_database_dispose;

    gobjectClass->finalize = webkit_web_database_finalize;

    gobjectClass->set_property = webkit_web_database_set_property;

    gobjectClass->get_property = webkit_web_database_get_property;

     /**

      * WebKitWebDatabase:security-origin:

      *

      * The security origin of the database.

      *

      * Since: 1.1.14

      */

     g_object_class_install_property(gobjectClass, PROP_SECURITY_ORIGIN,

                                     g_param_spec_object("security-origin",

                                                         _("Security Origin"),

                                                         _("The security origin of the database"),

                                                         WEBKIT_TYPE_SECURITY_ORIGIN,

                                                         (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));

     /**

      * WebKitWebDatabase:name:

      *

      * The name of the Web Database database.

      *

      * Since: 1.1.14

      */

     g_object_class_install_property(gobjectClass, PROP_NAME,

                                     g_param_spec_string("name",

                                                         _("Name"),

                                                         _("The name of the Web Database database"),

                                                         NULL,

                                                         (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));

     /**

      * WebKitWebDatabase:display-name:

      *

      * The display name of the Web Database database.

      *

      * Since: 1.1.14

      */

     g_object_class_install_property(gobjectClass, PROP_DISPLAY_NAME,

                                     g_param_spec_string("display-name",

                                                         _("Display Name"),

                                                         _("The display name of the Web Storage database"),

                                                         NULL,

                                                         WEBKIT_PARAM_READABLE));

     /**

     * WebKitWebDatabase:expected-size:

     *

     * The expected size of the database in bytes as defined by the web author.

     *

     * Since: 1.1.14

     */

     g_object_class_install_property(gobjectClass, PROP_EXPECTED_SIZE,

                                     g_param_spec_uint64("expected-size",

                                                         _("Expected Size"),

                                                         _("The expected size of the Web Database database"),

                                                         0, G_MAXUINT64, 0,

                                                         WEBKIT_PARAM_READABLE));

     /**

     * WebKitWebDatabase:size:

     *

     * The current size of the database in bytes.

     *

     * Since: 1.1.14

     */

     g_object_class_install_property(gobjectClass, PROP_SIZE,

                                     g_param_spec_uint64("size",

                                                         _("Size"),

                                                         _("The current size of the Web Database database"),

                                                         0, G_MAXUINT64, 0,

                                                         WEBKIT_PARAM_READABLE));

     /**

      * WebKitWebDatabase:filename:

      *

      * The absolute filename of the Web Database database.

      *

      * Since: 1.1.14

      */

     g_object_class_install_property(gobjectClass, PROP_PATH,

                                     g_param_spec_string("filename",

                                                         _("Filename"),

                                                         _("The absolute filename of the Web Storage database"),

                                                         NULL,

                                                         WEBKIT_PARAM_READABLE));

    g_type_class_add_private(klass, sizeof(WebKitWebDatabasePrivate));

}

static void webkit_web_database_init(WebKitWebDatabase* webDatabase)

{

    webDatabase->priv = WEBKIT_WEB_DATABASE_GET_PRIVATE(webDatabase);

}

// Internal use only

static void webkit_web_database_set_security_origin(WebKitWebDatabase *webDatabase, WebKitSecurityOrigin *securityOrigin)

{

    g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase));

    g_return_if_fail(WEBKIT_IS_SECURITY_ORIGIN(securityOrigin));

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    if (priv->origin)

        g_object_unref(priv->origin);

    g_object_ref(securityOrigin);

    priv->origin = securityOrigin;

}

static void webkit_web_database_set_name(WebKitWebDatabase* webDatabase, const gchar* name)

{

    g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase));

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    g_free(priv->name);

    priv->name = g_strdup(name);

}

/**

 * webkit_web_database_get_security_origin:

 * @web_database: a #WebKitWebDatabase

 *

 * Returns the security origin of the #WebKitWebDatabase.

 *

 * Returns: the security origin of the database

 *

 * Since: 1.1.14

 **/

WebKitSecurityOrigin* webkit_web_database_get_security_origin(WebKitWebDatabase* webDatabase)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    return priv->origin;

}

/**

 * webkit_web_database_get_name:

 * @web_database: a #WebKitWebDatabase

 *

 * Returns the canonical name of the #WebKitWebDatabase.

 *

 * Returns: the name of the database

 *

 * Since: 1.1.14

 **/

G_CONST_RETURN gchar* webkit_web_database_get_name(WebKitWebDatabase* webDatabase)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    return priv->name;

}

/**

 * webkit_web_database_get_display_name:

 * @web_database: a #WebKitWebDatabase

 *

 * Returns the name of the #WebKitWebDatabase as seen by the user.

 *

 * Returns: the name of the database as seen by the user.

 *

 * Since: 1.1.14

 **/

G_CONST_RETURN gchar* webkit_web_database_get_display_name(WebKitWebDatabase* webDatabase)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

#if ENABLE(DATABASE)

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));

    WebCore::String displayName =  details.displayName();

    if (displayName.isEmpty())

        return "";

    g_free(priv->displayName);

    priv->displayName = g_strdup(displayName.utf8().data());

    return priv->displayName;

#else

    return "";

#endif

}

/**

 * webkit_web_database_get_expected_size:

 * @web_database: a #WebKitWebDatabase

 *

 * Returns the expected size of the #WebKitWebDatabase in bytes as defined by the

 * web author. The Web Database standard allows web authors to specify an expected

 * size of the database to optimize the user experience.

 *

 * Returns: the expected size of the database in bytes

 *

 * Since: 1.1.14

 **/

guint64 webkit_web_database_get_expected_size(WebKitWebDatabase* webDatabase)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), 0);

#if ENABLE(DATABASE)

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));

    return details.expectedUsage();

#else

    return 0;

#endif

}

/**

 * webkit_web_database_get_size:

 * @web_database: a #WebKitWebDatabase

 *

 * Returns the actual size of the #WebKitWebDatabase space on disk in bytes.

 *

 * Returns: the actual size of the database in bytes

 *

 * Since: 1.1.14

 **/

guint64 webkit_web_database_get_size(WebKitWebDatabase* webDatabase)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), 0);

#if ENABLE(DATABASE)

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));

    return details.currentUsage();

#else

    return 0;

#endif

}

/**

 * webkit_web_database_get_filename:

 * @web_database: a #WebKitWebDatabase

 *

 * Returns the absolute filename to the #WebKitWebDatabase file on disk.

 *

 * Returns: the absolute filename of the database

 *

 * Since: 1.1.14

 **/

G_CONST_RETURN gchar* webkit_web_database_get_filename(WebKitWebDatabase* webDatabase)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

#if ENABLE(DATABASE)

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    WebCore::String coreName = WebCore::String::fromUTF8(priv->name);

    WebCore::String corePath = WebCore::DatabaseTracker::tracker().fullPathForDatabase(core(priv->origin), coreName);

    if (corePath.isEmpty())

        return"";

    g_free(priv->filename);

    priv->filename = g_strdup(corePath.utf8().data());

    return priv->filename;

#else

    return "";

#endif

}

/**

 * webkit_web_database_remove:

 * @web_database: a #WebKitWebDatabase

 *

 * Removes the #WebKitWebDatabase from its security origin and destroys all data

 * stored in the database.

 *

 * Since: 1.1.14

 **/

void webkit_web_database_remove(WebKitWebDatabase* webDatabase)

{

    g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase));

#if ENABLE(DATABASE)

    WebKitWebDatabasePrivate* priv = webDatabase->priv;

    WebCore::DatabaseTracker::tracker().deleteDatabase(core(priv->origin), priv->name);

#endif

}

/**

 * webkit_remove_all_web_databases:

 *

 * Removes all web databases from the current database directory path.

 *

 * Since: 1.1.14

 **/

void webkit_remove_all_web_databases()

{

#if ENABLE(DATABASE)

    WebCore::DatabaseTracker::tracker().deleteAllDatabases();

#endif

}

/**

 * webkit_get_web_database_directory_path:

 *

 * Returns the current path to the directory WebKit will write Web 

 * Database databases. By default this path will be in the user data

 * directory.

 *

 * Returns: the current database directory path

 *

 * Since: 1.1.14

 **/

G_CONST_RETURN gchar* webkit_get_web_database_directory_path()

{

#if ENABLE(DATABASE)

    WebCore::String path = WebCore::DatabaseTracker::tracker().databaseDirectoryPath();

    if (path.isEmpty())

        return "";

    g_free(webkit_database_directory_path);

    webkit_database_directory_path = g_strdup(path.utf8().data());

    return webkit_database_directory_path;

#else

    return "";

#endif

}

/**

 * webkit_set_web_database_directory_path:

 * @path: the new database directory path

 *

 * Sets the current path to the directory WebKit will write Web 

 * Database databases. 

 *

 * Since: 1.1.14

 **/

void webkit_set_web_database_directory_path(const gchar* path)

{

#if ENABLE(DATABASE)

    WebCore::String corePath = WebCore::String::fromUTF8(path);

    WebCore::DatabaseTracker::tracker().setDatabaseDirectoryPath(corePath);

    g_free(webkit_database_directory_path);

    webkit_database_directory_path = g_strdup(corePath.utf8().data());

#endif

}

/**

 * webkit_get_default_web_database_quota:

 *

 * Returns the default quota for Web Database databases. By default

 * this value is 5MB.

 * Returns: the current default database quota in bytes

 *

 * Since: 1.1.14

 **/

guint64 webkit_get_default_web_database_quota()

{

    return webkit_default_database_quota;

}

/**

 * webkit_set_default_web_database_quota:

 * @default_quota: the new default database quota

 *

 * Sets the current path to the directory WebKit will write Web 

 * Database databases. 

 *

 * Since: 1.1.14