config.cpp

#include "pch.h"

#include "config.h"

#include <algorithm>
#include <cctype>
#include <fstream>
#include <optional>
#include <string>
#include <vector>

namespace mapupdater::config {
namespace {

std::string TrimCopy(const std::string &value) {
  const auto is_space = [](unsigned char ch) { return std::isspace(ch) != 0; };

  auto begin = value.begin();
  while (begin != value.end() && is_space(static_cast<unsigned char>(*begin))) {
    ++begin;
  }

  auto end = value.end();
  while (end != begin && is_space(static_cast<unsigned char>(*(end - 1)))) {
    --end;
  }

  return std::string(begin, end);
}

std::string ToLowerAscii(std::string value) {
  std::transform(value.begin(), value.end(), value.begin(),
                 [](unsigned char ch) {
                   return static_cast<char>(std::tolower(ch));
                 });
  return value;
}

std::optional<bool> ParseBool(std::string value) {
  value = ToLowerAscii(TrimCopy(value));

  if (value == "true" || value == "1" || value == "yes" || value == "on") {
    return true;
  }
  if (value == "false" || value == "0" || value == "no" || value == "off") {
    return false;
  }

  return std::nullopt;
}

void WriteDefaultConfig(const std::filesystem::path &path) {
  std::ofstream out(path, std::ios::trunc);
  if (!out.is_open()) {
    return;
  }

  out << "[Settings]\n";
  out << "debug = false\n";
  out << "autoupdate = true\n";
  out << "checksize = true\n";
  out << "dota = true\n";
  out << "lod = false\n";
  out << "# Relative path from the Warcraft III root directory where MPQ files should be placed (e.g. mpq/).\n";
  out << "# If empty or not set, files will be downloaded to the root Warcraft III directory.\n";
  out << "# Note: Ordinary players do NOT need to change these settings. They are only intended for developers.\n";
  out << "dota_files_folder =\n";
  out << "lod_files_folder =\n";
}

} // namespace

std::filesystem::path SelectConfigFile(const std::filesystem::path &base_dir) {
  static const std::vector<std::string> config_files = {
      "MapUpdater.ini", "DotaUpdater.ini", "LodUpdater.ini"};

  for (const auto &name : config_files) {
    const auto candidate = base_dir / name;
    std::error_code ec;
    if (std::filesystem::exists(candidate, ec) && !ec) {
      return candidate;
    }
  }

  return base_dir / "MapUpdater.ini";
}

AppConfig LoadConfig(const std::filesystem::path &path) {
  AppConfig config;

  std::ifstream file(path);
  if (!file.is_open()) {
    WriteDefaultConfig(path);
    return config;
  }

  std::string line;
  while (std::getline(file, line)) {
    const size_t comment_pos = line.find_first_of(";#");
    if (comment_pos != std::string::npos) {
      line.erase(comment_pos);
    }

    line = TrimCopy(line);
    if (line.empty() || line.front() == '[') {
      continue;
    }

    const size_t eq_pos = line.find('=');
    if (eq_pos == std::string::npos) {
      continue;
    }

    const std::string key = ToLowerAscii(TrimCopy(line.substr(0, eq_pos)));
    const std::string raw_value = TrimCopy(line.substr(eq_pos + 1));

    if (key == "dota_files_folder") {
      config.dota_files_folder = raw_value;
    } else if (key == "lod_files_folder") {
      config.lod_files_folder = raw_value;
    } else {
      const auto bool_value = ParseBool(raw_value);
      if (!bool_value.has_value()) {
        continue;
      }

      if (key == "debug") {
        config.debug_enabled = *bool_value;
      } else if (key == "autoupdate") {
        config.autoupdate_enabled = *bool_value;
      } else if (key == "checksize") {
        config.checksize_enabled = *bool_value;
      } else if (key == "dota") {
        config.dota_enabled = *bool_value;
      } else if (key == "lod") {
        config.lod_enabled = *bool_value;
      }
    }
  }

  return config;
}

} // namespace mapupdater::config