// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/modules/indexeddb/indexed_db_key_builder.h"

#include <stddef.h>

#include <algorithm>
#include <string>
#include <utility>
#include <vector>

#include "third_party/blink/public/common/indexeddb/indexeddb_key_range.h"
#include "third_party/blink/public/common/indexeddb/web_idb_types.h"
#include "third_party/blink/public/platform/web_string.h"
#include "third_party/blink/public/platform/web_vector.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
#include "third_party/blink/renderer/modules/indexeddb/web_idb_key.h"
#include "third_party/blink/renderer/modules/indexeddb/web_idb_key_path.h"
#include "third_party/blink/renderer/modules/indexeddb/web_idb_key_range.h"

namespace blink {

namespace {

IndexedDBKey::KeyArray CopyKeyArray(WebIDBKeyArrayView array) {
  IndexedDBKey::KeyArray result;
  const size_t array_size = array.size();
  result.reserve(array_size);
  for (size_t i = 0; i < array_size; ++i)
    result.emplace_back(IndexedDBKeyBuilder::Build(array[i]));
  return result;
}

std::vector<base::string16> CopyArray(const WebVector<WebString>& array) {
  std::vector<base::string16> result;
  result.reserve(array.size());
  for (const WebString& element : array)
    result.emplace_back(element.Utf16());
  return result;
}

}  // anonymous namespace

// static
IndexedDBKey IndexedDBKeyBuilder::Build(WebIDBKeyView key) {
  switch (key.KeyType()) {
    case mojom::IDBKeyType::Array:
      return IndexedDBKey(CopyKeyArray(key.ArrayView()));
    case mojom::IDBKeyType::Binary: {
      const WebData data = key.Binary();
      std::string key_string;
      key_string.reserve(data.size());

      data.ForEachSegment([&key_string](const char* segment,
                                        size_t segment_size,
                                        size_t segment_offset) {
        key_string.append(segment, segment_size);
        return true;
      });
      return IndexedDBKey(std::move(key_string));
    }
    case mojom::IDBKeyType::String:
      return IndexedDBKey(key.String().Utf16());
    case mojom::IDBKeyType::Date:
      return IndexedDBKey(key.Date(), blink::mojom::IDBKeyType::Date);
    case mojom::IDBKeyType::Number:
      return IndexedDBKey(key.Number(), blink::mojom::IDBKeyType::Number);
    case mojom::IDBKeyType::Null:
    case mojom::IDBKeyType::Invalid:
      return IndexedDBKey(key.KeyType());
    case mojom::IDBKeyType::Min:
      NOTREACHED();
      return IndexedDBKey();
  }
}

// static
WebIDBKey WebIDBKeyBuilder::Build(const WebIDBKeyView& key) {
  switch (key.KeyType()) {
    case mojom::IDBKeyType::Array: {
      const WebIDBKeyArrayView& array = key.ArrayView();
      WebVector<WebIDBKey> web_idb_keys;
      const size_t array_size = array.size();
      web_idb_keys.reserve(array_size);
      for (size_t i = 0; i < array_size; ++i)
        web_idb_keys.emplace_back(Build(array[i]));
      return WebIDBKey::CreateArray(std::move(web_idb_keys));
    }
    case mojom::IDBKeyType::Binary: {
      const WebData data = key.Binary();
      return WebIDBKey::CreateBinary(data);
    }
    case mojom::IDBKeyType::String:
      return WebIDBKey::CreateString(key.String());
    case mojom::IDBKeyType::Date:
      return WebIDBKey::CreateDate(key.Date());
    case mojom::IDBKeyType::Number:
      return WebIDBKey::CreateNumber(key.Number());
    case mojom::IDBKeyType::Invalid:
      return WebIDBKey::CreateInvalid();
    case mojom::IDBKeyType::Null:
      return WebIDBKey::CreateNull();
    case mojom::IDBKeyType::Min:
      NOTREACHED();
      return WebIDBKey::CreateInvalid();
  }
}

// static
WebIDBKey WebIDBKeyBuilder::Build(const IndexedDBKey& key) {
  switch (key.type()) {
    case mojom::IDBKeyType::Array: {
      const IndexedDBKey::KeyArray& array = key.array();
      WebVector<WebIDBKey> web_idb_keys;
      web_idb_keys.reserve(array.size());
      for (const IndexedDBKey& array_element : array)
        web_idb_keys.emplace_back(Build(array_element));
      return WebIDBKey::CreateArray(std::move(web_idb_keys));
    }
    case blink::mojom::IDBKeyType::Binary: {
      const std::string& str = key.binary();
      const WebData& data = WebData(str.c_str(), str.length());
      return WebIDBKey::CreateBinary(data);
    }
    case mojom::IDBKeyType::String:
      return WebIDBKey::CreateString(WebString::FromUTF16(key.string()));
    case blink::mojom::IDBKeyType::Date:
      return WebIDBKey::CreateDate(key.date());
    case blink::mojom::IDBKeyType::Number:
      return WebIDBKey::CreateNumber(key.number());
    case mojom::IDBKeyType::Invalid:
      return WebIDBKey::CreateInvalid();
    case mojom::IDBKeyType::Null:
      return WebIDBKey::CreateNull();
    case mojom::IDBKeyType::Min:
      NOTREACHED();
      return WebIDBKey::CreateInvalid();
  }
}

// static
IndexedDBKeyRange IndexedDBKeyRangeBuilder::Build(
    const WebIDBKeyRange& key_range) {
  return IndexedDBKeyRange(IndexedDBKeyBuilder::Build(key_range.Lower()),
                           IndexedDBKeyBuilder::Build(key_range.Upper()),
                           key_range.LowerOpen(), key_range.UpperOpen());
}

// static
IndexedDBKeyRange IndexedDBKeyRangeBuilder::Build(WebIDBKeyView key) {
  return IndexedDBKeyRange(IndexedDBKeyBuilder::Build(key),
                           IndexedDBKeyBuilder::Build(key),
                           false /* lower_open */, false /* upper_open */);
}

// static
WebIDBKeyRange WebIDBKeyRangeBuilder::Build(WebIDBKeyView key) {
  return WebIDBKeyRange(WebIDBKeyBuilder::Build(key),
                        WebIDBKeyBuilder::Build(key), false /* lower_open */,
                        false /* upper_open */);
}

// static
WebIDBKeyRange WebIDBKeyRangeBuilder::Build(
    const IndexedDBKeyRange& key_range) {
  return WebIDBKeyRange(WebIDBKeyBuilder::Build(key_range.lower()),
                        WebIDBKeyBuilder::Build(key_range.upper()),
                        key_range.lower_open(), key_range.upper_open());
}

// static
IndexedDBKeyPath IndexedDBKeyPathBuilder::Build(const WebIDBKeyPath& key_path) {
  switch (key_path.KeyPathType()) {
    case mojom::IDBKeyPathType::String:
      return IndexedDBKeyPath(key_path.String().Utf16());
    case mojom::IDBKeyPathType::Array:
      return IndexedDBKeyPath(CopyArray(key_path.Array()));
    case mojom::IDBKeyPathType::Null:
      return IndexedDBKeyPath();
  }
}

// static
WebIDBKeyPath WebIDBKeyPathBuilder::Build(const IndexedDBKeyPath& key_path) {
  switch (key_path.type()) {
    case mojom::IDBKeyPathType::String:
      return WebIDBKeyPath::Create(WebString::FromUTF16(key_path.string()));
    case mojom::IDBKeyPathType::Array: {
      WebVector<WebString> key_path_vector(key_path.array().size());
      for (const auto& item : key_path.array())
        key_path_vector.emplace_back(WebString::FromUTF16(item));
      return WebIDBKeyPath::Create(key_path_vector);
    }
    case mojom::IDBKeyPathType::Null:
      return WebIDBKeyPath::CreateNull();
  }
}

}  // namespace blink