/*

 * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "DatabaseTracker.h"

#if ENABLE(DATABASE)

#include "AbstractDatabase.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "DatabaseThread.h"

#include "DatabaseTrackerClient.h"

#include "Logging.h"

#include "OriginQuotaManager.h"

#include "Page.h"

#include "ScriptExecutionContext.h"

#include "SecurityOrigin.h"

#include "SecurityOriginHash.h"

#include "SQLiteFileSystem.h"

#include "SQLiteStatement.h"

#include <wtf/MainThread.h>

#include <wtf/StdLibExtras.h>

using namespace std;

static WebCore::OriginQuotaManager& originQuotaManager()

{

    DEFINE_STATIC_LOCAL(WebCore::OriginQuotaManager, quotaManager, ());

    return quotaManager;

}

namespace WebCore {

static DatabaseTracker* staticTracker = 0;

void DatabaseTracker::initializeTracker(const String& databasePath)

{

    ASSERT(!staticTracker);

    if (staticTracker)

        return;

    staticTracker = new DatabaseTracker(databasePath);

}

DatabaseTracker& DatabaseTracker::tracker()

{

    if (!staticTracker)

        staticTracker = new DatabaseTracker("");

    return *staticTracker;

}

DatabaseTracker::DatabaseTracker(const String& databasePath)

    : m_client(0)

{

    setDatabaseDirectoryPath(databasePath);

    SQLiteFileSystem::registerSQLiteVFS();

    MutexLocker lockDatabase(m_databaseGuard);

    populateOrigins();

}

void DatabaseTracker::setDatabaseDirectoryPath(const String& path)

{

    MutexLocker lockDatabase(m_databaseGuard);

    ASSERT(!m_database.isOpen());

    m_databaseDirectoryPath = path.threadsafeCopy();

}

String DatabaseTracker::databaseDirectoryPath() const

{

    return m_databaseDirectoryPath.threadsafeCopy();

}

String DatabaseTracker::trackerDatabasePath() const

{

    return SQLiteFileSystem::appendDatabaseFileNameToPath(m_databaseDirectoryPath, "Databases.db");

}

void DatabaseTracker::openTrackerDatabase(bool createIfDoesNotExist)

{

    ASSERT(!m_databaseGuard.tryLock());

    if (m_database.isOpen())

        return;

    String databasePath = trackerDatabasePath();

    if (!SQLiteFileSystem::ensureDatabaseFileExists(databasePath, createIfDoesNotExist))

        return;

    if (!m_database.open(databasePath)) {

        // FIXME: What do do here?

        LOG_ERROR("Failed to open databasePath %s.", databasePath.ascii().data());

        return;

    }

    m_database.disableThreadingChecks();

    if (!m_database.tableExists("Origins")) {

        if (!m_database.executeCommand("CREATE TABLE Origins (origin TEXT UNIQUE ON CONFLICT REPLACE, quota INTEGER NOT NULL ON CONFLICT FAIL);")) {

            // FIXME: and here

            LOG_ERROR("Failed to create Origins table");

        }

    }

    if (!m_database.tableExists("Databases")) {

        if (!m_database.executeCommand("CREATE TABLE Databases (guid INTEGER PRIMARY KEY AUTOINCREMENT, origin TEXT, name TEXT, displayName TEXT, estimatedSize INTEGER, path TEXT);")) {

            // FIXME: and here

            LOG_ERROR("Failed to create Databases table");

        }

    }

}

bool DatabaseTracker::canEstablishDatabase(ScriptExecutionContext* context, const String& name, const String& displayName, unsigned long estimatedSize)

{

    SecurityOrigin* origin = context->securityOrigin();

    ProposedDatabase details;

    unsigned long long requirement;

    {

        MutexLocker lockDatabase(m_databaseGuard);

        Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());

        if (!canCreateDatabase(origin, name))

            return false;

        recordCreatingDatabase(origin, name);

        // Since we're imminently opening a database within this context's origin, make sure this origin is being tracked by the QuotaTracker

        // by fetching its current usage now.

        unsigned long long usage = usageForOriginNoLock(origin);

        // If a database already exists, ignore the passed-in estimated size and say it's OK.

        if (hasEntryForDatabase(origin, name))

            return true;

        // If the database will fit, allow its creation.

        requirement = usage + max(1UL, estimatedSize);

        if (requirement < usage) {

            doneCreatingDatabase(origin, name);

            return false; // If the estimated size is so big it causes an overflow, don't allow creation.

        }

        if (requirement <= quotaForOriginNoLock(origin))

            return true;

        // Give the chrome client a chance to increase the quota.

        // Temporarily make the details of the proposed database available, so the client can get at them.

        // FIXME: We should really just pass the details into this call, rather than using m_proposedDatabases.

        details = ProposedDatabase(origin->threadsafeCopy(), DatabaseDetails(name.threadsafeCopy(), displayName.threadsafeCopy(), estimatedSize, 0));

        m_proposedDatabases.add(&details);

    }

    // Drop all locks before calling out; we don't know what they'll do.

    context->databaseExceededQuota(name);

    MutexLocker lockDatabase(m_databaseGuard);

    m_proposedDatabases.remove(&details);

    // If the database will fit now, allow its creation.

    if (requirement <= quotaForOriginNoLock(origin))

        return true;

    doneCreatingDatabase(origin, name);

    return false;

}

bool DatabaseTracker::hasEntryForOriginNoLock(SecurityOrigin* origin)

{

    ASSERT(!m_databaseGuard.tryLock());

    ASSERT(m_quotaMap);

    return m_quotaMap->contains(origin);

}

bool DatabaseTracker::hasEntryForOrigin(SecurityOrigin* origin)

{

    MutexLocker lockDatabase(m_databaseGuard);

    return hasEntryForOriginNoLock(origin);

}

bool DatabaseTracker::hasEntryForDatabase(SecurityOrigin* origin, const String& databaseIdentifier)

{

    ASSERT(!m_databaseGuard.tryLock());

    openTrackerDatabase(false);

    if (!m_database.isOpen())

        return false;

    SQLiteStatement statement(m_database, "SELECT guid FROM Databases WHERE origin=? AND name=?;");

    if (statement.prepare() != SQLResultOk)

        return false;

    statement.bindText(1, origin->databaseIdentifier());

    statement.bindText(2, databaseIdentifier);

    return statement.step() == SQLResultRow;

}

unsigned long long DatabaseTracker::getMaxSizeForDatabase(const AbstractDatabase* database)

{

    // The maximum size for a database is the full quota for its origin, minus the current usage within the origin,

    // plus the current usage of the given database

    MutexLocker lockDatabase(m_databaseGuard);

    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());

    SecurityOrigin* origin = database->securityOrigin();

    return quotaForOriginNoLock(origin) - originQuotaManager().diskUsage(origin) + SQLiteFileSystem::getDatabaseFileSize(database->fileName());

}

void DatabaseTracker::databaseChanged(AbstractDatabase* database)

{

    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());

    originQuotaManager().markDatabase(database);

}

String DatabaseTracker::originPath(SecurityOrigin* origin) const

{

    return SQLiteFileSystem::appendDatabaseFileNameToPath(m_databaseDirectoryPath.threadsafeCopy(), origin->databaseIdentifier());

}

String DatabaseTracker::fullPathForDatabaseNoLock(SecurityOrigin* origin, const String& name, bool createIfNotExists)

{

    ASSERT(!m_databaseGuard.tryLock());

    ASSERT(!originQuotaManager().tryLock());

    for (HashSet<ProposedDatabase*>::iterator iter = m_proposedDatabases.begin(); iter != m_proposedDatabases.end(); ++iter)

        if ((*iter)->second.name() == name && (*iter)->first->equal(origin))

            return String();

    String originIdentifier = origin->databaseIdentifier();

    String originPath = this->originPath(origin);

    // Make sure the path for this SecurityOrigin exists

    if (createIfNotExists && !SQLiteFileSystem::ensureDatabaseDirectoryExists(originPath))

        return String();

    // See if we have a path for this database yet

    if (!m_database.isOpen())

        return String();

    SQLiteStatement statement(m_database, "SELECT path FROM Databases WHERE origin=? AND name=?;");

    if (statement.prepare() != SQLResultOk)

        return String();

    statement.bindText(1, originIdentifier);

    statement.bindText(2, name);

    int result = statement.step();

    if (result == SQLResultRow)

        return SQLiteFileSystem::appendDatabaseFileNameToPath(originPath, statement.getColumnText(0));

    if (!createIfNotExists)

        return String();

    if (result != SQLResultDone) {

        LOG_ERROR("Failed to retrieve filename from Database Tracker for origin %s, name %s", originIdentifier.ascii().data(), name.ascii().data());

        return String();

    }

    statement.finalize();

    String fileName = SQLiteFileSystem::getFileNameForNewDatabase(originPath, name, originIdentifier, &m_database);

    if (!addDatabase(origin, name, fileName))

        return String();

    // If this origin's quota is being tracked (open handle to a database in this origin), add this new database

    // to the quota manager now

    String fullFilePath = SQLiteFileSystem::appendDatabaseFileNameToPath(originPath, fileName);

    if (originQuotaManager().tracksOrigin(origin))

        originQuotaManager().addDatabase(origin, name, fullFilePath);

    return fullFilePath;

}

String DatabaseTracker::fullPathForDatabase(SecurityOrigin* origin, const String& name, bool createIfNotExists)

{

    MutexLocker lockDatabase(m_databaseGuard);

    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());

    return fullPathForDatabaseNoLock(origin, name, createIfNotExists).threadsafeCopy();

}

void DatabaseTracker::populateOrigins()

{

    ASSERT(!m_databaseGuard.tryLock());

    if (m_quotaMap)

        return;

    m_quotaMap.set(new QuotaMap);

    openTrackerDatabase(false);

    if (!m_database.isOpen())

        return;

    SQLiteStatement statement(m_database, "SELECT origin, quota FROM Origins");

    if (statement.prepare() != SQLResultOk) {

        LOG_ERROR("Failed to prepare statement.");

        return;

    }

    int result;

    while ((result = statement.step()) == SQLResultRow) {

        RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromDatabaseIdentifier(statement.getColumnText(0));

        m_quotaMap->set(origin.get()->threadsafeCopy(), statement.getColumnInt64(1));

    }

    if (result != SQLResultDone)

        LOG_ERROR("Failed to read in all origins from the database.");

}

void DatabaseTracker::origins(Vector<RefPtr<SecurityOrigin> >& result)

{

    MutexLocker lockDatabase(m_databaseGuard);

    ASSERT(m_quotaMap);

    copyKeysToVector(*m_quotaMap, result);

}

bool DatabaseTracker::databaseNamesForOriginNoLock(SecurityOrigin* origin, Vector<String>& resultVector)

{

    ASSERT(!m_databaseGuard.tryLock());

    openTrackerDatabase(false);

    if (!m_database.isOpen())

        return false;

    SQLiteStatement statement(m_database, "SELECT name FROM Databases where origin=?;");

    if (statement.prepare() != SQLResultOk)

        return false;

    statement.bindText(1, origin->databaseIdentifier());

    int result;

    while ((result = statement.step()) == SQLResultRow)

        resultVector.append(statement.getColumnText(0));

    if (result != SQLResultDone) {

        LOG_ERROR("Failed to retrieve all database names for origin %s", origin->databaseIdentifier().ascii().data());

        return false;

    }

    return true;

}

bool DatabaseTracker::databaseNamesForOrigin(SecurityOrigin* origin, Vector<String>& resultVector)

{

    Vector<String> temp;

    {

        MutexLocker lockDatabase(m_databaseGuard);

        if (!databaseNamesForOriginNoLock(origin, temp))

          return false;

    }

    for (Vector<String>::iterator iter = temp.begin(); iter != temp.end(); ++iter)

        resultVector.append(iter->threadsafeCopy());

    return true;

}

DatabaseDetails DatabaseTracker::detailsForNameAndOrigin(const String& name, SecurityOrigin* origin)

{

    String originIdentifier = origin->databaseIdentifier();

    String displayName;

    int64_t expectedUsage;

    {

        MutexLocker lockDatabase(m_databaseGuard);

        for (HashSet<ProposedDatabase*>::iterator iter = m_proposedDatabases.begin(); iter != m_proposedDatabases.end(); ++iter)

            if ((*iter)->second.name() == name && (*iter)->first->equal(origin)) {

                ASSERT((*iter)->second.thread() == currentThread());

                return (*iter)->second;

            }

        openTrackerDatabase(false);

        if (!m_database.isOpen())

            return DatabaseDetails();

        SQLiteStatement statement(m_database, "SELECT displayName, estimatedSize FROM Databases WHERE origin=? AND name=?");

        if (statement.prepare() != SQLResultOk)

            return DatabaseDetails();

        statement.bindText(1, originIdentifier);

        statement.bindText(2, name);

        int result = statement.step();

        if (result == SQLResultDone)

            return DatabaseDetails();

        if (result != SQLResultRow) {

            LOG_ERROR("Error retrieving details for database %s in origin %s from tracker database", name.ascii().data(), originIdentifier.ascii().data());

            return DatabaseDetails();

        }

        displayName = statement.getColumnText(0);

        expectedUsage = statement.getColumnInt64(1);

    }

    return DatabaseDetails(name, displayName, expectedUsage, usageForDatabase(name, origin));

}

void DatabaseTracker::setDatabaseDetails(SecurityOrigin* origin, const String& name, const String& displayName, unsigned long estimatedSize)

{

    String originIdentifier = origin->databaseIdentifier();

    int64_t guid = 0;

    MutexLocker lockDatabase(m_databaseGuard);

    openTrackerDatabase(true);

    if (!m_database.isOpen())

        return;

    SQLiteStatement statement(m_database, "SELECT guid FROM Databases WHERE origin=? AND name=?");

    if (statement.prepare() != SQLResultOk)

        return;

    statement.bindText(1, originIdentifier);

    statement.bindText(2, name);

    int result = statement.step();

    if (result == SQLResultRow)

        guid = statement.getColumnInt64(0);

    statement.finalize();

    if (guid == 0) {

        if (result != SQLResultDone)

            LOG_ERROR("Error to determing existence of database %s in origin %s in tracker database", name.ascii().data(), originIdentifier.ascii().data());

        else {

            // This case should never occur - we should never be setting database details for a database that doesn't already exist in the tracker

            // But since the tracker file is an external resource not under complete control of our code, it's somewhat invalid to make this an ASSERT case

            // So we'll print an error instead

            LOG_ERROR("Could not retrieve guid for database %s in origin %s from the tracker database - it is invalid to set database details on a database that doesn't already exist in the tracker",

                       name.ascii().data(), originIdentifier.ascii().data());

        }

        return;

    }

    SQLiteStatement updateStatement(m_database, "UPDATE Databases SET displayName=?, estimatedSize=? WHERE guid=?");

    if (updateStatement.prepare() != SQLResultOk)

        return;

    updateStatement.bindText(1, displayName);

    updateStatement.bindInt64(2, estimatedSize);

    updateStatement.bindInt64(3, guid);

    if (updateStatement.step() != SQLResultDone) {

        LOG_ERROR("Failed to update details for database %s in origin %s", name.ascii().data(), originIdentifier.ascii().data());

        return;

    }

    if (m_client)

        m_client->dispatchDidModifyDatabase(origin, name);

}

unsigned long long DatabaseTracker::usageForDatabase(const String& name, SecurityOrigin* origin)

{

    String path = fullPathForDatabase(origin, name, false);

    if (path.isEmpty())

        return 0;

    return SQLiteFileSystem::getDatabaseFileSize(path);

}

void DatabaseTracker::addOpenDatabase(AbstractDatabase* database)

{

    if (!database)

        return;

    {

        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);

        if (!m_openDatabaseMap)

            m_openDatabaseMap.set(new DatabaseOriginMap);

        String name(database->stringIdentifier());

        DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());

        if (!nameMap) {

            nameMap = new DatabaseNameMap;

            m_openDatabaseMap->set(database->securityOrigin()->threadsafeCopy(), nameMap);

        }

        DatabaseSet* databaseSet = nameMap->get(name);

        if (!databaseSet) {

            databaseSet = new DatabaseSet;

            nameMap->set(name.threadsafeCopy(), databaseSet);

        }

        databaseSet->add(database);

        LOG(StorageAPI, "Added open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);

        Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());

        if (!originQuotaManager().tracksOrigin(database->securityOrigin())) {

            originQuotaManager().trackOrigin(database->securityOrigin());

            originQuotaManager().addDatabase(database->securityOrigin(), database->stringIdentifier(), database->fileName());

        }

    }

    MutexLocker lockDatabase(m_databaseGuard);

    doneCreatingDatabase(database->securityOrigin(), database->stringIdentifier());

}

void DatabaseTracker::removeOpenDatabase(AbstractDatabase* database)

{

    if (!database)

        return;

    {

        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);

        if (!m_openDatabaseMap) {