dynv.cpp

#include <android/log.h>
#include <sys/stat.h>
#include <unistd.h>
#include <yaml-cpp/yaml.h>

#include <algorithm>
#include <atomic>
#include <chrono>
#include <cmath>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <mutex>
#include <numeric>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
#include <thread>
#include <unordered_set>
#include <utility>
#include <vector>

#define SWAP_PROC_FILE "/proc/swaps"
#define ZRAM_DIR "/dev/block"
#define SWAP_DIR "/data/adb"

using namespace std;
using namespace chrono;
namespace fs = filesystem;

extern void save_pid(const string &filename, pid_t pid);
extern void dyn_swap_service();
extern void fmiop();

atomic<bool> running(true);
atomic<bool> is_swapoff_session{false};
atomic<bool> sleeper_alive(false);
vector<string> swapoff_tracker, active_swaps;
mutex safe_thread_mutex;
pair<vector<string>, vector<string>> available_swaps;
const string fmiop_dir = "/sdcard/Android/fmiop";
const string NVBASE = "/data/adb";
const string LOG_FOLDER = NVBASE + "/fmiop";
const string PIDS_DB = LOG_FOLDER + "/fmiop" + ".pids";
const string SWAP_FILE_PREFIX = "fmiop_swap.";
const string DEFAULT_CONFIG = "/data/adb/fmiop/config.yaml";

enum class LogType { ALWAYS, QUIET, ONCE };
enum class LogPriority {
  DEBUG = ANDROID_LOG_DEBUG,
  INFO = ANDROID_LOG_INFO,
  WARNING = ANDROID_LOG_WARN,
  ERROR = ANDROID_LOG_ERROR
};
#define LOG_TAG "fmiop"

/**
 * Converts any type to string using stringstream.
 */
template <typename T>
string to_string_generic(const T &val) {
  ostringstream oss;
  oss << boolalpha << val;  // handle bool as "true"/"false"
  return oss.str();
}

class LogManager {
 public:
  /**
   * @brief Logs a message with the specified type, priority, and format.
   *
   * This templated function logs messages using Android's logging system. It
   * supports different log types, including normal, quiet (no logging), and
   * once (logs only once per key). If the log type is QUIET, the function
   * returns immediately without logging. If the log type is ONCE and the
   * message with the given key has already been logged, it will not log again.
   * Otherwise, it logs the formatted message with the provided arguments.
   *
   * @tparam Args Variadic template parameters for formatting the log message.
   * @param type The type of log (e.g., normal, quiet, once).
   * @param level The priority level of the log message.
   * @param key A unique key to identify the log message (used for ONCE type).
   * @param format The format string for the log message (printf-style).
   * @param args Arguments to be formatted into the log message.
   */
  template <typename... Args>
  void log(LogType type, LogPriority level, const string &key,
           const char *format, Args... args) {
    if (type == LogType::QUIET) return;

    if (type == LogType::ONCE && once_logged.find(key) != once_logged.end()) {
      return;
    }

    __android_log_print(static_cast<int>(level), LOG_TAG, format, args...);

    if (type == LogType::ONCE) {
      once_logged.insert(key);
    }
  }

  // Overloaded function with default parameters
  template <typename... Args>
  void log(const string &key, const char *format, Args... args) {
    log(key, LogType::ALWAYS, LogPriority::INFO, format, args...);
  }

  void reset(const string &key) { once_logged.erase(key); }

  void reset_all() { once_logged.clear(); }

 private:
  unordered_set<string> once_logged;
};

static LogManager log_manager;

#define ALOGD(format, ...)                                         \
  log_manager.log(LogType::ALWAYS, LogPriority::DEBUG, "", format, \
                  ##__VA_ARGS__)

#define ALOGI(format, ...) \
  log_manager.log(LogType::ALWAYS, LogPriority::INFO, "", format, ##__VA_ARGS__)

#define ALOGW(format, ...)                                           \
  log_manager.log(LogType::ALWAYS, LogPriority::WARNING, "", format, \
                  ##__VA_ARGS__)

#define ALOGE(format, ...)                                         \
  log_manager.log(LogType::ALWAYS, LogPriority::ERROR, "", format, \
                  ##__VA_ARGS__)

#define ALOGD_ONCE(key, format, ...) \
  log_manager.log(LogType::ONCE, LogPriority::DEBUG, key, format, ##__VA_ARGS__)

#define ALOGI_ONCE(key, format, ...) \
  log_manager.log(LogType::ONCE, LogPriority::INFO, key, format, ##__VA_ARGS__)

#define ALOGW_ONCE(key, format, ...)                                \
  log_manager.log(LogType::ONCE, LogPriority::WARNING, key, format, \
                  ##__VA_ARGS__)

#define ALOGE_ONCE(key, format, ...) \
  log_manager.log(LogType::ONCE, LogPriority::ERROR, key, format, ##__VA_ARGS__)

#define ALOG_RESET(key) log_manager.reset(key)

/**
 * Reads a value from a YAML config file with a default fallback.
 */
template <typename T>
T read_config(const string &key_path, T default_value) {
  try {
    YAML::Node node = YAML::LoadFile(DEFAULT_CONFIG);
    size_t pos = 0, found;
    string clean_key_path =
        (key_path[0] == '.') ? key_path.substr(1) : key_path;

    while ((found = clean_key_path.find('.', pos)) != string::npos) {
      string key = clean_key_path.substr(pos, found - pos);
      node = node[key];

      if (!node) {
        ALOGW("Config key not found: %s. Using default: %s", key_path.c_str(),
              to_string_generic(default_value).c_str());
        return default_value;
      }
      pos = found + 1;
    }

    string finalKey = clean_key_path.substr(pos);
    node = node[finalKey];

    if (!node) {
      ALOGW("Config key not found: %s. Using default: %s", key_path.c_str(),
            to_string_generic(default_value).c_str());
      return default_value;
    }

    T value = node.as<T>();
    ALOGI("Config [%s] = %s", key_path.c_str(),
          to_string_generic(value).c_str());
    return value;
  } catch (const exception &e) {
    ALOGE("Error reading config: %s", e.what());
    return default_value;
  }
}

vector<pair<int, int>> parse_pressure_pairs(const YAML::Node &node) {
  vector<pair<int, int>> result;
  if (!node || !node.IsSequence()) return result;

  for (const auto &pairNode : node) {
    if (pairNode.IsSequence() && pairNode.size() == 2) {
      int threshold = pairNode[0].as<int>();
      int value = pairNode[1].as<int>();
      result.emplace_back(threshold, value);
    }
  }
  return result;
}

/**
 * Reads the current swappiness value from the system.
 */
int read_swappiness() {
  ifstream file("/proc/sys/vm/swappiness");
  int swappiness;
  if (file >> swappiness) {
    return swappiness;
  }
  return -1;
}

/**
 * Writes a new swappiness value to the system.
 */
void write_swappiness(int value) {
  ofstream file("/proc/sys/vm/swappiness");
  if (!file) {
    ALOGE(
        "Error: Unable to write to /proc/sys/vm/swappiness. Check "
        "permission.");
    return;
  }
  file << value;
}

/**
 * Reads a specific pressure metric from /proc/pressure/<resource>.
 */
double read_pressure(const string &resource, const string &level,
                     const string &key) {
  string file_path = "/proc/pressure/" + resource;
  ifstream file(file_path);

  if (!file.is_open()) {
    ALOGE("Error: Unable to open %s", file_path.c_str());
    return nan("");
  }

  string line;
  while (getline(file, line)) {
    istringstream iss(line);
    string word;
    iss >> word;

    if (word == level) {
      string metric;
      while (iss >> metric) {
        size_t pos = metric.find('=');
        if (pos != string::npos) {
          string metric_key = metric.substr(0, pos);
          string metric_value = metric.substr(pos + 1);

          if (metric_key == key) {
            return stod(metric_value);
          }
        }
      }
    }
  }

  ALOGE("Key: %s not found.", key.c_str());
  return nan("");
}

/**
 * Handles termination signals.
 */
void signal_handler(int signal) {
  ALOGI("Received signal %d, exiting...", signal);
  running = false;
  _Exit(signal);
}

/**
 * Saves a PID to a file (PID_DB) with a given name.
 * If the name already exists, it is replaced.
 *
 * @param pid_name The name associated with the PID.
 * @param pid_value The PID to be saved.
 */
void save_pid(const string &pid_name, int pid_value) {
  vector<string> lines;
  string line;
  bool found = false;

  // Open the PID_DB file for reading.
  ifstream infile(PIDS_DB);
  if (infile) {
    while (getline(infile, line)) {
      // Check if the line starts with "pid_name="
      if (line.compare(0, pid_name.size() + 1, pid_name + "=") != 0) {
        lines.push_back(line);
      } else {
        found = true;
      }
    }
    infile.close();
  }

  // Append the new PID entry.
  lines.push_back(pid_name + "=" + to_string(pid_value));

  // Open PID_DB for writing (this overwrites the file).
  ofstream outfile(PIDS_DB);
  if (!outfile) {
    ALOGE("Error: Unable to open %s for writing.", PIDS_DB.c_str());
    return;
  }

  for (const auto &l : lines) {
    outfile << l << "\n";
  }
  outfile.close();

  ALOGD("Saved PID %d for %s %s", pid_value, pid_name.c_str(),
        found ? "(Updated)" : "(New)");
}

// Function to get the smallest priority of active ZRAM swaps
int get_smlst_priority() {
  ifstream file(SWAP_PROC_FILE);
  if (!file) {
    ALOGE("Error: Unable to open %s", SWAP_PROC_FILE);
    return -1;
  }

  string line;
  vector<int> priorities;

  // Skip the first line (header)
  getline(file, line);

  while (getline(file, line)) {
    istringstream iss(line);
    string device;
    int priority;
    string temp;

    // Extract values: device name is first, priority is the 5th column
    for (int i = 0; i < 5; ++i) {
      if (!(iss >> temp)) {
        break;
      }
      if (i == 0) {
        device = temp;
      } else if (i == 4) {
        priority = stoi(temp);
      }
    }

    priorities.push_back(priority);
  }

  if (priorities.empty()) {
    ALOGW("No active swaps found.");
    return 32767;
  }

  return *min_element(priorities.begin(), priorities.end());
}

// Function to check if a ZRAM device is active
bool is_active(const string &device) {
  ifstream file(SWAP_PROC_FILE);
  if (!file) {
    ALOGE("Error: Unable to open %s", SWAP_PROC_FILE);
    return false;
  }

  string line;
  while (getline(file, line)) {
    if (line.find(device) != string::npos) {
      return true;
    }
  }
  return false;
}

pair<vector<string>, vector<string>> get_available_swap() {
  vector<string> swap_files, zram_devices;
  vector<string> dir_list = {SWAP_DIR, ZRAM_DIR};

  for (const auto &dir : dir_list) {
    if (!fs::exists(dir)) {
      ALOGW("Directory does not exist: %s", dir.c_str());
      continue;
    }
    if (!fs::is_directory(dir)) {
      ALOGW("Path is not a directory: %s", dir.c_str());
      continue;
    }

    for (const auto &entry : fs::directory_iterator(dir)) {
      bool swap_found = false;

      if (entry.is_directory()) continue;

      string pathStr = entry.path().string();
      if (is_active(pathStr)) {
        ALOGI("ACTIVE SWAP detected: %s", pathStr.c_str());
      } else {
        if (pathStr.find("swap") != string::npos) {
          swap_files.push_back(pathStr);
          swap_found = true;
        } else if (pathStr.find("zram") != string::npos) {
          zram_devices.push_back(pathStr);
          swap_found = true;
        }

        if (swap_found) {
          ALOGD("INACTIVE SWAP found: %s", pathStr.c_str());
        }
      }
    }
  }

  // ✅ **Sorting logic**
  auto extract_number = [](const string &s) -> int {
    size_t pos = s.find_last_not_of("0123456789");
    return (pos != string::npos) ? stoi(s.substr(pos + 1)) : -1;
  };

  sort(swap_files.begin(), swap_files.end(),
       [&](const string &a, const string &b) {
         return extract_number(a) > extract_number(b);
       });

  sort(zram_devices.begin(), zram_devices.end(),
       [&](const string &a, const string &b) {
         return extract_number(a) > extract_number(b);
       });

  // ✅ **Combine them: swap first, then zram**
  vector<string> available_swaps;
  available_swaps.insert(available_swaps.end(), swap_files.begin(),
                         swap_files.end());
  available_swaps.insert(available_swaps.end(), zram_devices.begin(),
                         zram_devices.end());

  for (const auto &swap : available_swaps) {
    ALOGD("Available SWAP: %s", swap.c_str());
  }

  return {zram_devices, swap_files};
}

vector<string> get_active_swap() {
  string line;
  vector<pair<string, long>> swaps;  // Store (device, usage)
  ifstream file(SWAP_PROC_FILE);

  if (!file) {
    ALOGE("Error: Unable to open %s", SWAP_PROC_FILE);
    return {};  // Return empty if file can't be opened
  }

  // Skip header
  getline(file, line);

  while (getline(file, line)) {
    istringstream iss(line);
    string device;
    long size, used;  // We only care about "used"
    iss >> device >> size >> used;

    if (!device.empty()) {
      swaps.emplace_back(device, used);
    }
  }

  // Sort swaps by usage (descending order)
  sort(swaps.begin(), swaps.end(),
       [](const pair<string, long> &a, const pair<string, long> &b) {
         return a.second > b.second;  // Biggest usage first
       });

  // Extract sorted device names
  vector<string> active_swaps;
  for (const auto &swap : swaps) {
    active_swaps.push_back(swap.first);
  }

  return active_swaps;
}

pair<int, int> get_swap_usage(const string &device) {
  string line;
  ifstream proc_file(SWAP_PROC_FILE);

  getline(proc_file, line);  // Skip header line

  int size = 0, used = 0;
  while (getline(proc_file, line)) {
    if (line.find(device) != string::npos) {
      istringstream iss(line);
      string temp;
      iss >> temp >> temp >> size >> used;
      break;
    }
  }

  if (size == 0) {
    lock_guard<mutex> lock(safe_thread_mutex);
    active_swaps = get_active_swap();
    available_swaps = get_available_swap();

    ALOGE("Error: Could not determine size of %s", device.c_str());

    return {0, -1};  // Return -1% to indicate error
  }

  int used_percentage = (used * 100) / size;
  int used_mb = (used / 1024);
  return {used_mb, used_percentage};  // Return {used MB, percentage}
}

vector<string> get_lusg_swaps() {
  string line;
  ifstream proc_file(SWAP_PROC_FILE);
  vector<string> low_usage_swaps;

  getline(proc_file, line);  // Skip header line

  int used = 0;
  string device;
  while (getline(proc_file, line)) {
    istringstream iss(line);
    string temp;
    iss >> device >> temp >> temp >> used;
    int used_mb = (used / 1024);

    if (used_mb < 10) {
      low_usage_swaps.push_back(device);
    }
  }

  return low_usage_swaps;
}

int get_memory_pressure() {
  FILE *fp = popen("free -b", "r");
  if (!fp) {
    perror("popen failed");
    return -1;
  }

  string line;
  char buffer[256];
  long mem_used = 0, swap_used = 0;

  // Skip the header
  fgets(buffer, sizeof(buffer), fp);

  while (fgets(buffer, sizeof(buffer), fp)) {
    istringstream iss(buffer);
    string label;
    long used = 0, temp;

    iss >> label;
    if (label == "Mem:") {
      iss >> temp >> used;
      mem_used = used;
    } else if (label == "Swap:") {
      iss >> temp >> used;
      swap_used = used;
    }
  }

  pclose(fp);

  long total_used = mem_used + swap_used;

  if (total_used == 0) return 0;

  return static_cast<int>((mem_used * 100) / total_used);
}

template <typename T, typename U>
bool contains(const T &value, vector<U> &vector_data) {
  return find(vector_data.begin(), vector_data.end(), value) !=
         vector_data.end();
}

template <typename T>
void remove_element(const string &element, vector<T> *elements) {
  lock_guard<mutex> lock(safe_thread_mutex);
  elements->erase(remove(elements->begin(), elements->end(), element),
                  elements->end());
}

template <typename T>
void safe_push_back(const string &value, vector<T> &elements) {
  lock_guard<mutex> lock(safe_thread_mutex);
  elements.push_back(value);
}

// Function to perform swapoff on a single device
void swapoff_th(const string &device) {
  string command = "/system/bin/swapoff " + device;

  if (system(command.c_str()) == 0) {
    ALOGI("Swap: %s is turned off.", device.c_str());
    if (device.find("zram") != string::npos) {
      safe_push_back(device, available_swaps.first);
    } else {
      safe_push_back(device, available_swaps.second);
    }
    remove_element(device, &swapoff_tracker);
    remove_element(device, &active_swaps);
  } else {
    remove_element(device, &swapoff_tracker);
    ALOGE("Failed: Turn off %s", device.c_str());
  }
}

bool swapoff_(const string &device, vector<thread> &threads,
              optional<string> message = nullopt) {
  bool cntn_the_swap = contains(device, swapoff_tracker);

  if (!cntn_the_swap) {
    ALOGI("[THREAD] Swapoff: %s. %s", device.c_str(), message->c_str());
    safe_push_back(device, swapoff_tracker);
    threads.emplace_back(swapoff_th, device);
    return true;
  } else {
    return false;
  }
}

bool swapon(const string device, int priority) {
  string command =
      "/system/bin/swapon -p " + to_string(priority) + " " + device;

  if (system(command.c_str()) == 0) {
    ALOGI("SWAPON: %s, priority: %d", device.c_str(), priority);

    return true;
  } else {
    ALOGE("Failed: turn on swap %s", device.c_str());

    return false;
  }
}

bool is_doze_mode() {
  FILE *pipe = popen("dumpsys deviceidle get deep", "r");
  if (!pipe) {
    cerr << "Failed to check Doze Mode!" << endl;
    return false;
  }

  char buffer[128];
  string result = "";

  while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
    result += buffer;
  }

  pclose(pipe);

  // Trim whitespace
  result.erase(0, result.find_first_not_of(" \n\r\t"));
  result.erase(result.find_last_not_of(" \n\r\t") + 1);

  return (result == "IDLE");
}

bool is_sleep_mode() {
  FILE *pipe = popen("dumpsys power", "r");
  if (!pipe) {
    cerr << "Failed to check Sleep Mode!" << endl;
    return false;
  }

  char buffer[128];
  string result = "";

  while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
    result += buffer;
  }

  pclose(pipe);

  // Check if display is OFF
  return (result.find("mWakefulness=Asleep") != string::npos);
}

void sleeper(int seconds, function<void()> on_complete = nullptr,
             function<bool()> interrupt_check = nullptr) {
  sleeper_alive = true;
  bool interrupted = false;

  auto deadline = steady_clock::now() + chrono::seconds(seconds);
  ALOGI("Sleep for %d seconds...", seconds);

  while (steady_clock::now() < deadline) {
    this_thread::sleep_for(milliseconds(100));

    if (interrupt_check && interrupt_check()) {
      interrupted = true;
      break;
    }
  }

  if (!interrupted && on_complete) {
    ALOGD("Sleep completed.");
    on_complete();
  }

  sleeper_alive = false;
}

void start_swapoff_timer_if_idle(int wait_timeout) {
  if (is_swapoff_session || !is_sleep_mode() || sleeper_alive) return;
  thread([=] {
    sleeper(
        wait_timeout,
        [] {
          is_swapoff_session = true;
          ALOGI_ONCE("swapoff_session", "Swapoff session started...");
          ALOG_RESET("swapoff_timer");
        },
        [] {
          if (!is_sleep_mode()) {
            ALOGI("Device woke before timeout, swapoff canceled.");
            ALOG_RESET("swapoff_timer");
            ALOG_RESET("swapoff_session");
            return true;
          }
          return false;
        });
  }).detach();

  ALOGI_ONCE("swapoff timer", "Idle detected. Timer for swapoff initiated...");
}

struct Config {
  float config_version;
  int swappiness_max;
  int swappiness_min;
  int zram_activation_threshold;
  int zram_deactivation_threshold;
  int swap_activation_threshold;
  int swap_deactivation_threshold;
  int swap_deactivation_time;
  bool pressure_binding;
  bool deactivate_in_sleep;
  string threshold_type;

  void load_from_yaml() {
    config_version = read_config(".config_version", -1.0);
    swappiness_max =
        read_config(".dynamic_swappiness.swappiness_range.max", 100);
    swappiness_min =
        read_config(".dynamic_swappiness.swappiness_range.min", 80);
    zram_activation_threshold =
        read_config(".virtual_memory.zram.activation_threshold", 70);
    zram_deactivation_threshold =
        read_config(".virtual_memory.zram.deactivation_threshold", 50);
    swap_activation_threshold =
        read_config(".virtual_memory.swap.activation_threshold", 90);
    swap_deactivation_threshold =
        read_config(".virtual_memory.swap.deactivation_threshold", 50);
    swap_deactivation_time = read_config(".virtual_memory.wait_timeout", 10);
    pressure_binding = read_config(".virtual_memory.pressure_binding", false);
    deactivate_in_sleep =
        read_config(".virtual_memory.deactivate_in_sleep", true);
    threshold_type =
        read_config(".dynamic_swappiness.threshold_type", string("psi"));
  }
};

struct PressureMapping {
  vector<pair<int, int>> cpu;
  vector<pair<int, int>> memory;
  vector<pair<int, int>> io;
  vector<pair<int, int>> mem_pressure;
};

struct DynamicSwappinessConfig {
  int min_swappiness;
  int max_swappiness;
  Config _config;
  string threshold_type = _config.threshold_type;
  PressureMapping pressure_mapping;
  string mode;
  int levels;
  int cpu_max;
  int cpu_min;
  int mem_max;
  int mem_min;
  int io_max;
  int io_min;
  string cpu_time_window;
  string mem_time_window;
  string io_time_window;

  string pressure_to_string(const vector<pair<int, int>> &pressure_vec) {
    stringstream ss;
    for (size_t i = 0; i < pressure_vec.size(); ++i) {
      ss << "[" << pressure_vec[i].first << "," << pressure_vec[i].second
         << "]";
      if (i != pressure_vec.size() - 1) {
        ss << ", ";
      }
    }
    return ss.str();
  }

  void load_from_yaml(const YAML::Node &config) {
    ALOGD("Loading DynamicSwappinessConfig from YAML...");
    auto dyn = config["dynamic_swappiness"];
    if (!dyn) {
      ALOGW("dynamic_swappiness section not found in config.");
      return;
    }

    threshold_type = (dyn["threshold_type"] && dyn["threshold_type"].IsScalar())
                         ? dyn["threshold_type"].as<string>()
                         : "psi";
    if (dyn["swappiness_range"] && dyn["swappiness_range"].IsMap()) {
      min_swappiness = (dyn["swappiness_range"]["min"] &&
                        dyn["swappiness_range"]["min"].IsScalar())
                           ? dyn["swappiness_range"]["min"].as<int>()
                           : _config.swappiness_min;
      max_swappiness = (dyn["swappiness_range"]["max"] &&
                        dyn["swappiness_range"]["max"].IsScalar())
                           ? dyn["swappiness_range"]["max"].as<int>()
                           : _config.swappiness_max;
    } else {
      min_swappiness = _config.swappiness_min;
      max_swappiness = _config.swappiness_max;
    }

    ALOGD("threshold_type: %s", threshold_type.c_str());
    ALOGD("min_swappiness: %d, max_swappiness: %d", min_swappiness,
          max_swappiness);

    auto psi = dyn["threshold_psi"];
    if (psi) {
      // Provide default values if not present in YAML
      pressure_mapping.cpu =
          psi["cpu_pressure"] && psi["cpu_pressure"].IsSequence()
              ? parse_pressure_pairs(psi["cpu_pressure"])
              : vector<pair<int, int>>{
                    {10, 160}, {20, 120}, {30, 80}, {40, 60}, {80, 40}};
      pressure_mapping.memory =
          psi["memory_pressure"] && psi["memory_pressure"].IsSequence()
              ? parse_pressure_pairs(psi["memory_pressure"])
              : vector<pair<int, int>>{
                    {5, 160}, {10, 140}, {15, 100}, {20, 60}, {25, 40}};
      pressure_mapping.io =
          psi["io_pressure"] && psi["io_pressure"].IsSequence()
              ? parse_pressure_pairs(psi["io_pressure"])
              : vector<pair<int, int>>{
                    {10, 140}, {15, 100}, {20, 80}, {25, 100}};

      ALOGD("CPU Pressure Mapping: %s",
            pressure_to_string(pressure_mapping.cpu).c_str());
      ALOGD("Memory Pressure Mapping: %s",
            pressure_to_string(pressure_mapping.memory).c_str());
      ALOGD("IO Pressure Mapping: %s",
            pressure_to_string(pressure_mapping.io).c_str());
    } else {
      ALOGW("threshold_psi section not found in config.");
    }

    auto mem = dyn["threshold_mem_pressure"];
    mode = (psi && psi["mode"] && psi["mode"].IsScalar())
               ? psi["mode"].as<string>()
               : "auto";
    levels = (psi && psi["levels"] && psi["levels"].IsScalar())
                 ? psi["levels"].as<int>()
                 : 10;
    cpu_max = (psi && psi["auto_cpu"] && psi["auto_cpu"]["max"] &&
               psi["auto_cpu"]["max"].IsScalar())
                  ? psi["auto_cpu"]["max"].as<int>()
                  : 80;
    cpu_min = (psi && psi["auto_cpu"] && psi["auto_cpu"]["min"] &&
               psi["auto_cpu"]["min"].IsScalar())
                  ? psi["auto_cpu"]["min"].as<int>()
                  : 0;
    mem_max = (psi && psi["auto_memory"] && psi["auto_memory"]["max"] &&
               psi["auto_memory"]["max"].IsScalar())
                  ? psi["auto_memory"]["max"].as<int>()
                  : 20;
    mem_min = (psi && psi["auto_memory"] && psi["auto_memory"]["min"] &&
               psi["auto_memory"]["min"].IsScalar())
                  ? psi["auto_memory"]["min"].as<int>()
                  : 0;
    io_max = (psi && psi["auto_io"] && psi["auto_io"]["max"] &&
              psi["auto_io"]["max"].IsScalar())
                 ? psi["auto_io"]["max"].as<int>()
                 : 25;
    io_min = (psi && psi["auto_io"] && psi["auto_io"]["min"] &&
              psi["auto_io"]["min"].IsScalar())
                 ? psi["auto_io"]["min"].as<int>()
                 : 0;
    cpu_time_window =
        (psi && psi["auto_cpu"] && psi["auto_cpu"]["time_window"] &&
         psi["auto_cpu"]["time_window"].IsScalar())
            ? psi["auto_cpu"]["time_window"].as<string>()
            : "avg60";
    mem_time_window =
        (psi && psi["auto_memory"] && psi["auto_memory"]["time_window"] &&
         psi["auto_memory"]["time_window"].IsScalar())
            ? psi["auto_memory"]["time_window"].as<string>()
            : "avg60";
    io_time_window = (psi && psi["auto_io"] && psi["auto_io"]["time_window"] &&
                      psi["auto_io"]["time_window"].IsScalar())
                         ? psi["auto_io"]["time_window"].as<string>()
                         : "avg60";
    mem_time_window =
        psi && psi["auto_memory"] && psi["auto_memory"]["time_window"]
            ? psi["auto_memory"]["time_window"].as<string>()
            : "avg60";
    io_time_window = psi && psi["auto_io"] && psi["auto_io"]["time_window"]
                         ? psi["auto_io"]["time_window"].as<string>()
                         : "avg60";

    ALOGD("mode: %s, levels: %d", mode.c_str(), levels);
    ALOGD(
        "cpu_max: %d, cpu_min: %d, mem_max: %d, mem_min: %d, io_max: %d, "
        "io_min: %d",
        cpu_max, cpu_min, mem_max, mem_min, io_max, io_min);
    ALOGD("cpu_time_window: %s, mem_time_window: %s, io_time_window: %s",
          cpu_time_window.c_str(), mem_time_window.c_str(),
          io_time_window.c_str());
  }
};

bool psi_available() {
  ifstream cpu_file("/proc/pressure/cpu");
  ifstream mem_file("/proc/pressure/memory");
  ifstream io_file("/proc/pressure/io");

  if (cpu_file.good() && mem_file.good() && io_file.good()) {
    return true;
  } else {
    ALOGW_ONCE("psi_unavailable",
               "PSI metrics unavailable. Falling back to mem_pressure.");
    return false;
  }
}

class SwappinessManager {
 public:
  SwappinessManager(const DynamicSwappinessConfig &config)
      : config(config), last_swappiness(-1) {
    // Cache sorted pressure maps
    cached_cpu = sort_desc(config.pressure_mapping.cpu);
    cached_mem = sort_desc(config.pressure_mapping.memory);
    cached_io = sort_desc(config.pressure_mapping.io);
    cached_legacy = sort_desc(config.pressure_mapping.mem_pressure);
  }

  int get_swappiness() {
    int swappiness = config.threshold_type == "psi" && psi_available()
                         ? evaluate_psi()
                         : evaluate_legacy();
    return clamp(swappiness, config.min_swappiness, config.max_swappiness);
  }

  void apply_swappiness(int &swappiness) {
    if (swappiness != last_swappiness) {
      ALOGI("Swappiness -> %d", swappiness);
      write_swappiness(swappiness);
      last_swappiness = swappiness;
      reset_threshold_logs();
    }
  }

 private:
  const DynamicSwappinessConfig &config;
  int last_swappiness;

  // Cached sorted maps
  vector<pair<int, int>> cached_cpu;
  vector<pair<int, int>> cached_mem;
  vector<pair<int, int>> cached_io;
  vector<pair<int, int>> cached_legacy;

  static vector<pair<int, int>> sort_desc(const vector<pair<int, int>> &table) {
    auto sorted = table;
    sort(sorted.begin(), sorted.end(),
         [](const auto &a, const auto &b) { return a.first > b.first; });
    return sorted;
  }

  vector<int> compute_swappiness_steps(int min_swappiness, int max_swappiness,
                                       int levels) {
    vector<int> steps;
    double step =
        (max_swappiness - min_swappiness) / static_cast<double>(levels);
    for (int i = 0; i <= levels; ++i) {
      steps.insert(steps.begin(),
                   static_cast<int>(round(max_swappiness - i * step)));
    }
    return steps;
  }

  int interpolate(double pressure, double pressure_min, double pressure_max,
                  double swappiness_max, double swappiness_min) {
    return (pressure - pressure_min) * (swappiness_min - swappiness_max) /
               (pressure_max - pressure_min) +
           swappiness_max;
  }

  // Helper function to join vector<int> into a string, highlighting the
  // selected index
  static string join_vector(const vector<int> &vec, int highlight_index) {
    ostringstream oss;
    for (size_t i = 0; i < vec.size(); ++i) {
      if (static_cast<int>(i) == highlight_index) {
        oss << "[" << vec[i] << "]";
      } else {
        oss << vec[i];
      }
      if (i != vec.size() - 1) oss << " ";
    }
    return oss.str();
  }

  int interpolate_sparse(double pressure, double pressure_min,
                         double pressure_max, int swappiness_max,
                         int swappiness_min, string log_id, int levels = 4) {
    // Step 1: Clamp the pressure
    pressure = clamp(pressure, pressure_min, pressure_max);
    // Step 2: Normalize the pressure to [0,1]
    double norm = (pressure - pressure_min) / (pressure_max - pressure_min);
    // Step 3: Reverse the normalized value so high pressure → low swappiness
    double reversed = 1.0 - norm;
    // Step 4: Calculate index based on levels
    int index = round(reversed * levels);
    index = clamp(index, 0, levels);
    // Step 5: Generate swappiness steps
    vector<int> swappiness_steps =
        compute_swappiness_steps(swappiness_min, swappiness_max, levels);

    ostringstream oss;
    for (size_t i = 0; i < swappiness_steps.size(); ++i) {
      if (i == index)
        oss << "[" << swappiness_steps[i] << "] ";
      else
        oss << swappiness_steps[i] << " ";
    }

    ALOGI_ONCE(log_id,
               "[%s] PSI: %.2f normalized to %.4f (reversed: %.4f). "
               "Using level %d → swappiness %d from steps [%s]",
               log_id.c_str(), pressure, norm, reversed, index,
               swappiness_steps[index],
               join_vector(swappiness_steps, index).c_str());
    // Step 6: Return selected swappiness
    return swappiness_steps[index];
  }

  int evaluate_psi() {
    double cpu = read_pressure("cpu", "some", config.cpu_time_window);
    double mem = read_pressure("memory", "some", config.mem_time_window);
    double io = read_pressure("io", "some", config.io_time_window);

    if (config.mode == "auto") {
      vector<int> pressures = {};
      vector<tuple<pair<int, int>, double, string>> types = {
          {make_pair(config.cpu_max, config.cpu_min), cpu, "cpu_pressure"},
          {make_pair(config.mem_max, config.mem_min), mem, "mem_pressure"},
          {make_pair(config.io_max, config.io_min), io, "io_pressure"}};

      for (const auto &[pair, pressure, log_id] : types) {
        double max = pair.first;
        double min = pair.second;
        pressures.push_back(
            interpolate_sparse(pressure, min, max, config.max_swappiness,
                               config.min_swappiness, log_id, config.levels));
      }

      int swappiness = min({pressures[0], pressures[1], pressures[2]});
      log_if_threshold("sparsed_swappiness", swappiness, cpu, mem, io);
      ALOGI_ONCE(
          "swappiness_eval",
          "[AUTO MODE] CPU(%s): %.2f → %d, MEM(%s): %.2f → %d, IO(%s): %.2f → "
          "%d → FINAL: %d",
          config.cpu_time_window.c_str(), cpu, pressures[0],
          config.mem_time_window.c_str(), mem, pressures[1],
          config.io_time_window.c_str(), io, pressures[2], swappiness);

      return swappiness;
    } else {
      int cpu_swappiness = max(get_swappiness_from_pressure(cached_cpu, cpu),
                               config.min_swappiness);
      int mem_swappiness = max(get_swappiness_from_pressure(cached_mem, mem),
                               config.min_swappiness);
      int io_swappiness = max(get_swappiness_from_pressure(cached_io, io),
                              config.min_swappiness);
      int swappiness = max({cpu_swappiness, mem_swappiness, io_swappiness});

      log_if_threshold("cpu_threshold", cpu_swappiness, cpu, mem, io);
      log_if_threshold("mem_threshold", mem_swappiness, cpu, mem, io);
      log_if_threshold("io_threshold", io_swappiness, cpu, mem, io);
      return (swappiness != -1) ? swappiness : config.max_swappiness;
    }
  }

  int evaluate_legacy() {
    int mem_pressure = get_memory_pressure();
    return (get_swappiness_from_pressure(cached_legacy, mem_pressure) != -1)
               ? get_swappiness_from_pressure(cached_legacy, mem_pressure)
               : config.max_swappiness;
  }

  void log_if_threshold(const string &tag, int swappiness, double cpu,
                        double mem, double io) {
    if (swappiness != -1) {
      ALOGI_ONCE(tag,
                 "[THRESHOLD] [%s] Swappiness: %d | Pressures: CPU=%.2f, "
                 "MEM=%.2f, IO=%.2f",
                 tag.c_str(), swappiness, cpu, mem, io);
    } else {
      ALOG_RESET(tag);
    }
  }

  void reset_threshold_logs() {
    ALOG_RESET("cpu_threshold");
    ALOG_RESET("mem_threshold");
    ALOG_RESET("io_threshold");
    ALOG_RESET("cpu_pressure");
    ALOG_RESET("mem_pressure");
    ALOG_RESET("io_pressure");
    ALOG_RESET("swappiness_eval");
  }

  static int get_swappiness_from_pressure(const vector<pair<int, int>> &table,
                                          double pressure) {
    for (const auto &[threshold, value] : table) {
      if (pressure >= threshold) return value;
    }
    return -1;
  }
};

/**
 * Dynamic swappiness adjustment service.
 */
void dyn_swap_service() {
  Config config;
  config.load_from_yaml();
  float CONFIG_VERSION = config.config_version;
  int SWAPPINESS_MAX = config.swappiness_max;
  int SWAPPINESS_MIN = config.swappiness_min;
  int ZRAM_ACTIVATION_THRESHOLD = config.zram_activation_threshold;
  int ZRAM_DEACTIVATION_THRESHOLD = config.zram_deactivation_threshold;
  int SWAP_ACTIVATION_THRESHOLD = config.swap_activation_threshold;
  int SWAP_DEACTIVATION_THRESHOLD = config.swap_deactivation_threshold;
  int SWAP_DEACTIVATION_TIME = config.swap_deactivation_time;
  bool PRESSURE_BINDING = config.pressure_binding;
  bool DEACTIVATE_IN_SLEEP = config.deactivate_in_sleep;
  string THRESHOLD_TYPE = config.threshold_type;

  YAML::Node configRoot;
  try {
    configRoot = YAML::LoadFile(DEFAULT_CONFIG);
  } catch (const std::exception &e) {
    ALOGE("Failed to load config file: %s", e.what());
  }
  DynamicSwappinessConfig dynConfig;
  dynConfig.load_from_yaml(configRoot);
  SwappinessManager swappinessManager(dynConfig);

  active_swaps = get_active_swap();
  available_swaps = get_available_swap();
  string swap_type = "zram";
  string last_active_swap, scnd_lst_swap, next_swap, first_swap;
  thread wfs_thread;
  vector<thread> swapoff_thread;
  vector<string> *current_avs, low_usage_swaps;
  pair<int, int> lst_swap_usage, sc_prev_swap_usg;

  int last_swappiness = read_swappiness();
  int new_swappiness = SWAPPINESS_MAX;
  int wait_timeout = SWAP_DEACTIVATION_TIME;
  int activation_threshold, deactivation_threshold, lst_scnd_act_threshold,
      priority;
  bool unbounded = true;
  bool is_condition_met, kill_low_swap, in_pressure;
  bool threshold_psi = THRESHOLD_TYPE == "psi";
  bool threshold_mem_pressure = THRESHOLD_TYPE == "mem_pressure";
  bool dynv_enabled = read_config(".dynamic_swappiness.enable", true);
  if (!dynv_enabled) {
    swappinessManager.apply_swappiness(SWAPPINESS_MAX);
  }
  is_swapoff_session = (!DEACTIVATE_IN_SLEEP) ? true : false;

  ALOGI("Config version: %.2f", CONFIG_VERSION);

  while (running) {
    if (!is_doze_mode()) {
      if (dynv_enabled) {
        new_swappiness = swappinessManager.get_swappiness();
        swappinessManager.apply_swappiness(new_swappiness);
      } else {
        ALOGI_ONCE("dynv disabled", "Dynamic Swappiness is disabled.");
      }

      if (DEACTIVATE_IN_SLEEP) {
        start_swapoff_timer_if_idle(wait_timeout);
        if (!is_sleep_mode()) {
          is_swapoff_session = false;
          ALOG_RESET("swapoff_session");
          ALOG_RESET("swapoff_timer");
        }
      }

      // SWAP management logic
      if (unbounded) {
        // Load available swaps
        if (!available_swaps.first.empty()) {
          current_avs = &available_swaps.first;
        } else if (!available_swaps.second.empty()) {
          current_avs = &available_swaps.second;
        }

        // If there's no swap turn on first swap
        if (active_swaps.empty()) {
          first_swap = current_avs->back();
          priority = get_smlst_priority();

          if (swapon(first_swap, priority)) {
            safe_push_back(first_swap, active_swaps);
            current_avs->pop_back();

            ALOGI("SWAPON: %s.", first_swap.c_str());
          } else {
            available_swaps = get_available_swap();
          }
        } else {
          last_active_swap = active_swaps.back();
          lst_swap_usage = get_swap_usage(last_active_swap);
          activation_threshold =
              (last_active_swap.find(SWAP_FILE_PREFIX) != string::npos)
                  ? SWAP_ACTIVATION_THRESHOLD
                  : ZRAM_ACTIVATION_THRESHOLD;
          deactivation_threshold =
              (last_active_swap.find(SWAP_FILE_PREFIX) != string::npos)
                  ? SWAP_DEACTIVATION_THRESHOLD
                  : ZRAM_DEACTIVATION_THRESHOLD;
          low_usage_swaps = get_lusg_swaps();

          /*
            If conditions:
              1. Swap usage is more than activation threshold
              2. Swap is available
              3. Device is not in sleep mode which probably better for battery
                 with swap usage low so less process running.
            Then:
              - Turn on next available swap
          */
          if (lst_swap_usage.second > activation_threshold &&
              !current_avs->empty() && !is_sleep_mode()) {
            next_swap = current_avs->back();
            priority = (next_swap.find("fmiop_swap.1") != string::npos)
                           ? get_smlst_priority()
                           : get_smlst_priority() - 1;

            if (swapon(next_swap, priority)) {
              safe_push_back(next_swap, active_swaps);
              current_avs->pop_back();
            } else {
              available_swaps = get_available_swap();
            }
          } else {
            // If SWAP more than 1 then check if need to turn off SWAP
            try {
              scnd_lst_swap = active_swaps.at(active_swaps.size() - 2);
              lst_scnd_act_threshold =
                  (scnd_lst_swap.find(SWAP_FILE_PREFIX) != string::npos)
                      ? SWAP_ACTIVATION_THRESHOLD
                      : ZRAM_ACTIVATION_THRESHOLD;
              sc_prev_swap_usg = get_swap_usage(scnd_lst_swap);
              is_condition_met =
                  (sc_prev_swap_usg.second < lst_scnd_act_threshold &&
                   lst_swap_usage.first < deactivation_threshold) &&
                  is_swapoff_session;
              kill_low_swap =
                  (!low_usage_swaps.empty() &&
                   sc_prev_swap_usg.second < lst_scnd_act_threshold &&
                   active_swaps.size() > 1);

              // If one of condition is met turn off SWAP
              if (is_condition_met) {
                ALOGW("condition met",
                      "sleep more than %d minutes. Deactivating swap...",
                      SWAP_DEACTIVATION_TIME);
                swapoff_(last_active_swap, swapoff_thread);
              } else if (kill_low_swap) {
                for (auto swap : low_usage_swaps) {
                  swapoff_(swap, swapoff_thread, "Reason: low swap usage.");
                }
              }
              ALOG_RESET("swapoff_end");
            } catch (const out_of_range &e) {
              ALOGW_ONCE("swapoff_end", "No second last swap.");
              ALOG_RESET("condition met");
            }
          }
        }
      }
      // Sleep for 1 second (100ms * 10 loops) to make it more responsive
      for (int i = 0; i < 10 && running; ++i) {
        this_thread::sleep_for(milliseconds(100));
      }
    }
  }
}

void relmkd() {
  system("resetprop lmkd.reinit 1");
  ALOGD("LMKD reinitialized");
}

bool prop_exists(const string &prop) {
  string command = "resetprop -v " + prop + " 2>/dev/null";
  FILE *pipe = popen(command.c_str(), "r");
  if (!pipe) {
    ALOGW("Failed to check property: %s", prop.c_str());
    return false;
  }

  char buffer[128];
  bool exists = false;
  if (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
    exists = true;  // If output is not empty, property exists
  }

  pclose(pipe);
  return exists;
}

bool rm_prop(const vector<string> &props) {
  for (const auto &prop : props) {
    if (prop_exists(prop)) {
      string command = "resetprop -d " + prop;
      int result = system(command.c_str());

      if (result == 0) {
        ALOGW("Prop %s deleted successfully", prop.c_str());
        return true;
      } else {
        ALOGW("Failed to delete prop: %s", prop.c_str());
      }
    }
  }
  return false;
}

void fmiop() {
  ALOGI("Starting minfree_level deleter service.");

  while (true) {
    if (rm_prop({"sys.lmk.minfree_levels"})) {
      relmkd();
    }
    this_thread::sleep_for(seconds(1));
  }
}

int main() {
  signal(SIGINT, signal_handler);

  pid_t pid, sid;

  pid = fork();

  if (pid < 0) {
    exit(EXIT_FAILURE);
  }

  if (pid > 0) {
    exit(EXIT_SUCCESS);  // Parent process exits
  }

  // Set file mode creation mask to 0
  umask(0);

  // Create a new session ID
  sid = setsid();
  if (sid < 0) {
    ALOGE("Failed to create new session: %s", strerror(errno));
    exit(EXIT_FAILURE);
  }

  if (chdir("/") < 0) {
    ALOGE("Failed to change working directory: %s", strerror(errno));
    exit(EXIT_FAILURE);
  }

  // Close standard file descriptors
  close(STDIN_FILENO);
  close(STDOUT_FILENO);
  close(STDERR_FILENO);

  pid_t current_pid = getpid();
  ALOGI("Current PID: %d", current_pid);
  save_pid("dyn_swap_service", current_pid);

  thread adjust_thread(dyn_swap_service);
  thread fmiop_thread(fmiop);
  adjust_thread.join();
  fmiop_thread.join();
  return 0;
}