/*
 * Copyright (C) 2010 Google 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.
 *
 * 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 "modules/indexeddb/IDBDatabase.h"

#include "bindings/core/v8/ExceptionState.h"
#include "bindings/core/v8/ExceptionStatePlaceholder.h"
#include "bindings/core/v8/Nullable.h"
#include "bindings/core/v8/SerializedScriptValue.h"
#include "bindings/modules/v8/V8BindingForModules.h"
#include "core/dom/ExceptionCode.h"
#include "core/dom/ExecutionContext.h"
#include "core/events/EventQueue.h"
#include "modules/indexeddb/IDBAny.h"
#include "modules/indexeddb/IDBEventDispatcher.h"
#include "modules/indexeddb/IDBIndex.h"
#include "modules/indexeddb/IDBKeyPath.h"
#include "modules/indexeddb/IDBTracing.h"
#include "modules/indexeddb/IDBVersionChangeEvent.h"
#include "modules/indexeddb/WebIDBDatabaseCallbacksImpl.h"
#include "platform/Histogram.h"
#include "public/platform/modules/indexeddb/WebIDBKeyPath.h"
#include "public/platform/modules/indexeddb/WebIDBTypes.h"
#include "wtf/Atomics.h"
#include <limits>
#include <memory>

using blink::WebIDBDatabase;

namespace blink {

const char IDBDatabase::indexDeletedErrorMessage[] =
    "The index or its object store has been deleted.";
const char IDBDatabase::indexNameTakenErrorMessage[] =
    "An index with the specified name already exists.";
const char IDBDatabase::isKeyCursorErrorMessage[] =
    "The cursor is a key cursor.";
const char IDBDatabase::noKeyOrKeyRangeErrorMessage[] =
    "No key or key range specified.";
const char IDBDatabase::noSuchIndexErrorMessage[] =
    "The specified index was not found.";
const char IDBDatabase::noSuchObjectStoreErrorMessage[] =
    "The specified object store was not found.";
const char IDBDatabase::noValueErrorMessage[] =
    "The cursor is being iterated or has iterated past its end.";
const char IDBDatabase::notValidKeyErrorMessage[] =
    "The parameter is not a valid key.";
const char IDBDatabase::notVersionChangeTransactionErrorMessage[] =
    "The database is not running a version change transaction.";
const char IDBDatabase::objectStoreDeletedErrorMessage[] =
    "The object store has been deleted.";
const char IDBDatabase::objectStoreNameTakenErrorMessage[] =
    "An object store with the specified name already exists.";
const char IDBDatabase::requestNotFinishedErrorMessage[] =
    "The request has not finished.";
const char IDBDatabase::sourceDeletedErrorMessage[] =
    "The cursor's source or effective object store has been deleted.";
const char IDBDatabase::transactionInactiveErrorMessage[] =
    "The transaction is not active.";
const char IDBDatabase::transactionFinishedErrorMessage[] =
    "The transaction has finished.";
const char IDBDatabase::transactionReadOnlyErrorMessage[] =
    "The transaction is read-only.";
const char IDBDatabase::databaseClosedErrorMessage[] =
    "The database connection is closed.";

IDBDatabase* IDBDatabase::create(ExecutionContext* context,
                                 std::unique_ptr<WebIDBDatabase> database,
                                 IDBDatabaseCallbacks* callbacks) {
  IDBDatabase* idbDatabase =
      new IDBDatabase(context, std::move(database), callbacks);
  idbDatabase->suspendIfNeeded();
  return idbDatabase;
}

IDBDatabase::IDBDatabase(ExecutionContext* context,
                         std::unique_ptr<WebIDBDatabase> backend,
                         IDBDatabaseCallbacks* callbacks)
    : ActiveScriptWrappable(this),
      ActiveDOMObject(context),
      m_backend(std::move(backend)),
      m_databaseCallbacks(callbacks) {
  m_databaseCallbacks->connect(this);
}

IDBDatabase::~IDBDatabase() {
  if (!m_closePending && m_backend)
    m_backend->close();
}

DEFINE_TRACE(IDBDatabase) {
  visitor->trace(m_versionChangeTransaction);
  visitor->trace(m_transactions);
  visitor->trace(m_enqueuedEvents);
  visitor->trace(m_databaseCallbacks);
  EventTargetWithInlineData::trace(visitor);
  ActiveDOMObject::trace(visitor);
}

int64_t IDBDatabase::nextTransactionId() {
  // Only keep a 32-bit counter to allow ports to use the other 32
  // bits of the id.
  static int currentTransactionId = 0;
  return atomicIncrement(&currentTransactionId);
}

void IDBDatabase::indexCreated(int64_t objectStoreId,
                               const IDBIndexMetadata& metadata) {
  IDBDatabaseMetadata::ObjectStoreMap::iterator it =
      m_metadata.objectStores.find(objectStoreId);
  ASSERT_WITH_SECURITY_IMPLICATION(it != m_metadata.objectStores.end());
  it->value.indexes.set(metadata.id, metadata);
}

void IDBDatabase::indexDeleted(int64_t objectStoreId, int64_t indexId) {
  IDBDatabaseMetadata::ObjectStoreMap::iterator it =
      m_metadata.objectStores.find(objectStoreId);
  ASSERT_WITH_SECURITY_IMPLICATION(it != m_metadata.objectStores.end());
  it->value.indexes.remove(indexId);
}

void IDBDatabase::indexRenamed(int64_t objectStoreId,
                               int64_t indexId,
                               const String& newName) {
  IDBDatabaseMetadata::ObjectStoreMap::iterator storeIterator =
      m_metadata.objectStores.find(objectStoreId);
  SECURITY_DCHECK(storeIterator != m_metadata.objectStores.end());

  IDBObjectStoreMetadata& storeMetadata = storeIterator->value;
  IDBObjectStoreMetadata::IndexMap::iterator indexIterator =
      storeMetadata.indexes.find(indexId);
  DCHECK_NE(indexIterator, storeMetadata.indexes.end());
  indexIterator->value.name = newName;
}

void IDBDatabase::transactionCreated(IDBTransaction* transaction) {
  DCHECK(transaction);
  DCHECK(!m_transactions.contains(transaction->id()));
  m_transactions.add(transaction->id(), transaction);

  if (transaction->isVersionChange()) {
    DCHECK(!m_versionChangeTransaction);
    m_versionChangeTransaction = transaction;
  }
}

void IDBDatabase::transactionFinished(const IDBTransaction* transaction) {
  DCHECK(transaction);
  DCHECK(m_transactions.contains(transaction->id()));
  DCHECK_EQ(m_transactions.get(transaction->id()), transaction);
  m_transactions.remove(transaction->id());

  if (transaction->isVersionChange()) {
    DCHECK_EQ(m_versionChangeTransaction, transaction);
    m_versionChangeTransaction = nullptr;
  }

  if (m_closePending && m_transactions.isEmpty())
    closeConnection();
}

void IDBDatabase::onAbort(int64_t transactionId, DOMException* error) {
  DCHECK(m_transactions.contains(transactionId));
  m_transactions.get(transactionId)->onAbort(error);
}

void IDBDatabase::onComplete(int64_t transactionId) {
  DCHECK(m_transactions.contains(transactionId));
  m_transactions.get(transactionId)->onComplete();
}

DOMStringList* IDBDatabase::objectStoreNames() const {
  DOMStringList* objectStoreNames =
      DOMStringList::create(DOMStringList::IndexedDB);
  for (const auto& it : m_metadata.objectStores)
    objectStoreNames->append(it.value.name);
  objectStoreNames->sort();
  return objectStoreNames;
}

const String& IDBDatabase::getObjectStoreName(int64_t objectStoreId) const {
  const auto& it = m_metadata.objectStores.find(objectStoreId);
  DCHECK(it != m_metadata.objectStores.end());
  return it->value.name;
}

IDBObjectStore* IDBDatabase::createObjectStore(const String& name,
                                               const IDBKeyPath& keyPath,
                                               bool autoIncrement,
                                               ExceptionState& exceptionState) {
  IDB_TRACE("IDBDatabase::createObjectStore");
  recordApiCallsHistogram(IDBCreateObjectStoreCall);

  if (!m_versionChangeTransaction) {
    exceptionState.throwDOMException(
        InvalidStateError,
        IDBDatabase::notVersionChangeTransactionErrorMessage);
    return nullptr;
  }
  if (m_versionChangeTransaction->isFinished() ||
      m_versionChangeTransaction->isFinishing()) {
    exceptionState.throwDOMException(
        TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
    return nullptr;
  }
  if (!m_versionChangeTransaction->isActive()) {
    exceptionState.throwDOMException(
        TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
    return nullptr;
  }

  if (!keyPath.isNull() && !keyPath.isValid()) {
    exceptionState.throwDOMException(
        SyntaxError, "The keyPath option is not a valid key path.");
    return nullptr;
  }

  if (containsObjectStore(name)) {
    exceptionState.throwDOMException(
        ConstraintError, IDBDatabase::objectStoreNameTakenErrorMessage);
    return nullptr;
  }

  if (autoIncrement && ((keyPath.getType() == IDBKeyPath::StringType &&
                         keyPath.string().isEmpty()) ||
                        keyPath.getType() == IDBKeyPath::ArrayType)) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The autoIncrement option was set but the "
                                     "keyPath option was empty or an array.");
    return nullptr;
  }

  if (!m_backend) {
    exceptionState.throwDOMException(InvalidStateError,
                                     IDBDatabase::databaseClosedErrorMessage);
    return nullptr;
  }

  int64_t objectStoreId = m_metadata.maxObjectStoreId + 1;
  m_backend->createObjectStore(m_versionChangeTransaction->id(), objectStoreId,
                               name, keyPath, autoIncrement);

  IDBObjectStoreMetadata metadata(name, objectStoreId, keyPath, autoIncrement,
                                  WebIDBDatabase::minimumIndexId);
  IDBObjectStore* objectStore =
      IDBObjectStore::create(metadata, m_versionChangeTransaction.get());
  m_metadata.objectStores.set(metadata.id, metadata);
  ++m_metadata.maxObjectStoreId;

  m_versionChangeTransaction->objectStoreCreated(name, objectStore);
  return objectStore;
}

void IDBDatabase::deleteObjectStore(const String& name,
                                    ExceptionState& exceptionState) {
  IDB_TRACE("IDBDatabase::deleteObjectStore");
  recordApiCallsHistogram(IDBDeleteObjectStoreCall);
  if (!m_versionChangeTransaction) {
    exceptionState.throwDOMException(
        InvalidStateError,
        IDBDatabase::notVersionChangeTransactionErrorMessage);
    return;
  }
  if (m_versionChangeTransaction->isFinished() ||
      m_versionChangeTransaction->isFinishing()) {
    exceptionState.throwDOMException(
        TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
    return;
  }
  if (!m_versionChangeTransaction->isActive()) {
    exceptionState.throwDOMException(
        TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
    return;
  }

  int64_t objectStoreId = findObjectStoreId(name);
  if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
    exceptionState.throwDOMException(
        NotFoundError, "The specified object store was not found.");
    return;
  }

  if (!m_backend) {
    exceptionState.throwDOMException(InvalidStateError,
                                     IDBDatabase::databaseClosedErrorMessage);
    return;
  }

  m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
  m_versionChangeTransaction->objectStoreDeleted(name);
  m_metadata.objectStores.remove(objectStoreId);
}

IDBTransaction* IDBDatabase::transaction(
    ScriptState* scriptState,
    const StringOrStringSequenceOrDOMStringList& storeNames,
    const String& modeString,
    ExceptionState& exceptionState) {
  IDB_TRACE("IDBDatabase::transaction");
  recordApiCallsHistogram(IDBTransactionCall);

  HashSet<String> scope;
  if (storeNames.isString()) {
    scope.add(storeNames.getAsString());
  } else if (storeNames.isStringSequence()) {
    for (const String& name : storeNames.getAsStringSequence())
      scope.add(name);
  } else if (storeNames.isDOMStringList()) {
    const Vector<String>& list = *storeNames.getAsDOMStringList();
    for (const String& name : list)
      scope.add(name);
  } else {
    NOTREACHED();
  }

  if (m_versionChangeTransaction) {
    exceptionState.throwDOMException(
        InvalidStateError, "A version change transaction is running.");
    return nullptr;
  }

  if (m_closePending) {
    exceptionState.throwDOMException(InvalidStateError,
                                     "The database connection is closing.");
    return nullptr;
  }

  if (!m_backend) {
    exceptionState.throwDOMException(InvalidStateError,
                                     IDBDatabase::databaseClosedErrorMessage);
    return nullptr;
  }

  if (scope.isEmpty()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The storeNames parameter was empty.");
    return nullptr;
  }

  Vector<int64_t> objectStoreIds;
  for (const String& name : scope) {
    int64_t objectStoreId = findObjectStoreId(name);
    if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
      exceptionState.throwDOMException(
          NotFoundError, "One of the specified object stores was not found.");
      return nullptr;
    }
    objectStoreIds.append(objectStoreId);
  }

  WebIDBTransactionMode mode = IDBTransaction::stringToMode(modeString);
  if (mode != WebIDBTransactionModeReadOnly &&
      mode != WebIDBTransactionModeReadWrite) {
    exceptionState.throwTypeError(
        "The mode provided ('" + modeString +
        "') is not one of 'readonly' or 'readwrite'.");
    return nullptr;
  }

  int64_t transactionId = nextTransactionId();
  m_backend->createTransaction(transactionId, objectStoreIds, mode);

  return IDBTransaction::createNonVersionChange(scriptState, transactionId,
                                                scope, mode, this);
}

void IDBDatabase::forceClose() {
  for (const auto& it : m_transactions)
    it.value->abort(IGNORE_EXCEPTION);
  this->close();
  enqueueEvent(Event::create(EventTypeNames::close));
}

void IDBDatabase::close() {
  IDB_TRACE("IDBDatabase::close");
  if (m_closePending)
    return;

  m_closePending = true;

  if (m_transactions.isEmpty())
    closeConnection();
}

void IDBDatabase::closeConnection() {
  DCHECK(m_closePending);
  DCHECK(m_transactions.isEmpty());

  if (m_backend) {
    m_backend->close();
    m_backend.reset();
  }

  if (m_contextStopped || !getExecutionContext())
    return;

  EventQueue* eventQueue = getExecutionContext()->getEventQueue();
  // Remove any pending versionchange events scheduled to fire on this
  // connection. They would have been scheduled by the backend when another
  // connection attempted an upgrade, but the frontend connection is being
  // closed before they could fire.
  for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
    bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
    ASSERT_UNUSED(removed, removed);
  }
}

void IDBDatabase::onVersionChange(int64_t oldVersion, int64_t newVersion) {
  IDB_TRACE("IDBDatabase::onVersionChange");
  if (m_contextStopped || !getExecutionContext())
    return;

  if (m_closePending) {
    // If we're pending, that means there's a busy transaction. We won't
    // fire 'versionchange' but since we're not closing immediately the
    // back-end should still send out 'blocked'.
    m_backend->versionChangeIgnored();
    return;
  }

  Nullable<unsigned long long> newVersionNullable =
      (newVersion == IDBDatabaseMetadata::NoVersion)
          ? Nullable<unsigned long long>()
          : Nullable<unsigned long long>(newVersion);
  enqueueEvent(IDBVersionChangeEvent::create(EventTypeNames::versionchange,
                                             oldVersion, newVersionNullable));
}

void IDBDatabase::enqueueEvent(Event* event) {
  DCHECK(!m_contextStopped);
  DCHECK(getExecutionContext());
  EventQueue* eventQueue = getExecutionContext()->getEventQueue();
  event->setTarget(this);
  eventQueue->enqueueEvent(event);
  m_enqueuedEvents.append(event);
}

DispatchEventResult IDBDatabase::dispatchEventInternal(Event* event) {
  IDB_TRACE("IDBDatabase::dispatchEvent");
  if (m_contextStopped || !getExecutionContext())
    return DispatchEventResult::CanceledBeforeDispatch;
  DCHECK(event->type() == EventTypeNames::versionchange ||
         event->type() == EventTypeNames::close);
  for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
    if (m_enqueuedEvents[i].get() == event)
      m_enqueuedEvents.remove(i);
  }

  DispatchEventResult dispatchResult =
      EventTarget::dispatchEventInternal(event);
  if (event->type() == EventTypeNames::versionchange && !m_closePending &&
      m_backend)
    m_backend->versionChangeIgnored();
  return dispatchResult;
}

int64_t IDBDatabase::findObjectStoreId(const String& name) const {
  for (const auto& it : m_metadata.objectStores) {
    if (it.value.name == name) {
      DCHECK_NE(it.key, IDBObjectStoreMetadata::InvalidId);
      return it.key;
    }
  }
  return IDBObjectStoreMetadata::InvalidId;
}

void IDBDatabase::objectStoreRenamed(int64_t objectStoreId,
                                     const String& newName) {
  DCHECK(m_versionChangeTransaction)
      << "Object store renamed on database without a versionchange transaction";
  DCHECK(m_versionChangeTransaction->isActive())
      << "Object store renamed when versionchange transaction is not active";
  DCHECK(m_backend) << "Object store renamed after database connection closed";
  DCHECK(m_metadata.objectStores.contains(objectStoreId));
  IDBDatabaseMetadata::ObjectStoreMap::iterator it =
      m_metadata.objectStores.find(objectStoreId);
  it->value.name = newName;
}

bool IDBDatabase::hasPendingActivity() const {
  // The script wrapper must not be collected before the object is closed or
  // we can't fire a "versionchange" event to let script manually close the
  // connection.
  return !m_closePending && hasEventListeners() && !m_contextStopped;
}

void IDBDatabase::contextDestroyed() {
  m_contextStopped = true;

  // Immediately close the connection to the back end. Don't attempt a
  // normal close() since that may wait on transactions which require a
  // round trip to the back-end to abort.
  if (m_backend) {
    m_backend->close();
    m_backend.reset();
  }
}

const AtomicString& IDBDatabase::interfaceName() const {
  return EventTargetNames::IDBDatabase;
}

ExecutionContext* IDBDatabase::getExecutionContext() const {
  return ActiveDOMObject::getExecutionContext();
}

void IDBDatabase::recordApiCallsHistogram(IndexedDatabaseMethods method) {
  DEFINE_THREAD_SAFE_STATIC_LOCAL(
      EnumerationHistogram, apiCallsHistogram,
      new EnumerationHistogram("WebCore.IndexedDB.FrontEndAPICalls",
                               IDBMethodsMax));
  apiCallsHistogram.count(method);
}

}  // namespace blink