// Copyright 2026 The Fuchsia 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/developer/debug/zxdb/debug_adapter/data_id.h"

#include <inttypes.h>
#include <lib/syslog/cpp/macros.h>

#include <limits>
#include <string>
#include <string_view>

#include "src/developer/debug/shared/arch.h"
#include "src/developer/debug/zxdb/client/breakpoint_settings.h"
#include "src/developer/debug/zxdb/common/checked_math.h"
#include "src/developer/debug/zxdb/common/err_or.h"
#include "src/developer/debug/zxdb/expr/expr_value.h"
#include "src/lib/fxl/strings/split_string.h"
#include "src/lib/fxl/strings/string_number_conversions.h"
#include "src/lib/fxl/strings/string_printf.h"

namespace zxdb {

ErrOr<DataId> DataId::FromExprValue(debug::Arch arch, uint64_t process_koid, std::string_view name,
                                    const ExprValue& value) {
  FX_DCHECK(process_koid != 0);

  const ExprValueSource& source = value.source();
  if (source.type() != ExprValueSource::Type::kMemory) {
    return Err("Expression '" + std::string(name) + "' is stored in a " +
               ExprValueSource::TypeToString(source.type()) +
               " location. Only values stored in memory can be watched.");
  }

  if (source.is_bitfield()) {
    return Err("Bitfields cannot be watched.");
  }

  size_t raw_size = value.data().size();
  uint32_t size = raw_size > std::numeric_limits<uint32_t>::max()
                      ? std::numeric_limits<uint32_t>::max()
                      : static_cast<uint32_t>(raw_size);
  if (Err err = BreakpointSettings::ValidateSize(arch, BreakpointSettings::Type::kWrite, size);
      err.has_error()) {
    return err;
  }

  uint64_t address = source.address();
  if (!CheckedAdd(address, static_cast<uint64_t>(size)).has_value()) {
    return Err("Address range overflows 64-bit address space.");
  }

  return DataId(process_koid, address, size);
}

ErrOr<DataId> DataId::Parse(std::string_view data_id) {
  auto format_err = [&]() { return Err("Invalid dataId format: " + std::string(data_id)); };

  auto parts = fxl::SplitString(data_id, ":", fxl::kKeepWhitespace, fxl::kSplitWantAll);
  if (parts.size() != 3) {
    return format_err();
  }

  uint64_t koid = 0;
  if (!fxl::StringToNumberWithError<uint64_t>(parts[0], &koid, fxl::Base::k10) || koid == 0) {
    return format_err();
  }

  std::string_view addr_part = parts[1];
  std::string_view size_part = parts[2];

  if (addr_part.size() <= 2 || addr_part[0] != '0' ||
      (addr_part[1] != 'x' && addr_part[1] != 'X')) {
    return format_err();
  }

  uint64_t address = 0;
  uint32_t byte_size = 0;
  if (!fxl::StringToNumberWithError<uint64_t>(addr_part.substr(2), &address, fxl::Base::k16) ||
      !fxl::StringToNumberWithError<uint32_t>(size_part, &byte_size, fxl::Base::k10) ||
      byte_size == 0) {
    return format_err();
  }

  if (!CheckedAdd(address, static_cast<uint64_t>(byte_size)).has_value()) {
    return format_err();
  }

  return DataId(koid, address, byte_size);
}

ErrOr<BreakpointSettings::Type> DataId::ParseAccessType(std::string_view access_type) {
  if (access_type == "write") {
    return BreakpointSettings::Type::kWrite;
  }
  if (access_type == "readWrite") {
    return BreakpointSettings::Type::kReadWrite;
  }
  if (access_type == "read") {
    return Err("Read-only data breakpoints are not supported on this platform.");
  }
  return Err("Unknown accessType: " + std::string(access_type));
}

Err DataId::ValidateSize(debug::Arch arch, BreakpointSettings::Type type) const {
  return BreakpointSettings::ValidateSize(arch, type, byte_size_);
}

std::string DataId::ToString() const {
  return fxl::StringPrintf("%" PRIu64 ":0x%" PRIx64 ":%u", process_koid_, address_, byte_size_);
}

}  // namespace zxdb