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

#include "shill/default_profile.h"

#include <string>
#include <string_view>
#include <vector>

#include <base/files/file_path.h>
#include <base/strings/string_number_conversions.h>
#include <chromeos/dbus/service_constants.h>

#include "shill/adaptor_interfaces.h"
#include "shill/manager.h"
#include "shill/network/portal_detector.h"
#include "shill/resolver.h"
#include "shill/store/property_accessor.h"
#include "shill/store/store_interface.h"

namespace shill {

namespace {
// UseSwanctlDriver was removed in crrev.com/c/3857326.
// This was left here to remove UseSwanctlDriver entries from profiles.
constexpr char kStorageUseSwanctlDriver[] = "UseSwanctlDriver";

// Removed in crrev/c/5040178. Left to remove entries from profile.
constexpr char kStorageIgnoredDNSSearchPaths[] = "IgnoredDNSSearchPaths";
}  // namespace

// static
const char DefaultProfile::kDefaultId[] = "default";
// static
const char DefaultProfile::kStorageArpGateway[] = "ArpGateway";
// static
const char DefaultProfile::kStorageCheckPortalList[] = "CheckPortalList";
// static
const char DefaultProfile::kStorageName[] = "Name";
// static
const char DefaultProfile::kStorageNoAutoConnectTechnologies[] =
    "NoAutoConnectTechnologies";
// static
const char DefaultProfile::kStorageProhibitedTechnologies[] =
    "ProhibitedTechnologies";
// b/221171651: This string must stay consistent with the storage id used
// previously by DhcpProperties.
// static
const char DefaultProfile::kStorageDhcpHostname[] = "Hostname";
// static
const char DefaultProfile::kStorageWifiGlobalFTEnabled[] =
    "WiFi.GlobalFTEnabled";

DefaultProfile::DefaultProfile(Manager* manager,
                               const base::FilePath& storage_directory,
                               const std::string& profile_id,
                               const ManagerProperties& manager_props)
    : Profile(manager, Identifier(profile_id), storage_directory, true),
      profile_id_(profile_id),
      props_(manager_props) {
  PropertyStore* store = this->mutable_store();
  store->RegisterConstBool(kArpGatewayProperty, &manager_props.arp_gateway);
  store->RegisterConstString(kCheckPortalListProperty,
                             &manager_props.check_portal_list);
  store->RegisterConstString(kNoAutoConnectTechnologiesProperty,
                             &manager_props.no_auto_connect_technologies);
  store->RegisterConstString(kProhibitedTechnologiesProperty,
                             &manager_props.prohibited_technologies);
  HelpRegisterConstDerivedBool(kWifiGlobalFTEnabledProperty,
                               &DefaultProfile::GetFTEnabled);
  set_persistent_profile_path(
      GetFinalStoragePath(storage_directory, Identifier(profile_id)));
}

DefaultProfile::~DefaultProfile() = default;

void DefaultProfile::HelpRegisterConstDerivedBool(
    std::string_view name, bool (DefaultProfile::*get)(Error*)) {
  this->mutable_store()->RegisterDerivedBool(
      name, BoolAccessor(new CustomAccessor<DefaultProfile, bool>(
                this, get, nullptr, nullptr)));
}

bool DefaultProfile::GetFTEnabled(Error* error) {
  return manager()->GetFTEnabled(error);
}

void DefaultProfile::LoadManagerProperties(ManagerProperties* manager_props) {
  storage()->GetBool(kStorageId, kStorageArpGateway,
                     &manager_props->arp_gateway);
  storage()->GetBool(kStorageId, kStorageEnableRFC8925,
                     &manager_props->enable_rfc_8925);
  if (!storage()->GetString(kStorageId, kStorageCheckPortalList,
                            &manager_props->check_portal_list)) {
    manager_props->check_portal_list = PortalDetector::kDefaultCheckPortalList;
  }
  if (!storage()->GetString(kStorageId, kStorageNoAutoConnectTechnologies,
                            &manager_props->no_auto_connect_technologies)) {
    manager_props->no_auto_connect_technologies = "";
  }

  // This used to be loaded from the default profile, but now it is fixed.
  manager_props->portal_http_url = PortalDetector::kDefaultHttpUrl;
  manager_props->portal_https_url = PortalDetector::kDefaultHttpsUrl;
  manager_props->portal_fallback_http_urls =
      std::vector<std::string>(PortalDetector::kDefaultFallbackHttpUrls.begin(),
                               PortalDetector::kDefaultFallbackHttpUrls.end());
  manager_props->portal_fallback_https_urls = std::vector<std::string>(
      PortalDetector::kDefaultFallbackHttpsUrls.begin(),
      PortalDetector::kDefaultFallbackHttpsUrls.end());

  if (!storage()->GetString(kStorageId, kStorageProhibitedTechnologies,
                            &manager_props->prohibited_technologies)) {
    manager_props->prohibited_technologies = "";
  }

  if (!storage()->GetString(kStorageId, kStorageDhcpHostname,
                            &manager_props->dhcp_hostname)) {
    manager_props->dhcp_hostname = "";
  }

  bool ft_enabled;
  if (storage()->GetBool(kStorageId, kStorageWifiGlobalFTEnabled,
                         &ft_enabled)) {
    manager_props->ft_enabled = ft_enabled;
  }

  manager_props->request_scan_type = kWiFiRequestScanTypeDefault;

  manager_props->disconnect_wifi_on_ethernet =
      ManagerProperties::DisconnectWiFiOnEthernet::kOff;
  std::string disconnect_wifi_property;
  if (storage()->GetString(kStorageId, kStorageDisableWiFiOnEthernet,
                           &disconnect_wifi_property)) {
    if (base::EqualsCaseInsensitiveASCII(
            disconnect_wifi_property, kStorageDisableWiFiOnEthernetConnected)) {
      manager_props->disconnect_wifi_on_ethernet =
          ManagerProperties::DisconnectWiFiOnEthernet::kConnected;
    }
    if (base::EqualsCaseInsensitiveASCII(disconnect_wifi_property,
                                         kStorageDisableWiFiOnEthernetOnline)) {
      manager_props->disconnect_wifi_on_ethernet =
          ManagerProperties::DisconnectWiFiOnEthernet::kOnline;
    }
  }
}

bool DefaultProfile::ConfigureService(const ServiceRefPtr& service) {
  if (Profile::ConfigureService(service)) {
    return true;
  }
  if (service->technology() == Technology::kEthernet) {
    // Ethernet services should have an affinity towards the default profile,
    // so even if a new Ethernet service has no known configuration, accept
    // it anyway.
    UpdateService(service);
    service->SetProfile(this);
    return true;
  }
  return false;
}

bool DefaultProfile::Save() {
  // UseSwanctlDriver was removed in crrev.com/c/3857326.
  storage()->DeleteKey(kStorageId, kStorageUseSwanctlDriver);
  // IgnoredDNSSearchPaths was removed in crrev/c/5040178Í.
  storage()->DeleteKey(kStorageId, kStorageIgnoredDNSSearchPaths);

  storage()->SetBool(kStorageId, kStorageArpGateway, props_.arp_gateway);
  storage()->SetBool(kStorageId, kStorageEnableRFC8925, props_.enable_rfc_8925);
  storage()->SetString(kStorageId, kStorageName, GetFriendlyName());
  storage()->SetString(kStorageId, kStorageCheckPortalList,
                       props_.check_portal_list);
  storage()->SetString(kStorageId, kStorageNoAutoConnectTechnologies,
                       props_.no_auto_connect_technologies);
  storage()->SetString(kStorageId, kStorageProhibitedTechnologies,
                       props_.prohibited_technologies);
  if (!props_.dhcp_hostname.empty()) {
    storage()->SetString(kStorageId, kStorageDhcpHostname,
                         props_.dhcp_hostname);
  }
  if (props_.ft_enabled.has_value()) {
    storage()->SetBool(kStorageId, kStorageWifiGlobalFTEnabled,
                       props_.ft_enabled.value());
  }
  switch (props_.disconnect_wifi_on_ethernet) {
    case ManagerProperties::DisconnectWiFiOnEthernet::kOff:
      storage()->DeleteKey(kStorageId, kStorageDisableWiFiOnEthernet);
      break;
    case ManagerProperties::DisconnectWiFiOnEthernet::kConnected:
      storage()->SetString(kStorageId, kStorageDisableWiFiOnEthernet,
                           kStorageDisableWiFiOnEthernetConnected);
      break;
    case ManagerProperties::DisconnectWiFiOnEthernet::kOnline:
      storage()->SetString(kStorageId, kStorageDisableWiFiOnEthernet,
                           kStorageDisableWiFiOnEthernetOnline);
      break;
  }
  return Profile::Save();
}

bool DefaultProfile::UpdateDevice(const DeviceRefPtr& device) {
  return device->Save(storage()) && storage()->Flush();
}

}  // namespace shill