//
// Copyright (C) 2015 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include <base/strings/string_number_conversions.h>

#include "proxy_dbus_shill_wifi_client.h"

namespace {
const int kRescanIntervalMilliseconds = 200;
const int kServiceDisconnectTimeoutMilliseconds = 5000;
const char kDefaultBgscanMethod[] = "default";
const char kDefaultProfileName[] = "default";
} // namespace

ProxyDbusShillWifiClient::ProxyDbusShillWifiClient(
    scoped_refptr<dbus::Bus> dbus_bus) {
  dbus_client_.reset(new ProxyDbusClient(dbus_bus));
}

bool ProxyDbusShillWifiClient::SetLogging() {
  dbus_client_->SetLogging(ProxyDbusClient::TECHNOLOGY_WIFI);
  return true;
}

bool ProxyDbusShillWifiClient::RemoveAllWifiEntries() {
  for (auto& profile_proxy : dbus_client_->GetProfileProxies()) {
    brillo::Any property_value;
    CHECK(dbus_client_->GetPropertyValueFromProfileProxy(
          profile_proxy.get(), shill::kEntriesProperty, &property_value));
    auto entry_ids = property_value.Get<std::vector<std::string>>();
    for (const auto& entry_id : entry_ids) {
      brillo::VariantDictionary entry_props;
      if (profile_proxy->GetEntry(entry_id, &entry_props, nullptr)) {
        if (entry_props[shill::kTypeProperty].Get<std::string>() ==
            shill::kTypeWifi) {
          profile_proxy->DeleteEntry(entry_id, nullptr);
        }
      }
    }
  }
  return true;
}

bool ProxyDbusShillWifiClient::ConfigureServiceByGuid(
    const std::string& guid,
    AutoConnectType autoconnect,
    const std::string& passphrase) {
  brillo::VariantDictionary service_params;
  if (guid.empty()) {
    return false;
  }
  SetAutoConnectInServiceParams(autoconnect, &service_params);
  if (!passphrase.empty()) {
    service_params.insert(std::make_pair(
        shill::kPassphraseProperty, brillo::Any(passphrase)));
  }
  return dbus_client_->ConfigureServiceByGuid(guid, service_params);
}

bool ProxyDbusShillWifiClient::ConfigureWifiService(
    const std::string& ssid,
    const std::string& security,
    const brillo::VariantDictionary& security_params,
    bool save_credentials,
    StationType station_type,
    bool hidden_network,
    const std::string& guid,
    AutoConnectType autoconnect) {
  brillo::VariantDictionary service_params;
  // Create the configure params dictionary.
  service_params.insert(std::make_pair(
      shill::kTypeProperty, brillo::Any(std::string(shill::kTypeWifi))));
  service_params.insert(std::make_pair(
      shill::kWifiHiddenSsid, brillo::Any(hidden_network)));
  service_params.insert(std::make_pair(
      shill::kSSIDProperty, brillo::Any(ssid)));
  service_params.insert(std::make_pair(
      shill::kSecurityClassProperty, brillo::Any(security)));
  service_params.insert(std::make_pair(
      shill::kModeProperty, brillo::Any(GetModeFromStationType(station_type))));
  SetAutoConnectInServiceParams(autoconnect, &service_params);
  service_params.insert(security_params.begin(), security_params.end());
  if (!guid.empty()) {
    service_params.insert(std::make_pair(
        shill::kGuidProperty, brillo::Any(guid)));
  }
  for (const auto& param: service_params) {
    LOG(INFO) << __func__ << ". Param: " << param.first << "="
              << param.second.TryGet<bool>() << ","
              << param.second.TryGet<int>() << ","
              << param.second.TryGet<std::string>() << ".";
  }
  return dbus_client_->ConfigureService(service_params);
}

bool ProxyDbusShillWifiClient::ConnectToWifiNetwork(
    const std::string& ssid,
    const std::string& security,
    const brillo::VariantDictionary& security_params,
    bool save_credentials,
    StationType station_type,
    bool hidden_network,
    const std::string& guid,
    AutoConnectType autoconnect,
    long discovery_timeout_milliseconds,
    long association_timeout_milliseconds,
    long configuration_timeout_milliseconds,
    long* discovery_time_milliseconds,
    long* association_time_milliseconds,
    long* configuration_time_milliseconds,
    std::string* failure_reason) {
  *discovery_time_milliseconds = -1;
  *association_time_milliseconds = -1;
  *configuration_time_milliseconds = -1;
  if (station_type != kStationTypeManaged &&
      station_type != kStationTypeIBSS) {
    *failure_reason = "FAIL(Invalid station type specified.)";
    return false;
  }
  if (hidden_network && !ConfigureWifiService(
          ssid, security, security_params, save_credentials, station_type,
          hidden_network, guid,autoconnect)) {
    *failure_reason = "FAIL(Failed to configure hidden SSID)";
    return false;
  }
  brillo::VariantDictionary service_params;
  service_params.insert(std::make_pair(
      shill::kTypeProperty, brillo::Any(std::string(shill::kTypeWifi))));
  service_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(ssid)));
  service_params.insert(std::make_pair(
      shill::kSecurityClassProperty, brillo::Any(security)));
  service_params.insert(std::make_pair(
      shill::kModeProperty, brillo::Any(GetModeFromStationType(station_type))));
  for (const auto& param: service_params) {
    LOG(INFO) << __func__ << ". Param: " << param.first << "="
              << param.second.TryGet<bool>() << ","
              << param.second.TryGet<int>() << ","
              << param.second.TryGet<std::string>() << ".";
  }
  brillo::Any signal_strength;
  auto service = dbus_client_->WaitForMatchingServiceProxy(
      service_params, shill::kTypeWifi, discovery_timeout_milliseconds,
      kRescanIntervalMilliseconds, discovery_time_milliseconds);
  if (!service ||
      !dbus_client_->GetPropertyValueFromServiceProxy(
          service.get(), shill::kSignalStrengthProperty, &signal_strength) ||
      (signal_strength.Get<uint8_t>() < 0)) {
    *failure_reason = "FAIL(Discovery timed out)";
    return false;
  }

  for (const auto& security_param : security_params) {
    CHECK(service->SetProperty(security_param.first, security_param.second, nullptr));
  }
  if (!guid.empty()) {
    CHECK(service->SetProperty(shill::kGuidProperty, brillo::Any(guid), nullptr));
  }
  if (autoconnect != kAutoConnectTypeUnspecified) {
    CHECK(service->SetProperty(
        shill::kAutoConnectProperty, brillo::Any(bool(autoconnect)), nullptr));
  }

  brillo::ErrorPtr error;
  if (!service->Connect(&error) &&
      error->GetCode() != shill::kErrorResultAlreadyConnected) {
    *failure_reason = "FAIL(Failed to call connect)";
    return false;
  }

  brillo::Any final_value;
  std::vector<brillo::Any> associated_states = {
    brillo::Any(std::string("configuration")),
    brillo::Any(std::string("ready")),
    brillo::Any(std::string("portal")),
    brillo::Any(std::string("online")) };
  if (!dbus_client_->WaitForServiceProxyPropertyValueIn(
          service->GetObjectPath(), shill::kStateProperty, associated_states,
          association_timeout_milliseconds, &final_value,
          association_time_milliseconds)) {
    *failure_reason = "FAIL(Association timed out)";
    LOG(ERROR) << "FAIL(Association timed out). Final State: " <<
      final_value.Get<std::string>();
    return false;
  }

  std::vector<brillo::Any> configured_states = {
    brillo::Any(std::string("ready")),
    brillo::Any(std::string("portal")),
    brillo::Any(std::string("online")) };
  if (!dbus_client_->WaitForServiceProxyPropertyValueIn(
          service->GetObjectPath(), shill::kStateProperty, configured_states,
          configuration_timeout_milliseconds, nullptr,
          configuration_time_milliseconds)) {
    *failure_reason = "FAIL(Configuration timed out)";
    LOG(ERROR) << "FAIL(Configuration timed out). Final State: " <<
      final_value.Get<std::string>();
    return false;
  }

  *failure_reason = "SUCCESS(Connection successful)";
  return true;
}

bool ProxyDbusShillWifiClient::DisconnectFromWifiNetwork(
    const std::string& ssid,
    long disconnect_timeout_milliseconds,
    long* disconnect_time_milliseconds,
    std::string* failure_reason) {
  *disconnect_time_milliseconds = -1;
  if (disconnect_timeout_milliseconds == 0) {
    disconnect_timeout_milliseconds = kServiceDisconnectTimeoutMilliseconds;
  }
  brillo::VariantDictionary service_params;
  service_params.insert(std::make_pair(
      shill::kTypeProperty, brillo::Any(std::string(shill::kTypeWifi))));
  service_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(ssid)));
  std::unique_ptr<ServiceProxy> service =
      dbus_client_->GetMatchingServiceProxy(service_params);
  if (!service) {
    *failure_reason = "FAIL(Service not found)";
    return false;
  }
  if (!service->Disconnect(nullptr)) {
    *failure_reason = "FAIL(Failed to call disconnect)";
    return false;
  }
  brillo::Any final_value;
  std::vector<brillo::Any> disconnect_states = {
    brillo::Any(std::string("idle")) };
  if (!dbus_client_->WaitForServiceProxyPropertyValueIn(
          service->GetObjectPath(), shill::kStateProperty, disconnect_states,
          disconnect_timeout_milliseconds, &final_value,
          disconnect_time_milliseconds)) {
    *failure_reason = "FAIL(Disconnection timed out)";
    return false;
  }

  *failure_reason = "SUCCESS(Disconnection successful)";
  return true;
}

bool ProxyDbusShillWifiClient::ConfigureBgScan(
    const std::string& interface_name,
    const std::string& method_name,
    uint16_t short_interval,
    uint16_t long_interval,
    int signal_threshold) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  bool is_success = true;
  if (method_name == kDefaultBgscanMethod) {
    is_success &= device->ClearProperty(shill::kBgscanMethodProperty, nullptr);
  } else {
    is_success &= device->SetProperty(
        shill::kBgscanMethodProperty,
        brillo::Any(method_name),
        nullptr);
  }
  is_success &= device->SetProperty(
      shill::kBgscanShortIntervalProperty,
      brillo::Any(short_interval),
      nullptr);
  is_success &= device->SetProperty(
      shill::kScanIntervalProperty,
      brillo::Any(long_interval),
      nullptr);
  is_success &= device->SetProperty(
      shill::kBgscanSignalThresholdProperty,
      brillo::Any(signal_threshold),
      nullptr);
  return is_success;
}

bool ProxyDbusShillWifiClient::GetActiveWifiSsids(
    std::vector<std::string>* ssids) {
  for (auto& service : dbus_client_->GetServiceProxies()) {
    brillo::Any service_type, signal_strength, ssid_hex;
    std::vector<uint8_t> ssid_bytes;
    brillo::VariantDictionary proxy_properties;
    brillo::ErrorPtr error;
    if (service->GetProperties(&proxy_properties, &error)) {
      service_type = proxy_properties[shill::kTypeProperty];
      signal_strength = proxy_properties[shill::kSignalStrengthProperty];
      ssid_hex = proxy_properties[shill::kWifiHexSsid];
      if ((service_type.TryGet<std::string>() == shill::kTypeWifi) &&
          (signal_strength.TryGet<uint8_t>() > 0) &&
          !ssid_hex.TryGet<std::string>().empty() &&
          base::HexStringToBytes(ssid_hex.Get<std::string>(), &ssid_bytes)) {
        ssids->emplace_back(std::string(ssid_bytes.begin(), ssid_bytes.end()));
      }
    } else {
      // Ignore unknown object path errors since we might be using some proxies
      // for objects which may have been destroyed since.
      CHECK(error->GetCode() == ProxyDbusClient::kDbusErrorObjectUnknown);
    }
  }
  return true;
}

bool ProxyDbusShillWifiClient::WaitForServiceStates(
    const std::string& ssid,
    const std::vector<std::string>& expected_states,
    long wait_timeout_milliseconds,
    std::string* final_state,
    long* wait_time_milliseconds) {
  *wait_time_milliseconds = -1;
  brillo::VariantDictionary service_params;
  service_params.insert(std::make_pair(
      shill::kTypeProperty, brillo::Any(std::string(shill::kTypeWifi))));
  service_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(ssid)));
  long discovery_time_milliseconds;
  auto service = dbus_client_->WaitForMatchingServiceProxy(
      service_params, shill::kTypeWifi, wait_timeout_milliseconds,
      kRescanIntervalMilliseconds, &discovery_time_milliseconds);
  if (!service) {
    *final_state = "unknown";
    return false;
  }
  brillo::Any final_value;
  std::vector<brillo::Any> expected_states_any;
  for (auto& state : expected_states) {
    expected_states_any.emplace_back(brillo::Any(state));
  }
  bool is_success =
      dbus_client_->WaitForServiceProxyPropertyValueIn(
          service->GetObjectPath(), shill::kStateProperty, expected_states_any,
          wait_timeout_milliseconds - discovery_time_milliseconds,
          &final_value, wait_time_milliseconds);
  *wait_time_milliseconds += discovery_time_milliseconds;
  *final_state = final_value.Get<std::string>();
  return is_success;
}

bool ProxyDbusShillWifiClient::CreateProfile(const std::string& profile_name) {
  return dbus_client_->CreateProfile(profile_name);
}

bool ProxyDbusShillWifiClient::PushProfile(const std::string& profile_name) {
  return dbus_client_->PushProfile(profile_name);
}

bool ProxyDbusShillWifiClient::PopProfile(const std::string& profile_name) {
  if (profile_name.empty()) {
    return dbus_client_->PopAnyProfile();
  } else {
    return dbus_client_->PopProfile(profile_name);
  }
}

bool ProxyDbusShillWifiClient::RemoveProfile(const std::string& profile_name) {
  return dbus_client_->RemoveProfile(profile_name);
}

bool ProxyDbusShillWifiClient::CleanProfiles() {
  while (true) {
    auto active_profile = dbus_client_->GetActiveProfileProxy();
    brillo::Any profile_name;
    if (!dbus_client_->GetPropertyValueFromProfileProxy(
            active_profile.get(), shill::kNameProperty, &profile_name)) {
      return false;
    }
    std::string profile_name_str = profile_name.Get<std::string>();
    if (profile_name_str == kDefaultProfileName) {
      return true;
    }
    dbus_client_->PopProfile(profile_name_str);
    dbus_client_->RemoveProfile(profile_name_str);
  }
  return false;
}

bool ProxyDbusShillWifiClient::DeleteEntriesForSsid(const std::string& ssid) {
  auto profiles = dbus_client_->GetProfileProxies();
  for (auto& profile : profiles) {
    brillo::Any property_value;
    if (!dbus_client_->GetPropertyValueFromProfileProxy(
            profile.get(), shill::kEntriesProperty, &property_value)) {
      continue;
    }
    auto entry_ids = property_value.Get<std::vector<std::string>>();
    for (const auto& entry_id : entry_ids) {
      brillo::VariantDictionary entry_props;
      if ((profile->GetEntry(entry_id, &entry_props, nullptr)) &&
          (entry_props[shill::kNameProperty].Get<std::string>() == ssid)) {
        profile->DeleteEntry(entry_id, nullptr);
      }
    }
  }
  return true;
}

bool ProxyDbusShillWifiClient::ListControlledWifiInterfaces(
    std::vector<std::string>* interface_names) {
  for (auto& device : dbus_client_->GetDeviceProxies()) {
    brillo::Any device_type;
    brillo::Any device_name;
    if (!dbus_client_->GetPropertyValueFromDeviceProxy(
            device.get(), shill::kTypeProperty, &device_type)) {
      return false;
    }
    if (device_type.Get<std::string>() == shill::kTypeWifi) {
      if (!dbus_client_->GetPropertyValueFromDeviceProxy(
              device.get(), shill::kNameProperty, &device_name)) {
        return false;
      }
      interface_names->emplace_back(device_name.Get<std::string>());
    }
  }
  return true;
}

bool ProxyDbusShillWifiClient::Disconnect(const std::string& ssid) {
  long disconnect_time_milliseconds;
  std::string failure_reason;
  return DisconnectFromWifiNetwork(
      ssid, 0, &disconnect_time_milliseconds, &failure_reason);
}

bool ProxyDbusShillWifiClient::GetServiceOrder(std::string* service_order) {
  return dbus_client_->GetServiceOrder(service_order);
}

bool ProxyDbusShillWifiClient::SetServiceOrder(const std::string& service_order) {
  return dbus_client_->SetServiceOrder(service_order);
}

bool ProxyDbusShillWifiClient::GetServiceProperties(
    const std::string& ssid,
    brillo::VariantDictionary* properties) {
  brillo::VariantDictionary service_params;
  service_params.insert(std::make_pair(
      shill::kTypeProperty, brillo::Any(std::string(shill::kTypeWifi))));
  service_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(ssid)));
  std::unique_ptr<ServiceProxy> service =
      dbus_client_->GetMatchingServiceProxy(service_params);
  if (!service) {
    return false;
  }
  CHECK(service->GetProperties(properties, nullptr));
  return true;
}

bool ProxyDbusShillWifiClient::SetSchedScan(bool enable) {
  return dbus_client_->SetSchedScan(enable);
}

bool ProxyDbusShillWifiClient::GetPropertyOnDevice(
    const std::string& interface_name,
    const std::string& property_name,
    brillo::Any* property_value) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return dbus_client_->GetPropertyValueFromDeviceProxy(
      device.get(), property_name, property_value);
}

bool ProxyDbusShillWifiClient::SetPropertyOnDevice(
    const std::string& interface_name,
    const std::string& property_name,
    const brillo::Any& property_value) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return device->SetProperty(
      property_name, property_value, nullptr);
}

bool ProxyDbusShillWifiClient::RequestRoam(
    const std::string& interface_name,
    const std::string& bssid) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return device->RequestRoam(bssid, nullptr);
}

bool ProxyDbusShillWifiClient::SetDeviceEnabled(
    const std::string& interface_name,
    bool enable) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  if (enable) {
    return device->Enable(nullptr);
  } else {
    return device->Disable(nullptr);
  }
}

bool ProxyDbusShillWifiClient::DiscoverTdlsLink(
    const std::string& interface_name,
    const std::string& peer_mac_address) {
  std::string out_params;
  return PerformTdlsOperation(
      interface_name, shill::kTDLSDiscoverOperation,
      peer_mac_address, &out_params);
}

bool ProxyDbusShillWifiClient::EstablishTdlsLink(
    const std::string& interface_name,
    const std::string& peer_mac_address) {
  std::string out_params;
  return PerformTdlsOperation(
      interface_name, shill::kTDLSSetupOperation,
      peer_mac_address, &out_params);
}

bool ProxyDbusShillWifiClient::QueryTdlsLink(
    const std::string& interface_name,
    const std::string& peer_mac_address,
    std::string* status) {
  return PerformTdlsOperation(
      interface_name, shill::kTDLSStatusOperation,
      peer_mac_address, status);
}

bool ProxyDbusShillWifiClient::AddWakePacketSource(
    const std::string& interface_name,
    const std::string& source_ip_address) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return device->AddWakeOnPacketConnection(source_ip_address, nullptr);
}

bool ProxyDbusShillWifiClient::RemoveWakePacketSource(
    const std::string& interface_name,
    const std::string& source_ip_address) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return device->RemoveWakeOnPacketConnection(source_ip_address, nullptr);
}

bool ProxyDbusShillWifiClient::RemoveAllWakePacketSources(
    const std::string& interface_name) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return device->RemoveAllWakeOnPacketConnections(nullptr);
}

void ProxyDbusShillWifiClient::SetAutoConnectInServiceParams(
    AutoConnectType autoconnect,
    brillo::VariantDictionary* service_params) {
  if (autoconnect != kAutoConnectTypeUnspecified) {
    service_params->insert(std::make_pair(
        shill::kAutoConnectProperty,
        brillo::Any(static_cast<bool>(autoconnect))));
  }
}

bool ProxyDbusShillWifiClient::PerformTdlsOperation(
    const std::string& interface_name,
    const std::string& operation,
    const std::string& peer_mac_address,
    std::string* out_params) {
  brillo::VariantDictionary device_params;
  device_params.insert(std::make_pair(
      shill::kNameProperty, brillo::Any(interface_name)));
  std::unique_ptr<DeviceProxy> device =
      dbus_client_->GetMatchingDeviceProxy(device_params);
  if (!device) {
    return false;
  }
  return device->PerformTDLSOperation(
      operation, peer_mac_address, out_params, nullptr);
}