/*
 * 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 "event_type.h"

#include <inttypes.h>
#include <unistd.h>
#include <algorithm>
#include <string>
#include <vector>

#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/parseint.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>

#include "ETMRecorder.h"
#include "environment.h"
#include "event_attr.h"
#include "utils.h"

namespace simpleperf {

struct EventFormat {
  EventFormat(const std::string& name, const std::string& attr, int shift)
      : name(name), attr(attr), shift(shift) {}

  std::string name;
  std::string attr;
  int shift;
};

extern std::set<EventType> builtin_event_types;

enum class EventFinderType {
  BUILTIN,
  TRACEPOINT_STRING,
  TRACEPOINT_SYSTEM,
  PMU,
  ETM,
  RAW,
  SCOPED,
};

class EventTypeFinder {
 public:
  EventTypeFinder(EventFinderType type) : finder_type_(type) {}
  virtual ~EventTypeFinder() {}

  EventFinderType GetFinderType() const { return finder_type_; }

  const std::set<EventType>& GetTypes() {
    if (!loaded_) {
      loaded_ = true;
      LoadTypes();
    }
    return types_;
  }

  virtual const EventType* FindType(const std::string& name) {
    const auto& types = GetTypes();
    auto it = types.find(EventType(name, 0, 0, "", ""));
    if (it != types.end()) {
      return &*it;
    }
    return nullptr;
  }

 protected:
  virtual void LoadTypes() = 0;

  const EventFinderType finder_type_;
  std::set<EventType> types_;
  bool loaded_ = false;
};

class BuiltinTypeFinder : public EventTypeFinder {
 public:
  BuiltinTypeFinder() : EventTypeFinder(EventFinderType::BUILTIN) {}

 protected:
  void LoadTypes() override { types_ = std::move(builtin_event_types); }
};

class TracepointStringFinder : public EventTypeFinder {
 public:
  TracepointStringFinder(std::string&& s)
      : EventTypeFinder(EventFinderType::TRACEPOINT_STRING), s_(std::move(s)) {}

 protected:
  void LoadTypes() override {
    for (const auto& line : android::base::Split(s_, "\n")) {
      std::string str = android::base::Trim(line);
      if (str.empty()) {
        continue;
      }
      std::vector<std::string> items = android::base::Split(str, " ");
      CHECK_EQ(items.size(), 2u);
      std::string event_name = items[0];
      uint64_t id;
      CHECK(android::base::ParseUint(items[1].c_str(), &id));
      types_.emplace(event_name, PERF_TYPE_TRACEPOINT, id, "", "");
    }
  }

 private:
  const std::string s_;
};

class TracepointSystemFinder : public EventTypeFinder {
 public:
  TracepointSystemFinder() : EventTypeFinder(EventFinderType::TRACEPOINT_SYSTEM) {}

  const EventType* FindType(const std::string& name) override {
    if (auto it = types_.find(EventType(name, 0, 0, "", "")); it != types_.end()) {
      return &*it;
    }
    std::vector<std::string> strs = android::base::Split(name, ":");
    if (strs.size() != 2) {
      return nullptr;
    }
    const char* tracefs_dir = GetTraceFsDir();
    if (tracefs_dir == nullptr) {
      return nullptr;
    }
    std::string path = tracefs_dir + std::string("/events/") + strs[0] + "/" + strs[1] + "/id";
    uint64_t id;
    if (!ReadEventId(path, &id)) {
      return nullptr;
    }
    auto res = types_.emplace(name, PERF_TYPE_TRACEPOINT, id, "", "");
    return &*res.first;
  }

  void RemoveType(const std::string& name) { types_.erase(EventType(name, 0, 0, "", "")); }

  std::string ToString() {
    std::string result;
    for (auto& type : GetTypes()) {
      if (!result.empty()) {
        result.push_back('\n');
      }
      result += android::base::StringPrintf("%s %" PRIu64, type.name.c_str(), type.config);
    }
    return result;
  }

 protected:
  void LoadTypes() override {
    const char* tracefs_dir = GetTraceFsDir();
    if (tracefs_dir == nullptr) {
      return;
    }
    const std::string tracepoint_dirname = tracefs_dir + std::string("/events");
    for (const auto& system_name : GetSubDirs(tracepoint_dirname)) {
      std::string system_path = tracepoint_dirname + "/" + system_name;
      for (const auto& event_name : GetSubDirs(system_path)) {
        std::string id_path = system_path + "/" + event_name + "/id";
        uint64_t id;
        if (ReadEventId(id_path, &id)) {
          types_.emplace(system_name + ":" + event_name, PERF_TYPE_TRACEPOINT, id, "", "");
        }
      }
    }
  }

 private:
  bool ReadEventId(const std::string& id_path, uint64_t* id) {
    std::string id_content;
    if (!android::base::ReadFileToString(id_path, &id_content)) {
      return false;
    }
    if (!android::base::ParseUint(android::base::Trim(id_content), id)) {
      LOG(DEBUG) << "unexpected id '" << id_content << "' in " << id_path;
      return false;
    }
    return true;
  }
};

class PMUTypeFinder : public EventTypeFinder {
 public:
  PMUTypeFinder() : EventTypeFinder(EventFinderType::PMU) {}

  const EventType* FindType(const std::string& name) override {
    if (name.find('/') == std::string::npos) {
      return nullptr;
    }
    return EventTypeFinder::FindType(name);
  }

 protected:
  void LoadTypes() override {
    const std::string evtsrc_dirname = "/sys/bus/event_source/devices/";
    for (const auto& device_name : GetSubDirs(evtsrc_dirname)) {
      std::string evtdev_path = evtsrc_dirname + device_name;
      std::string type_path = evtdev_path + "/type";
      std::string type_content;

      if (!android::base::ReadFileToString(type_path, &type_content)) {
        LOG(DEBUG) << "cannot read event type: " << device_name;
        continue;
      }
      uint64_t type_id = strtoull(type_content.c_str(), NULL, 10);

      std::vector<EventFormat> formats = ParseEventFormats(evtdev_path);

      std::string events_dirname = evtdev_path + "/events/";
      for (const auto& event_name : GetEntriesInDir(events_dirname)) {
        std::string event_path = events_dirname + event_name;
        std::string event_content;
        if (!android::base::ReadFileToString(event_path, &event_content)) {
          LOG(DEBUG) << "cannot read event content in " << event_name;
          continue;
        }

        uint64_t config = MakeEventConfig(event_content, formats);
        if (config == ~0ULL) {
          LOG(DEBUG) << "cannot handle config format in " << event_name;
          continue;
        }
        types_.emplace(device_name + "/" + event_name + "/", type_id, config, "", "");
      }
    }
  }

 private:
  std::vector<EventFormat> ParseEventFormats(const std::string& evtdev_path) {
    std::vector<EventFormat> v;
    std::string formats_dirname = evtdev_path + "/format/";
    for (const auto& format_name : GetEntriesInDir(formats_dirname)) {
      std::string format_path = formats_dirname + format_name;
      std::string format_content;
      if (!android::base::ReadFileToString(format_path, &format_content)) {
        continue;
      }

      // format files look like below (currently only 'config' is supported) :
      //   # cat armv8_pmuv3/format/event
      //   config:0-15
      int shift;
      if (sscanf(format_content.c_str(), "config:%d", &shift) != 1) {
        LOG(DEBUG) << "Invalid or unsupported event format: " << format_content;
        continue;
      }

      v.emplace_back(EventFormat(format_name, "config", shift));
    }
    return v;
  }

  uint64_t MakeEventConfig(const std::string& event_str, std::vector<EventFormat>& formats) {
    uint64_t config = 0;

    // event files might have multiple terms, but usually have a term like:
    //   # cat armv8_pmuv3/events/cpu_cycles
    //   event=0x011
    for (auto& s : android::base::Split(event_str, ",")) {
      auto pos = s.find('=');
      if (pos == std::string::npos) continue;

      auto format = s.substr(0, pos);
      long val;
      if (!android::base::ParseInt(android::base::Trim(s.substr(pos + 1)), &val)) {
        LOG(DEBUG) << "Invalid event format '" << s << "'";
        continue;
      }

      for (auto& f : formats) {
        if (f.name == format) {
          if (f.attr != "config") {
            LOG(DEBUG) << "cannot support other attribute: " << s;
            return ~0ULL;
          }

          config |= val << f.shift;
          break;
        }
      }
    }
    return config;
  }
};

class ETMTypeFinder : public EventTypeFinder {
 public:
  ETMTypeFinder() : EventTypeFinder(EventFinderType::ETM) {}

  const EventType* FindType(const std::string& name) override {
    if (name != kETMEventName) {
      return nullptr;
    }
    return EventTypeFinder::FindType(name);
  }

 protected:
  void LoadTypes() override {
#if defined(__linux__)
    std::unique_ptr<EventType> etm_type = ETMRecorder::GetInstance().BuildEventType();
    if (etm_type) {
      types_.emplace(std::move(*etm_type));
    }
#endif
  }
};

class RawTypeFinder : public EventTypeFinder {
 public:
  RawTypeFinder() : EventTypeFinder(EventFinderType::RAW) {}

  const EventType* AddType(EventType&& type) {
    auto result = types_.emplace(std::move(type));
    return &*(result.first);
  }

 protected:
  void LoadTypes() override {}
};

class ScopedTypeFinder : public EventTypeFinder {
 public:
  ScopedTypeFinder(std::set<EventType>&& types) : EventTypeFinder(EventFinderType::SCOPED) {
    types_ = std::move(types);
  }

 protected:
  void LoadTypes() override {}
};

EventTypeManager EventTypeManager::instance_;

EventTypeManager::EventTypeManager() {
  type_finders_.emplace_back(new BuiltinTypeFinder());
  type_finders_.emplace_back(new TracepointSystemFinder());
  type_finders_.emplace_back(new PMUTypeFinder());
  type_finders_.emplace_back(new ETMTypeFinder());
  type_finders_.emplace_back(new RawTypeFinder());
}

EventTypeManager::~EventTypeManager() {}

std::unique_ptr<EventTypeFinder>& EventTypeManager::GetFinder(EventFinderType type) {
  for (auto& finder : type_finders_) {
    if (finder->GetFinderType() == type) {
      return finder;
    }
  }
  LOG(FATAL) << "Failed to get EventTypeFinder";
  __builtin_unreachable();
}

RawTypeFinder& EventTypeManager::GetRawTypeFinder() {
  return *static_cast<RawTypeFinder*>(GetFinder(EventFinderType::RAW).get());
}

TracepointSystemFinder& EventTypeManager::GetTracepointSystemFinder() {
  return *static_cast<TracepointSystemFinder*>(GetFinder(EventFinderType::TRACEPOINT_SYSTEM).get());
}

bool EventTypeManager::ReadTracepointsFromFile(const std::string& filepath) {
  std::string data;
  if (!android::base::ReadFileToString(filepath, &data)) {
    PLOG(ERROR) << "Failed to read " << filepath;
    return false;
  }
  // Replace TracepointSystemFinder with TracepointStringFinder.
  auto& finder = GetFinder(EventFinderType::TRACEPOINT_SYSTEM);
  finder.reset(new TracepointStringFinder(std::move(data)));
  return true;
}

bool EventTypeManager::WriteTracepointsToFile(const std::string& filepath) {
  auto& tp_finder = GetTracepointSystemFinder();
  std::string s = tp_finder.ToString();
  if (!android::base::WriteStringToFile(s, filepath)) {
    PLOG(ERROR) << "Failed to store tracepoint events";
    return false;
  }
  return true;
}

bool EventTypeManager::ForEachType(const std::function<bool(const EventType&)>& callback) {
  if (scoped_finder_) {
    for (const auto& type : scoped_finder_->GetTypes()) {
      if (!callback(type)) {
        return false;
      }
    }
  } else {
    for (auto& finder : type_finders_) {
      for (const auto& type : finder->GetTypes()) {
        if (!callback(type)) {
          return false;
        }
      }
    }
  }
  return true;
}

const EventType* EventTypeManager::FindType(const std::string& name) {
  if (scoped_finder_) {
    return scoped_finder_->FindType(name);
  }
  for (auto& finder : type_finders_) {
    if (auto type = finder->FindType(name)) {
      return type;
    }
  }
  return nullptr;
}

const EventType* EventTypeManager::AddRawType(const std::string& name) {
  if (name.empty() || name[0] != 'r') {
    return nullptr;
  }
  errno = 0;
  char* end;
  uint64_t config = strtoull(&name[1], &end, 16);
  if (errno != 0 || *end != '\0') {
    return nullptr;
  }
  auto& raw_finder = GetRawTypeFinder();
  return raw_finder.AddType(EventType(name, PERF_TYPE_RAW, config, "", ""));
}

void EventTypeManager::RemoveProbeType(const std::string& name) {
  GetTracepointSystemFinder().RemoveType(name);
}

void EventTypeManager::SetScopedFinder(std::unique_ptr<EventTypeFinder>&& finder) {
  scoped_finder_ = std::move(finder);
}

std::vector<int> EventType::GetPmuCpumask() {
  std::vector<int> empty_result;
  if (!IsPmuEvent()) return empty_result;

  std::string pmu = name.substr(0, name.find('/'));
  std::string cpumask_path = "/sys/bus/event_source/devices/" + pmu + "/cpumask";
  std::string cpumask_content;
  if (!android::base::ReadFileToString(cpumask_path, &cpumask_content)) {
    LOG(DEBUG) << "cannot read cpumask content in " << pmu;
    return empty_result;
  }
  if (auto cpus = GetCpusFromString(cpumask_content); cpus) {
    return std::vector<int>(cpus->begin(), cpus->end());
  }
  return empty_result;
}

std::string ScopedEventTypes::BuildString(const std::vector<const EventType*>& event_types) {
  std::string result;
  for (auto type : event_types) {
    if (!result.empty()) {
      result.push_back('\n');
    }
    result +=
        android::base::StringPrintf("%s,%u,%" PRIu64, type->name.c_str(), type->type, type->config);
  }
  return result;
}

ScopedEventTypes::ScopedEventTypes(const std::string& event_type_str) {
  std::set<EventType> event_types;
  for (auto& s : android::base::Split(event_type_str, "\n")) {
    std::string name = s.substr(0, s.find(','));
    uint32_t type;
    uint64_t config;
    sscanf(s.c_str() + name.size(), ",%u,%" PRIu64, &type, &config);
    event_types.emplace(name, type, config, "", "");
  }
  CHECK(EventTypeManager::Instance().GetScopedFinder() == nullptr);
  EventTypeManager::Instance().SetScopedFinder(
      std::make_unique<ScopedTypeFinder>(std::move(event_types)));
}

ScopedEventTypes::~ScopedEventTypes() {
  CHECK(EventTypeManager::Instance().GetScopedFinder() != nullptr);
  EventTypeManager::Instance().SetScopedFinder(nullptr);
}

const EventType* FindEventTypeByName(const std::string& name, bool report_error) {
  const EventType* event_type = EventTypeManager::Instance().FindType(name);
  if (event_type != nullptr) {
    return event_type;
  }
  event_type = EventTypeManager::Instance().AddRawType(name);
  if (event_type != nullptr) {
    return event_type;
  }
  if (report_error) {
    LOG(ERROR) << "Unknown event_type '" << name
               << "', try `simpleperf list` to list all possible event type names";
  }
  return nullptr;
}

std::unique_ptr<EventTypeAndModifier> ParseEventType(const std::string& event_type_str) {
  static std::string modifier_characters = "ukhGHp";
  std::unique_ptr<EventTypeAndModifier> event_type_modifier(new EventTypeAndModifier);
  event_type_modifier->name = event_type_str;
  std::string event_type_name = event_type_str;
  std::string modifier;
  size_t comm_pos = event_type_str.rfind(':');
  if (comm_pos != std::string::npos) {
    bool match_modifier = true;
    for (size_t i = comm_pos + 1; i < event_type_str.size(); ++i) {
      char c = event_type_str[i];
      if (c != ' ' && modifier_characters.find(c) == std::string::npos) {
        match_modifier = false;
        break;
      }
    }
    if (match_modifier) {
      event_type_name = event_type_str.substr(0, comm_pos);
      modifier = event_type_str.substr(comm_pos + 1);
    }
  }
  const EventType* event_type = FindEventTypeByName(event_type_name);
  if (event_type == nullptr) {
    // Try if the modifier belongs to the event type name, like some tracepoint events.
    if (!modifier.empty()) {
      event_type_name = event_type_str;
      modifier.clear();
      event_type = FindEventTypeByName(event_type_name);
    }
    if (event_type == nullptr) {
      return nullptr;
    }
  }
  event_type_modifier->event_type = *event_type;
  if (modifier.find_first_of("ukh") != std::string::npos) {
    event_type_modifier->exclude_user = true;
    event_type_modifier->exclude_kernel = true;
    event_type_modifier->exclude_hv = true;
  }
  if (modifier.find_first_of("GH") != std::string::npos) {
    event_type_modifier->exclude_guest = true;
    event_type_modifier->exclude_host = true;
  }

  for (auto& c : modifier) {
    switch (c) {
      case 'u':
        event_type_modifier->exclude_user = false;
        break;
      case 'k':
        event_type_modifier->exclude_kernel = false;
        break;
      case 'h':
        event_type_modifier->exclude_hv = false;
        break;
      case 'G':
        event_type_modifier->exclude_guest = false;
        break;
      case 'H':
        event_type_modifier->exclude_host = false;
        break;
      case 'p':
        event_type_modifier->precise_ip++;
        break;
      case ' ':
        break;
      default:
        LOG(ERROR) << "Unknown event type modifier '" << c << "'";
    }
  }
  event_type_modifier->modifier = modifier;
  return event_type_modifier;
}

bool IsEtmEventType(uint32_t type) {
  const EventType* event_type = EventTypeManager::Instance().FindType(kETMEventName);
  return (event_type != nullptr) && (event_type->type == type);
}

}  // namespace simpleperf