// Copyright 2019 The Chromium OS 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 "diagnostics/cros_health_tool/telem/telem.h"

#include <sys/types.h>

#include <cstdlib>
#include <iostream>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include <base/at_exit.h>
#include <base/logging.h>
#include <base/optional.h>
#include <base/strings/stringprintf.h>
#include <base/strings/string_split.h>
#include <base/strings/string_util.h>
#include <base/task/single_thread_task_executor.h>
#include <brillo/flag_helper.h>
#include <brillo/syslog_logging.h>

#include "diagnostics/cros_healthd_mojo_adapter/cros_healthd_mojo_adapter.h"
#include "mojo/cros_healthd_probe.mojom.h"
#include "mojo/network_health.mojom.h"
#include "mojo/network_types.mojom.h"

namespace diagnostics {

namespace {

using chromeos::cros_healthd::mojom::CpuArchitectureEnum;
using chromeos::network_config::mojom::NetworkType;
using chromeos::network_health::mojom::NetworkState;

// Value printed for optional fields when they aren't populated.
constexpr char kNotApplicableString[] = "N/A";

constexpr std::pair<const char*,
                    chromeos::cros_healthd::mojom::ProbeCategoryEnum>
    kCategorySwitches[] = {
        {"battery", chromeos::cros_healthd::mojom::ProbeCategoryEnum::kBattery},
        {"storage", chromeos::cros_healthd::mojom::ProbeCategoryEnum::
                        kNonRemovableBlockDevices},
        {"cpu", chromeos::cros_healthd::mojom::ProbeCategoryEnum::kCpu},
        {"timezone",
         chromeos::cros_healthd::mojom::ProbeCategoryEnum::kTimezone},
        {"memory", chromeos::cros_healthd::mojom::ProbeCategoryEnum::kMemory},
        {"backlight",
         chromeos::cros_healthd::mojom::ProbeCategoryEnum::kBacklight},
        {"fan", chromeos::cros_healthd::mojom::ProbeCategoryEnum::kFan},
        {"stateful_partition",
         chromeos::cros_healthd::mojom::ProbeCategoryEnum::kStatefulPartition},
        {"bluetooth",
         chromeos::cros_healthd::mojom::ProbeCategoryEnum::kBluetooth},
        {"system", chromeos::cros_healthd::mojom::ProbeCategoryEnum::kSystem},
        {"network", chromeos::cros_healthd::mojom::ProbeCategoryEnum::kNetwork},
};

std::string ProcessStateToString(
    chromeos::cros_healthd::mojom::ProcessState state) {
  switch (state) {
    case chromeos::cros_healthd::mojom::ProcessState::kRunning:
      return "Running";
    case chromeos::cros_healthd::mojom::ProcessState::kSleeping:
      return "Sleeping";
    case chromeos::cros_healthd::mojom::ProcessState::kWaiting:
      return "Waiting";
    case chromeos::cros_healthd::mojom::ProcessState::kZombie:
      return "Zombie";
    case chromeos::cros_healthd::mojom::ProcessState::kStopped:
      return "Stopped";
    case chromeos::cros_healthd::mojom::ProcessState::kTracingStop:
      return "Tracing Stop";
    case chromeos::cros_healthd::mojom::ProcessState::kDead:
      return "Dead";
  }
}

std::string ErrorTypeToString(chromeos::cros_healthd::mojom::ErrorType type) {
  switch (type) {
    case chromeos::cros_healthd::mojom::ErrorType::kFileReadError:
      return "File Read Error";
    case chromeos::cros_healthd::mojom::ErrorType::kParseError:
      return "Parse Error";
    case chromeos::cros_healthd::mojom::ErrorType::kSystemUtilityError:
      return "Error running system utility";
    case chromeos::cros_healthd::mojom::ErrorType::kServiceUnavailable:
      return "External service not aviailable";
  }
}

void DisplayError(const chromeos::cros_healthd::mojom::ProbeErrorPtr& error) {
  std::cout << ErrorTypeToString(error->type) << ": " << error->msg
            << std::endl;
}

std::string GetArchitectureString(CpuArchitectureEnum architecture) {
  switch (architecture) {
    case CpuArchitectureEnum::kUnknown:
      return "unknown";
    case CpuArchitectureEnum::kX86_64:
      return "x86_64";
    case CpuArchitectureEnum::kAArch64:
      return "aarch64";
    case CpuArchitectureEnum::kArmv7l:
      return "armv7l";
  }
}

std::string NetworkTypeToString(NetworkType type) {
  switch (type) {
    case NetworkType::kAll:
      return "Unknown";
    case NetworkType::kCellular:
      return "Cellular";
    case NetworkType::kEthernet:
      return "Ethernet";
    case NetworkType::kMobile:
      return "Mobile";
    case NetworkType::kTether:
      return "Tether";
    case NetworkType::kVPN:
      return "VPN";
    case NetworkType::kWireless:
      return "Wireless";
    case NetworkType::kWiFi:
      return "WiFi";
  }
}

std::string NetworkStateToString(NetworkState state) {
  switch (state) {
    case NetworkState::kUninitialized:
      return "Uninitialized";
    case NetworkState::kDisabled:
      return "Disabled";
    case NetworkState::kProhibited:
      return "Prohibited";
    case NetworkState::kNotConnected:
      return "Not Connected";
    case NetworkState::kConnecting:
      return "Connecting";
    case NetworkState::kPortal:
      return "Portal";
    case NetworkState::kConnected:
      return "Connected";
    case NetworkState::kOnline:
      return "Online";
  }
}

void DisplayProcessInfo(
    const chromeos::cros_healthd::mojom::ProcessResultPtr& process_result) {
  if (process_result.is_null())
    return;

  if (process_result->is_error()) {
    DisplayError(process_result->get_error());
    return;
  }

  const auto& process = process_result->get_process_info();

  std::cout << "command,user_id,priority,nice,uptime_ticks,state,total_memory_"
               "kib,resident_memory_kib,free_memory_kib"
            << std::endl;

  // The int8_t fields need to be cast to a larger int type, otherwise they will
  // be treated as chars and display garbage. Also, wrap the command in quotes,
  // because the command-line options included in the command sometimes have
  // their own commas.
  std::cout << "\"" << process->command << "\"," << process->user_id << ","
            << static_cast<int>(process->priority) << ","
            << static_cast<int>(process->nice) << "," << process->uptime_ticks
            << "," << ProcessStateToString(process->state) << ","
            << process->total_memory_kib << "," << process->resident_memory_kib
            << "," << process->free_memory_kib << std::endl;
}

void DisplayBatteryInfo(
    const chromeos::cros_healthd::mojom::BatteryResultPtr& battery_result) {
  if (battery_result->is_error()) {
    DisplayError(battery_result->get_error());
    return;
  }

  const auto& battery = battery_result->get_battery_info();
  if (battery.is_null()) {
    std::cout << "Device does not have battery" << std::endl;
    return;
  }

  std::cout << "charge_full,charge_full_design,cycle_count,serial_number,"
               "vendor(manufacturer),voltage_now,voltage_min_design,"
               "manufacture_date_smart,temperature_smart,model_name,charge_now,"
               "current_now,technology,status"
            << std::endl;

  std::string manufacture_date_smart =
      battery->manufacture_date.value_or(kNotApplicableString);
  std::string temperature_smart =
      !battery->temperature.is_null()
          ? std::to_string(battery->temperature->value)
          : kNotApplicableString;

  std::cout << battery->charge_full << "," << battery->charge_full_design << ","
            << battery->cycle_count << "," << battery->serial_number << ","
            << battery->vendor << "," << battery->voltage_now << ","
            << battery->voltage_min_design << "," << manufacture_date_smart
            << "," << temperature_smart << "," << battery->model_name << ","
            << battery->charge_now << "," << battery->current_now << ","
            << battery->technology << "," << battery->status << std::endl;
}

void DisplayBlockDeviceInfo(
    const chromeos::cros_healthd::mojom::NonRemovableBlockDeviceResultPtr&
        block_device_result) {
  if (block_device_result->is_error()) {
    DisplayError(block_device_result->get_error());
    return;
  }

  const auto& block_devices = block_device_result->get_block_device_info();
  std::cout << "path,size,type,manfid,name,serial,bytes_read_since_last_boot,"
               "bytes_written_since_last_boot,read_time_seconds_since_last_"
               "boot,write_time_seconds_since_last_boot,io_time_seconds_since_"
               "last_boot,discard_time_seconds_since_last_boot"
            << std::endl;
  for (const auto& device : block_devices) {
    std::string discard_time =
        !device->discard_time_seconds_since_last_boot.is_null()
            ? std::to_string(
                  device->discard_time_seconds_since_last_boot->value)
            : kNotApplicableString;
    std::cout << device->path << "," << device->size << "," << device->type
              << "," << device->manufacturer_id << "," << device->name << ","
              << device->serial << "," << device->bytes_read_since_last_boot
              << "," << device->bytes_written_since_last_boot << ","
              << device->read_time_seconds_since_last_boot << ","
              << device->write_time_seconds_since_last_boot << ","
              << device->io_time_seconds_since_last_boot << "," << discard_time
              << std::endl;
  }
}

void DisplayBluetoothInfo(
    const chromeos::cros_healthd::mojom::BluetoothResultPtr& bluetooth_result) {
  if (bluetooth_result->is_error()) {
    DisplayError(bluetooth_result->get_error());
    return;
  }

  const auto& adapters = bluetooth_result->get_bluetooth_adapter_info();
  std::cout << "name,address,powered,num_connected_devices" << std::endl;
  for (const auto& adapter : adapters) {
    std::cout << adapter->name << "," << adapter->address << ","
              << (adapter->powered ? "true" : "false") << ","
              << adapter->num_connected_devices << std::endl;
  }
}

void DisplayCpuInfo(
    const chromeos::cros_healthd::mojom::CpuResultPtr& cpu_result) {
  if (cpu_result->is_error()) {
    DisplayError(cpu_result->get_error());
    return;
  }

  // An example CpuInfo output containing a single physical CPU, which in turn
  // contains two logical CPUs, would look like the following:
  //
  // num_total_threads,architecture
  // some_uint32,some_string
  // Physical CPU:
  //     model_name
  //     some_string
  //     Logical CPU:
  //         max_clock_speed_khz,scaling_max_frequency_khz,... (six keys total)
  //         some_uint32,... (six values total)
  //         C-states:
  //             name,time_in_state_since_last_boot_us
  //             some_string,some_uint_64
  //             ... (repeated per C-state)
  //             some_string,some_uint_64
  //     Logical CPU:
  //         max_clock_speed_khz,scaling_max_frequency_khz,... (six keys total)
  //         some_uint32,... (six values total)
  //         C-states:
  //             name,time_in_state_since_last_boot_us
  //             some_string,some_uint_64
  //             ... (repeated per C-state)
  //             some_string,some_uint_64
  // Temperature Channels:
  // label, temperature_celsius
  // some_label, some_int32_t
  // some_other_label, some_other_int32_t
  //
  // Any additional physical CPUs would repeat, similarly to the two logical
  // CPUs in the example.
  const auto& cpu_info = cpu_result->get_cpu_info();
  std::cout << "num_total_threads,architecture" << std::endl;
  std::cout << cpu_info->num_total_threads << ","
            << GetArchitectureString(cpu_info->architecture) << std::endl;
  for (const auto& physical_cpu : cpu_info->physical_cpus) {
    std::cout << "Physical CPU:" << std::endl;
    std::cout << "\tmodel_name" << std::endl;
    // Remove commas from the model name before printing CSVs.
    std::string csv_model_name;
    base::RemoveChars(physical_cpu->model_name.value_or(kNotApplicableString),
                      ",", &csv_model_name);
    std::cout << "\t" << csv_model_name << std::endl;

    for (const auto& logical_cpu : physical_cpu->logical_cpus) {
      std::cout << "\tLogical CPU:" << std::endl;
      std::cout << "\t\tmax_clock_speed_khz,scaling_max_frequency_khz,scaling_"
                   "current_frequency_khz,user_time_user_hz,system_time_user_"
                   "hz,idle_time_user_hz"
                << std::endl;
      std::cout << "\t\t" << logical_cpu->max_clock_speed_khz << ","
                << logical_cpu->scaling_max_frequency_khz << ","
                << logical_cpu->scaling_current_frequency_khz << ","
                << logical_cpu->user_time_user_hz << ","
                << logical_cpu->system_time_user_hz << ","
                << logical_cpu->idle_time_user_hz << std::endl;

      std::cout << "\t\tC-states:" << std::endl;
      std::cout << "\t\t\tname,time_in_state_since_last_boot_us" << std::endl;
      for (const auto& c_state : logical_cpu->c_states) {
        std::cout << "\t\t\t" << c_state->name << ","
                  << c_state->time_in_state_since_last_boot_us << std::endl;
      }
    }
  }
  std::cout << "Temperature Channels:" << std::endl;
  std::cout << "label,temperature_celsius" << std::endl;
  for (const auto& channel : cpu_info->temperature_channels) {
    std::cout << channel->label.value_or(kNotApplicableString) << ","
              << channel->temperature_celsius << std::endl;
  }
}

void DisplayFanInfo(
    const chromeos::cros_healthd::mojom::FanResultPtr& fan_result) {
  if (fan_result->is_error()) {
    DisplayError(fan_result->get_error());
    return;
  }

  const auto& fans = fan_result->get_fan_info();
  std::cout << "speed_rpm" << std::endl;
  for (const auto& fan : fans) {
    std::cout << fan->speed_rpm << std::endl;
  }
}

void DisplayNetworkInfo(
    const chromeos::cros_healthd::mojom::NetworkResultPtr& network_result) {
  if (network_result->is_error()) {
    DisplayError(network_result->get_error());
    return;
  }

  const auto& network_health = network_result->get_network_health();
  std::cout << "type,state,guid,name,signal_strength,mac_address" << std::endl;
  for (const auto& network : network_health->networks) {
    auto signal_strength = network->signal_strength
                               ? std::to_string(network->signal_strength->value)
                               : kNotApplicableString;
    std::cout << NetworkTypeToString(network->type) << ","
              << NetworkStateToString(network->state) << ","
              << network->guid.value_or(kNotApplicableString) << ","
              << network->name.value_or(kNotApplicableString) << ","
              << signal_strength << ","
              << network->mac_address.value_or(kNotApplicableString)
              << std::endl;
  }
}

void DisplayTimezoneInfo(
    const chromeos::cros_healthd::mojom::TimezoneResultPtr& timezone_result) {
  if (timezone_result->is_error()) {
    DisplayError(timezone_result->get_error());
    return;
  }

  const auto& timezone = timezone_result->get_timezone_info();
  // Replace commas in POSIX timezone before printing CSVs.
  std::string csv_posix_timezone;
  base::ReplaceChars(timezone->posix, ",", " ", &csv_posix_timezone);
  std::cout << "posix_timezone,timezone_region" << std::endl;
  std::cout << csv_posix_timezone << "," << timezone->region << std::endl;
}

void DisplayMemoryInfo(
    const chromeos::cros_healthd::mojom::MemoryResultPtr& memory_result) {
  if (memory_result->is_error()) {
    DisplayError(memory_result->get_error());
    return;
  }

  const auto& memory = memory_result->get_memory_info();
  std::cout << "total_memory_kib,free_memory_kib,available_memory_kib,"
               "page_faults_since_last_boot"
            << std::endl;
  std::cout << memory->total_memory_kib << "," << memory->free_memory_kib << ","
            << memory->available_memory_kib << ","
            << memory->page_faults_since_last_boot << std::endl;
}

void DisplayBacklightInfo(
    const chromeos::cros_healthd::mojom::BacklightResultPtr& backlight_result) {
  if (backlight_result->is_error()) {
    DisplayError(backlight_result->get_error());
    return;
  }

  const auto& backlights = backlight_result->get_backlight_info();
  std::cout << "path,max_brightness,brightness" << std::endl;
  for (const auto& backlight : backlights) {
    std::cout << backlight->path.c_str() << "," << backlight->max_brightness
              << "," << backlight->brightness << std::endl;
  }
}

void DisplayStatefulPartitionInfo(
    const chromeos::cros_healthd::mojom::StatefulPartitionResultPtr&
        stateful_partition_result) {
  if (stateful_partition_result->is_error()) {
    DisplayError(stateful_partition_result->get_error());
    return;
  }

  const auto& stateful_partition_info =
      stateful_partition_result->get_partition_info();
  std::cout << "available_space,total_space" << std::endl;
  std::cout << stateful_partition_info->available_space << ","
            << stateful_partition_info->total_space << std::endl;
}

void DisplaySystemInfo(
    const chromeos::cros_healthd::mojom::SystemResultPtr& system_result) {
  if (system_result->is_error()) {
    DisplayError(system_result->get_error());
    return;
  }

  const auto& system_info = system_result->get_system_info();
  std::cout << "first_power_date,manufacture_date,product_sku_number,"
            << "product_serial_number,marketing_name,bios_version,board_name,"
            << "board_version,chassis_type,product_name,os_version,os_channel"
            << std::endl;
  std::string chassis_type =
      !system_info->chassis_type.is_null()
          ? std::to_string(system_info->chassis_type->value)
          : kNotApplicableString;
  std::string os_version =
      base::JoinString({system_info->os_version->release_milestone,
                        system_info->os_version->build_number,
                        system_info->os_version->patch_number},
                       ".");

  // The marketing name sometimes has a comma, for example:
  // "Acer Chromebook Spin 11 (CP311-H1, CP311-1HN)"
  // This messes up the tast logic, which splits on commas. To fix it, we
  // replace any ", " patterns found with "/".
  std::string marketing_name = system_info->marketing_name;
  base::ReplaceSubstringsAfterOffset(&marketing_name, 0, ", ", "/");

  std::cout << system_info->first_power_date.value_or(kNotApplicableString)
            << ","
            << system_info->manufacture_date.value_or(kNotApplicableString)
            << ","
            << system_info->product_sku_number.value_or(kNotApplicableString)
            << ","
            << system_info->product_serial_number.value_or(kNotApplicableString)
            << "," << marketing_name << ","
            << system_info->bios_version.value_or(kNotApplicableString) << ","
            << system_info->board_name.value_or(kNotApplicableString) << ","
            << system_info->board_version.value_or(kNotApplicableString) << ","
            << chassis_type << ","
            << system_info->product_name.value_or(kNotApplicableString) << ","
            << os_version << ',' << system_info->os_version->release_channel
            << std::endl;
}

// Displays the retrieved telemetry information to the console.
void DisplayTelemetryInfo(
    const chromeos::cros_healthd::mojom::TelemetryInfoPtr& info) {
  const auto& battery_result = info->battery_result;
  if (battery_result)
    DisplayBatteryInfo(battery_result);

  const auto& block_device_result = info->block_device_result;
  if (block_device_result)
    DisplayBlockDeviceInfo(block_device_result);

  const auto& cpu_result = info->cpu_result;
  if (cpu_result)
    DisplayCpuInfo(cpu_result);

  const auto& timezone_result = info->timezone_result;
  if (timezone_result)
    DisplayTimezoneInfo(timezone_result);

  const auto& memory_result = info->memory_result;
  if (memory_result)
    DisplayMemoryInfo(memory_result);

  const auto& backlight_result = info->backlight_result;
  if (backlight_result)
    DisplayBacklightInfo(backlight_result);

  const auto& fan_result = info->fan_result;
  if (fan_result)
    DisplayFanInfo(fan_result);

  const auto& stateful_partition_result = info->stateful_partition_result;
  if (stateful_partition_result)
    DisplayStatefulPartitionInfo(stateful_partition_result);

  const auto& bluetooth_result = info->bluetooth_result;
  if (bluetooth_result)
    DisplayBluetoothInfo(bluetooth_result);

  const auto& system_result = info->system_result;
  if (system_result)
    DisplaySystemInfo(system_result);

  const auto& network_result = info->network_result;
  if (network_result)
    DisplayNetworkInfo(network_result);
}

// Create a stringified list of the category names for use in help.
std::string GetCategoryHelp() {
  std::stringstream ss;
  ss << "Category or categories to probe, as comma-separated list: [";
  const char* sep = "";
  for (auto pair : kCategorySwitches) {
    ss << sep << pair.first;
    sep = ", ";
  }
  ss << "]";
  return ss.str();
}

}  // namespace

// 'telem' sub-command for cros-health-tool:
//
// Test driver for cros_healthd's telemetry collection. Supports requesting a
// comma-separate list of categories and/or a single process at a time.
int telem_main(int argc, char** argv) {
  std::string category_help = GetCategoryHelp();
  DEFINE_string(category, "", category_help.c_str());
  DEFINE_uint32(process, 0, "Process ID to probe.");
  brillo::FlagHelper::Init(argc, argv, "telem - Device telemetry tool.");
  brillo::InitLog(brillo::kLogToSyslog | brillo::kLogToStderrIfTty);

  base::AtExitManager at_exit_manager;

  std::map<std::string, chromeos::cros_healthd::mojom::ProbeCategoryEnum>
      switch_to_category(std::begin(kCategorySwitches),
                         std::end(kCategorySwitches));

  logging::InitLogging(logging::LoggingSettings());

  base::SingleThreadTaskExecutor task_executor(base::MessagePumpType::IO);

  std::unique_ptr<CrosHealthdMojoAdapter> adapter =
      CrosHealthdMojoAdapter::Create();

  // Make sure at least one flag is specified.
  if (FLAGS_category == "" && FLAGS_process == 0) {
    LOG(ERROR) << "No category or process specified.";
    return EXIT_FAILURE;
  }

  // Probe a process, if requested.
  if (FLAGS_process != 0) {
    DisplayProcessInfo(
        adapter->GetProcessInfo(static_cast<pid_t>(FLAGS_process)));
  }

  // Probe category info, if requested.
  if (FLAGS_category != "") {
    // Validate the category flag.
    std::vector<chromeos::cros_healthd::mojom::ProbeCategoryEnum>
        categories_to_probe;
    std::vector<std::string> input_categories = base::SplitString(
        FLAGS_category, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
    for (const auto& category : input_categories) {
      auto iterator = switch_to_category.find(category);
      if (iterator == switch_to_category.end()) {
        LOG(ERROR) << "Invalid category: " << category;
        return EXIT_FAILURE;
      }
      categories_to_probe.push_back(iterator->second);
    }

    // Probe and display the category or categories.
    DisplayTelemetryInfo(adapter->GetTelemetryInfo(categories_to_probe));
  }

  return EXIT_SUCCESS;
}

}  // namespace diagnostics