/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <limits.h>

#include "mozilla/UniquePtrExtensions.h"

#include "nsString.h"

#include "mozStorageError.h"

#include "mozStoragePrivateHelpers.h"

#include "mozStorageBindingParams.h"

#include "mozStorageBindingParamsArray.h"

#include "Variant.h"

namespace mozilla {

namespace storage {

////////////////////////////////////////////////////////////////////////////////

//// Local Helper Objects

namespace {

struct BindingColumnData

{

  BindingColumnData(sqlite3_stmt *aStmt,

                    int aColumn)

  : stmt(aStmt)

  , column(aColumn)

  {

  }

  sqlite3_stmt *stmt;

  int column;

};

////////////////////////////////////////////////////////////////////////////////

//// Variant Specialization Functions (variantToSQLiteT)

int

sqlite3_T_int(BindingColumnData aData,

              int aValue)

{

  return ::sqlite3_bind_int(aData.stmt, aData.column + 1, aValue);

}

int

sqlite3_T_int64(BindingColumnData aData,

                sqlite3_int64 aValue)

{

  return ::sqlite3_bind_int64(aData.stmt, aData.column + 1, aValue);

}

int

sqlite3_T_double(BindingColumnData aData,

                 double aValue)

{

  return ::sqlite3_bind_double(aData.stmt, aData.column + 1, aValue);

}

int

sqlite3_T_text(BindingColumnData aData,

               const nsCString& aValue)

{

  return ::sqlite3_bind_text(aData.stmt,

                             aData.column + 1,

                             aValue.get(),

                             aValue.Length(),

                             SQLITE_TRANSIENT);

}

int

sqlite3_T_text16(BindingColumnData aData,

                 const nsString& aValue)

{

  return ::sqlite3_bind_text16(aData.stmt,

                               aData.column + 1,

                               aValue.get(),

                               aValue.Length() * 2, // Length in bytes!

                               SQLITE_TRANSIENT);

}

int

sqlite3_T_null(BindingColumnData aData)

{

  return ::sqlite3_bind_null(aData.stmt, aData.column + 1);

}

int

sqlite3_T_blob(BindingColumnData aData,

               const void *aBlob,

               int aSize)

{

  return ::sqlite3_bind_blob(aData.stmt, aData.column + 1, aBlob, aSize,

                             free);

}

#include "variantToSQLiteT_impl.h"

} // namespace

////////////////////////////////////////////////////////////////////////////////

//// BindingParams

BindingParams::BindingParams(mozIStorageBindingParamsArray *aOwningArray,

                             Statement *aOwningStatement)

: mLocked(false)

, mOwningArray(aOwningArray)

, mOwningStatement(aOwningStatement)

, mParamCount(0)

{

  (void)mOwningStatement->GetParameterCount(&mParamCount);

  mParameters.SetCapacity(mParamCount);

}

BindingParams::BindingParams(mozIStorageBindingParamsArray *aOwningArray)

: mLocked(false)

, mOwningArray(aOwningArray)

, mOwningStatement(nullptr)

, mParamCount(0)

{

}

AsyncBindingParams::AsyncBindingParams(

  mozIStorageBindingParamsArray *aOwningArray

)

: BindingParams(aOwningArray)

{

}

void

BindingParams::lock()

{

  NS_ASSERTION(mLocked == false, "Parameters have already been locked!");

  mLocked = true;

  // We no longer need to hold a reference to our statement or our owning array.

  // The array owns us at this point, and it will own a reference to the

  // statement.

  mOwningStatement = nullptr;

  mOwningArray = nullptr;

}

void

BindingParams::unlock(Statement *aOwningStatement)

{

  NS_ASSERTION(mLocked == true, "Parameters were not yet locked!");

  mLocked = false;

  mOwningStatement = aOwningStatement;

}

const mozIStorageBindingParamsArray *

BindingParams::getOwner() const

{

  return mOwningArray;

}

////////////////////////////////////////////////////////////////////////////////

//// nsISupports

NS_IMPL_ISUPPORTS(

  BindingParams

, mozIStorageBindingParams

, IStorageBindingParamsInternal

)

////////////////////////////////////////////////////////////////////////////////

//// IStorageBindingParamsInternal

already_AddRefed<mozIStorageError>

BindingParams::bind(sqlite3_stmt *aStatement)

{

  // Iterate through all of our stored data, and bind it.

  for (size_t i = 0; i < mParameters.Length(); i++) {

    int rc = variantToSQLiteT(BindingColumnData(aStatement, i), mParameters[i]);

    if (rc != SQLITE_OK) {

      // We had an error while trying to bind.  Now we need to create an error

      // object with the right message.  Note that we special case

      // SQLITE_MISMATCH, but otherwise get the message from SQLite.

      const char *msg = "Could not covert nsIVariant to SQLite type.";

      if (rc != SQLITE_MISMATCH)

        msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement));

      nsCOMPtr<mozIStorageError> err(new Error(rc, msg));

      return err.forget();

    }

  }

  return nullptr;

}

already_AddRefed<mozIStorageError>

AsyncBindingParams::bind(sqlite3_stmt * aStatement)

{

  // We should bind by index using the super-class if there is nothing in our

  // hashtable.

  if (!mNamedParameters.Count())

    return BindingParams::bind(aStatement);

  nsCOMPtr<mozIStorageError> err;

  for (auto iter = mNamedParameters.Iter(); !iter.Done(); iter.Next()) {

    const nsACString &key = iter.Key();

    // We do not accept any forms of names other than ":name", but we need to

    // add the colon for SQLite.

    nsAutoCString name(":");

    name.Append(key);

    int oneIdx = ::sqlite3_bind_parameter_index(aStatement, name.get());

    if (oneIdx == 0) {

      nsAutoCString errMsg(key);

      errMsg.AppendLiteral(" is not a valid named parameter.");

      err = new Error(SQLITE_RANGE, errMsg.get());

      break;

    }

    // XPCVariant's AddRef and Release are not thread-safe and so we must not

    // do anything that would invoke them here on the async thread.  As such we

    // can't cram aValue into mParameters using ReplaceObjectAt so that

    // we can freeload off of the BindingParams::Bind implementation.

    int rc = variantToSQLiteT(BindingColumnData(aStatement, oneIdx - 1),

                              iter.UserData());

    if (rc != SQLITE_OK) {

      // We had an error while trying to bind.  Now we need to create an error

      // object with the right message.  Note that we special case

      // SQLITE_MISMATCH, but otherwise get the message from SQLite.

      const char *msg = "Could not covert nsIVariant to SQLite type.";

      if (rc != SQLITE_MISMATCH) {

        msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement));

      }

      err = new Error(rc, msg);

      break;

    }

  }

  return err.forget();

}

///////////////////////////////////////////////////////////////////////////////

//// mozIStorageBindingParams

NS_IMETHODIMP

BindingParams::BindByName(const nsACString &aName,

                          nsIVariant *aValue)

{

  NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);

  // Get the column index that we need to store this at.

  uint32_t index;

  nsresult rv = mOwningStatement->GetParameterIndex(aName, &index);

  NS_ENSURE_SUCCESS(rv, rv);

  return BindByIndex(index, aValue);

}

NS_IMETHODIMP

AsyncBindingParams::BindByName(const nsACString &aName,

                               nsIVariant *aValue)

{

  NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);

  RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);

  if (!variant)

    return NS_ERROR_UNEXPECTED;

  mNamedParameters.Put(aName, variant);

  return NS_OK;

}

NS_IMETHODIMP

BindingParams::BindUTF8StringByName(const nsACString &aName,

                                    const nsACString &aValue)

{

  nsCOMPtr<nsIVariant> value(new UTF8TextVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindStringByName(const nsACString &aName,

                                const nsAString &aValue)

{

  nsCOMPtr<nsIVariant> value(new TextVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindDoubleByName(const nsACString &aName,

                                double aValue)

{

  nsCOMPtr<nsIVariant> value(new FloatVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindInt32ByName(const nsACString &aName,

                               int32_t aValue)

{

  nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindInt64ByName(const nsACString &aName,

                               int64_t aValue)

{

  nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindNullByName(const nsACString &aName)

{

  nsCOMPtr<nsIVariant> value(new NullVariant());

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindBlobByName(const nsACString &aName,

                              const uint8_t *aValue,

                              uint32_t aValueSize)

{

  NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);

  std::pair<const void *, int> data(

    static_cast<const void *>(aValue),

    int(aValueSize)

  );

  nsCOMPtr<nsIVariant> value(new BlobVariant(data));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindStringAsBlobByName(const nsACString& aName,

                                      const nsAString& aValue)

{

  return DoBindStringAsBlobByName(this, aName, aValue);

}

NS_IMETHODIMP

BindingParams::BindUTF8StringAsBlobByName(const nsACString& aName,

                                          const nsACString& aValue)

{

  return DoBindStringAsBlobByName(this, aName, aValue);

}

NS_IMETHODIMP

BindingParams::BindAdoptedBlobByName(const nsACString &aName,

                                     uint8_t *aValue,

                                     uint32_t aValueSize)

{

  UniqueFreePtr<uint8_t> uniqueValue(aValue);

  NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);

  std::pair<uint8_t *, int> data(uniqueValue.release(), int(aValueSize));

  nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));

  return BindByName(aName, value);

}

NS_IMETHODIMP

BindingParams::BindByIndex(uint32_t aIndex,

                           nsIVariant *aValue)

{

  NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);

  ENSURE_INDEX_VALUE(aIndex, mParamCount);

  // Store the variant for later use.

  RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);

  if (!variant)

    return NS_ERROR_UNEXPECTED;

  if (mParameters.Length() <= aIndex) {

    (void)mParameters.SetLength(aIndex);

    (void)mParameters.AppendElement(variant);

  }

  else {

    NS_ENSURE_TRUE(mParameters.ReplaceElementAt(aIndex, variant),

                   NS_ERROR_OUT_OF_MEMORY);

  }

  return NS_OK;

}

NS_IMETHODIMP

AsyncBindingParams::BindByIndex(uint32_t aIndex,

                                nsIVariant *aValue)

{

  NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);

  // In the asynchronous case we do not know how many parameters there are to

  // bind to, so we cannot check the validity of aIndex.

  RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);

  if (!variant)

    return NS_ERROR_UNEXPECTED;

  if (mParameters.Length() <= aIndex) {

    mParameters.SetLength(aIndex);

    mParameters.AppendElement(variant);

  }

  else {

    NS_ENSURE_TRUE(mParameters.ReplaceElementAt(aIndex, variant),

                   NS_ERROR_OUT_OF_MEMORY);

  }

  return NS_OK;

}

NS_IMETHODIMP

BindingParams::BindUTF8StringByIndex(uint32_t aIndex,

                                     const nsACString &aValue)

{

  nsCOMPtr<nsIVariant> value(new UTF8TextVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindStringByIndex(uint32_t aIndex,

                                 const nsAString &aValue)

{

  nsCOMPtr<nsIVariant> value(new TextVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindDoubleByIndex(uint32_t aIndex,

                                 double aValue)

{

  nsCOMPtr<nsIVariant> value(new FloatVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindInt32ByIndex(uint32_t aIndex,

                                int32_t aValue)

{

  nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindInt64ByIndex(uint32_t aIndex,

                                int64_t aValue)

{

  nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindNullByIndex(uint32_t aIndex)

{

  nsCOMPtr<nsIVariant> value(new NullVariant());

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindBlobByIndex(uint32_t aIndex,

                               const uint8_t *aValue,

                               uint32_t aValueSize)

{

  NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);

  std::pair<const void *, int> data(

    static_cast<const void *>(aValue),

    int(aValueSize)

  );

  nsCOMPtr<nsIVariant> value(new BlobVariant(data));

  NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);

  return BindByIndex(aIndex, value);

}

NS_IMETHODIMP

BindingParams::BindStringAsBlobByIndex(uint32_t aIndex, const nsAString& aValue)

{

  return DoBindStringAsBlobByIndex(this, aIndex, aValue);

}

NS_IMETHODIMP

BindingParams::BindUTF8StringAsBlobByIndex(uint32_t aIndex,

                                           const nsACString& aValue)

{

  return DoBindStringAsBlobByIndex(this, aIndex, aValue);

}

NS_IMETHODIMP

BindingParams::BindAdoptedBlobByIndex(uint32_t aIndex,

                                      uint8_t *aValue,

                                      uint32_t aValueSize)

{

  UniqueFreePtr<uint8_t> uniqueValue(aValue);

  NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);

  std::pair<uint8_t *, int> data(uniqueValue.release(), int(aValueSize));

  nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));

  return BindByIndex(aIndex, value);

}

} // namespace storage

} // namespace mozilla