// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ash/system_logs/shill_log_source.h"

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/json/json_writer.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "chrome/browser/ash/system_logs/shill_log_pii_identifiers.h"
#include "chromeos/ash/components/dbus/shill/shill_device_client.h"
#include "chromeos/ash/components/dbus/shill/shill_ipconfig_client.h"
#include "chromeos/ash/components/dbus/shill/shill_manager_client.h"
#include "chromeos/ash/components/dbus/shill/shill_service_client.h"
#include "chromeos/ash/components/network/network_event_log.h"
#include "chromeos/components/onc/onc_utils.h"
#include "dbus/object_path.h"
#include "third_party/cros_system_api/dbus/service_constants.h"

namespace {

constexpr char kNetworkDevices[] = "network_devices";
constexpr char kNetworkServices[] = "network_services";
constexpr char kServicePrefix[] = "/service/";
constexpr char kDevicePrefix[] = "/device/";

std::string GetString(const base::Value* value) {
  if (!value)
    return std::string();
  if (!value->is_string()) {
    LOG(ERROR) << "Bad string value: " << *value;
    return std::string();
  }
  return value->GetString();
}

constexpr char kMaskedString[] = "*** MASKED ***";

// Recursively scrubs dictionaries, masking any values in
// system_logs::MakeFixedFlatMap.
void ScrubDictionary(base::Value::Dict& dict) {
  for (auto entry : dict) {
    base::Value& value = entry.second;
    if (value.is_dict()) {
      ScrubDictionary(entry.second.GetDict());
    } else if (base::Contains(system_logs::kShillPIIMaskedMap, entry.first) &&
               system_logs::kShillPIIMaskedMap.at(entry.first) !=
                   redaction::PIIType::kNone &&
               (!value.is_string() || !value.GetString().empty())) {
      entry.second = base::Value(kMaskedString);
    }
  }
}

}  // namespace

namespace system_logs {

ShillLogSource::ShillLogSource(bool scrub)
    : SystemLogsSource("Shill"), scrub_(scrub) {}

ShillLogSource::~ShillLogSource() = default;

void ShillLogSource::Fetch(SysLogsSourceCallback callback) {
  DCHECK(!callback.is_null());
  DCHECK(callback_.is_null());
  callback_ = std::move(callback);

  ash::ShillManagerClient::Get()->GetProperties(base::BindOnce(
      &ShillLogSource::OnGetManagerProperties, weak_ptr_factory_.GetWeakPtr()));
}

void ShillLogSource::OnGetManagerProperties(
    std::optional<base::Value::Dict> result) {
  if (!result) {
    LOG(ERROR) << "ManagerPropertiesCallback Failed";
    std::move(callback_).Run(std::make_unique<SystemLogsResponse>());
    return;
  }

  const base::Value::List* devices = result->FindList(shill::kDevicesProperty);
  if (devices) {
    for (const base::Value& device : *devices) {
      std::string path = GetString(&device);
      if (path.empty())
        continue;
      device_paths_.insert(path);
      ash::ShillDeviceClient::Get()->GetProperties(
          dbus::ObjectPath(path),
          base::BindOnce(&ShillLogSource::OnGetDevice,
                         weak_ptr_factory_.GetWeakPtr(), path));
    }
  }

  const base::Value::List* services =
      result->FindList(shill::kServicesProperty);
  if (services) {
    for (const base::Value& service : *services) {
      std::string path = GetString(&service);
      if (path.empty())
        continue;
      service_paths_.insert(path);
      ash::ShillServiceClient::Get()->GetProperties(
          dbus::ObjectPath(path),
          base::BindOnce(&ShillLogSource::OnGetService,
                         weak_ptr_factory_.GetWeakPtr(), path));
    }
  }

  CheckIfDone();
}

void ShillLogSource::OnGetDevice(const std::string& device_path,
                                 std::optional<base::Value::Dict> properties) {
  if (!properties) {
    LOG(ERROR) << "Get Device Properties Failed for : " << device_path;
  } else {
    AddDeviceAndRequestIPConfigs(device_path, *properties);
  }
  device_paths_.erase(device_path);
  CheckIfDone();
}

void ShillLogSource::AddDeviceAndRequestIPConfigs(
    const std::string& device_path,
    const base::Value::Dict& properties) {
  base::Value* device = devices_.Set(
      device_path, ScrubAndExpandProperties(device_path, properties));

  const base::Value::List* ip_configs =
      properties.FindList(shill::kIPConfigsProperty);
  if (!ip_configs) {
    return;
  }

  for (const base::Value& ip_config : *ip_configs) {
    std::string ip_config_path = GetString(&ip_config);
    if (ip_config_path.empty()) {
      continue;
    }
    ip_config_paths_.insert(ip_config_path);
    ash::ShillIPConfigClient::Get()->GetProperties(
        dbus::ObjectPath(ip_config_path),
        base::BindOnce(&ShillLogSource::OnGetIPConfig,
                       weak_ptr_factory_.GetWeakPtr(), device_path,
                       ip_config_path));
  }
  if (!ip_config_paths_.empty()) {
    device->GetDict().Set(shill::kIPConfigsProperty, base::Value::Dict{});
  }
}

void ShillLogSource::OnGetIPConfig(
    const std::string& device_path,
    const std::string& ip_config_path,
    std::optional<base::Value::Dict> properties) {
  if (!properties) {
    LOG(ERROR) << "Get IPConfig Properties Failed for : " << device_path << ": "
               << ip_config_path;
  } else {
    AddIPConfig(device_path, ip_config_path, *properties);
  }
  // Erase a single matching entry.
  ip_config_paths_.erase(ip_config_paths_.find(ip_config_path));
  CheckIfDone();
}

void ShillLogSource::AddIPConfig(const std::string& device_path,
                                 const std::string& ip_config_path,
                                 const base::Value::Dict& properties) {
  base::Value::Dict* device = devices_.FindDict(device_path);
  DCHECK(device);
  base::Value::Dict* ip_configs = device->FindDict(shill::kIPConfigsProperty);
  DCHECK(ip_configs);
  ip_configs->Set(ip_config_path,
                  ScrubAndExpandProperties(ip_config_path, properties));
}

void ShillLogSource::OnGetService(const std::string& service_path,
                                  std::optional<base::Value::Dict> properties) {
  if (!properties) {
    LOG(ERROR) << "Get Service Properties Failed for : " << service_path;
  } else {
    services_.Set(service_path,
                  ScrubAndExpandProperties(service_path, properties.value()));
  }
  service_paths_.erase(service_path);
  CheckIfDone();
}

base::Value::Dict ShillLogSource::ScrubAndExpandProperties(
    const std::string& object_path,
    const base::Value::Dict& properties) {
  base::Value::Dict dict = properties.Clone();

  // Convert UIData from a string to a dictionary.
  std::string* ui_data = dict.FindString(shill::kUIDataProperty);
  if (ui_data) {
    std::optional<base::Value::Dict> ui_data_dict =
        chromeos::onc::ReadDictionaryFromJson(*ui_data);
    if (ui_data_dict.has_value()) {
      dict.Set(shill::kUIDataProperty, std::move(*ui_data_dict));
    }
  }

  if (!scrub_)
    return dict;

  if (base::StartsWith(object_path, kServicePrefix,
                       base::CompareCase::SENSITIVE)) {
    std::string log_name = ash::NetworkPathId(object_path);  // Not PII
    dict.Set(shill::kNameProperty, log_name);
  } else if (base::StartsWith(object_path, kDevicePrefix,
                              base::CompareCase::SENSITIVE)) {
    dict.Set(shill::kNameProperty, kMaskedString);
    // Only mask "Address" in the top level Device dictionary, not globally
    // (which would mask IPConfigs which get anonymized separately).
    if (dict.contains(shill::kAddressProperty)) {
      dict.Set(shill::kAddressProperty, kMaskedString);
    }
  }

  ScrubDictionary(dict);
  return dict;
}

void ShillLogSource::CheckIfDone() {
  if (!device_paths_.empty() || !ip_config_paths_.empty() ||
      !service_paths_.empty()) {
    return;
  }

  std::map<std::string, std::string> response;
  std::string json;
  base::JSONWriter::WriteWithOptions(
      devices_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
  response[kNetworkDevices] = std::move(json);
  base::JSONWriter::WriteWithOptions(
      services_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
  response[kNetworkServices] = std::move(json);

  // Clear |devices_| and |services_|.
  devices_.clear();
  services_.clear();

  std::move(callback_).Run(
      std::make_unique<SystemLogsResponse>(std::move(response)));
}

}  // namespace system_logs