// Copyright 2015 the V8 project 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 "src/profiler/strings-storage.h"

#include <memory>

#include "src/ast/ast-value-factory.h"
#include "src/base/bits.h"
#include "src/base/small-vector.h"
#include "src/base/strings.h"
#include "src/objects/objects-inl.h"
#include "src/strings/unicode-inl.h"
#include "src/utils/allocation.h"

namespace v8 {
namespace internal {

bool StringsStorage::StringsMatch(void* key1, void* key2) {
  return strcmp(reinterpret_cast<char*>(key1), reinterpret_cast<char*>(key2)) ==
         0;
}

StringsStorage::StringsStorage(uint32_t string_limit)
    : names_(StringsMatch), string_limit_(string_limit) {}

StringsStorage::~StringsStorage() {
  for (base::HashMap::Entry* p = names_.Start(); p != nullptr;
       p = names_.Next(p)) {
    DeleteArray(reinterpret_cast<const char*>(p->key));
  }
}

const char* StringsStorage::GetCopy(const char* src) {
  base::MutexGuard guard(&mutex_);
  int len = static_cast<int>(strlen(src));
  base::HashMap::Entry* entry = GetEntry(src, len);
  if (entry->value == nullptr) {
    base::Vector<char> dst = base::Vector<char>::New(len + 1);
    base::StrNCpy(dst, src, len);
    dst[len] = '\0';
    entry->key = dst.begin();
    string_size_ += len;
  }
  entry->value =
      reinterpret_cast<void*>(reinterpret_cast<size_t>(entry->value) + 1);
  return reinterpret_cast<const char*>(entry->key);
}

const char* StringsStorage::GetCopy(const AstRawString* src) {
  if (!src || src->IsEmpty()) return "";

  size_t capacity = src->length() * unibrow::Utf8::kMaxEncodedSize;
  base::SmallVector<char, 128> utf8_buffer;
  utf8_buffer.resize_no_init(capacity + 1);

  size_t bytes_written = 0;
  if (src->is_one_byte()) {
    // Characters in 0x80..0xFF need to be expanded to two bytes in UTF-8.
    bytes_written =
        unibrow::Utf8::Encode(
            base::Vector<const uint8_t>(src->raw_data(), src->length()),
            utf8_buffer.data(), capacity, /*write_null=*/false,
            /*replace_invalid_utf8=*/true)
            .bytes_written;
  } else {
    bytes_written = unibrow::Utf8::Encode(
                        base::Vector<const uint16_t>(
                            reinterpret_cast<const uint16_t*>(src->raw_data()),
                            src->length()),
                        utf8_buffer.data(), capacity, /*write_null=*/false,
                        /*replace_invalid_utf8=*/true)
                        .bytes_written;
  }
  utf8_buffer[bytes_written] = '\0';

  base::MutexGuard guard(&mutex_);
  base::HashMap::Entry* entry = GetEntry(utf8_buffer.data(), bytes_written);
  if (entry->value == nullptr) {
    base::Vector<char> dst = base::Vector<char>::New(bytes_written + 1);
    base::StrNCpy(dst, utf8_buffer.data(), bytes_written);
    dst[bytes_written] = '\0';
    entry->key = dst.begin();
    string_size_ += bytes_written;
  }
  entry->value =
      reinterpret_cast<void*>(reinterpret_cast<size_t>(entry->value) + 1);
  return reinterpret_cast<const char*>(entry->key);
}

const char* StringsStorage::GetFormatted(const char* format, ...) {
  va_list args;
  va_start(args, format);
  const char* result = GetVFormatted(format, args);
  va_end(args);
  return result;
}

const char* StringsStorage::AddOrDisposeString(char* str, size_t len) {
  base::MutexGuard guard(&mutex_);
  base::HashMap::Entry* entry = GetEntry(str, len);
  if (entry->value == nullptr) {
    // New entry added.
    entry->key = str;
    string_size_ += len;
  } else {
    DeleteArray(str);
  }
  entry->value =
      reinterpret_cast<void*>(reinterpret_cast<size_t>(entry->value) + 1);
  return reinterpret_cast<const char*>(entry->key);
}

const char* StringsStorage::GetVFormatted(const char* format, va_list args) {
  base::Vector<char> str = base::Vector<char>::New(4096);
  int len = base::VSNPrintF(str, format, args);
  if (len == -1) {
    return AddOrDisposeString(str.begin(), strlen(str.begin()));
  }
  return AddOrDisposeString(str.begin(), len);
}

const char* StringsStorage::GetSymbol(Tagged<Symbol> sym) {
  if (!IsString(sym->description())) {
    return "<symbol>";
  }
  Tagged<String> description = Cast<String>(sym->description());
  uint32_t length = GetTrimmedLength(description->length());
  size_t data_length = 0;
  auto data = description->ToCString(0, length, &data_length);
  if (sym->is_any_private_name()) {
    return AddOrDisposeString(data.release(), data_length);
  }
  auto str_length = 8 + data_length + 1 + 1;
  auto str_result = NewArray<char>(str_length);
  snprintf(str_result, str_length, "<symbol %s>", data.get());
  return AddOrDisposeString(str_result, str_length - 1);
}

const char* StringsStorage::GetName(Tagged<Name> name) {
  if (IsString(name)) {
    Tagged<String> str = Cast<String>(name);
    uint32_t length = GetTrimmedLength(str->length());
    size_t data_length = 0;
    std::unique_ptr<char[]> data = str->ToCString(0, length, &data_length);
    return AddOrDisposeString(data.release(), data_length);
  } else if (IsSymbol(name)) {
    return GetSymbol(Cast<Symbol>(name));
  }
  return "";
}

const char* StringsStorage::GetUntruncated(Tagged<String> string) {
  size_t data_length = 0;
  std::unique_ptr<char[]> data = string->ToCString(&data_length);
  return AddOrDisposeString(data.release(), data_length);
}

const char* StringsStorage::GetName(int index) {
  return GetFormatted("%d", index);
}

const char* StringsStorage::GetConsName(const char* prefix, Tagged<Name> name) {
  if (IsString(name)) {
    Tagged<String> str = Cast<String>(name);
    uint32_t length = GetTrimmedLength(str->length());
    size_t data_length = 0;
    std::unique_ptr<char[]> data = str->ToCString(0, length, &data_length);

    size_t cons_length = data_length + strlen(prefix) + 1;
    char* cons_result = NewArray<char>(cons_length);
    snprintf(cons_result, cons_length, "%s%s", prefix, data.get());

    return AddOrDisposeString(cons_result, cons_length - 1);
  } else if (IsSymbol(name)) {
    return GetSymbol(Cast<Symbol>(name));
  }
  return "";
}

bool StringsStorage::NeedsTruncation(uint32_t length) const {
  return length > GetTrimmedLength(length);
}

uint32_t StringsStorage::GetTrimmedLength(uint32_t length) const {
  if (string_limit_ == 0) return length;
  return std::min(string_limit_, length);
}

namespace {

inline uint32_t ComputeStringHash(const char* str, size_t len) {
  uint32_t raw_hash_field = base::bits::RotateLeft32(
      StringHasher::HashSequentialString(str, base::checked_cast<uint32_t>(len),
                                         HashSeed::Default()),
      2);
  return Name::HashBits::decode(raw_hash_field);
}

}  // namespace

bool StringsStorage::Release(const char* str) {
  base::MutexGuard guard(&mutex_);
  size_t len = strlen(str);
  uint32_t hash = ComputeStringHash(str, len);
  base::HashMap::Entry* entry = names_.Lookup(const_cast<char*>(str), hash);

  // If an entry wasn't found or the address of the found entry doesn't match
  // the one passed in, this string wasn't managed by this StringsStorage
  // instance (i.e. a constant). Ignore this.
  if (!entry || entry->key != str) {
    return false;
  }

  DCHECK(entry->value);
  entry->value =
      reinterpret_cast<void*>(reinterpret_cast<size_t>(entry->value) - 1);

  if (entry->value == 0) {
    string_size_ -= len;
    names_.Remove(const_cast<char*>(str), hash);
    DeleteArray(str);
  }
  return true;
}

size_t StringsStorage::GetStringCountForTesting() const {
  return names_.occupancy();
}

size_t StringsStorage::GetStringSize() {
  base::MutexGuard guard(&mutex_);
  return string_size_;
}

base::HashMap::Entry* StringsStorage::GetEntry(const char* str, size_t len) {
  uint32_t hash = ComputeStringHash(str, len);
  return names_.LookupOrInsert(const_cast<char*>(str), hash);
}

}  // namespace internal
}  // namespace v8