ConfigManager.cpp

Go to the documentation of this file.

#include "Parsers/ConfigManager.h"
#include "Utils/Logger.h"
#include <cstdlib>
#include <dirent.h>
#include <fstream>
#include <nlohmann/json.hpp>
#include <pwd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
namespace EmberCore {
 
// Helper function to check if directory exists
static bool DirectoryExists(const String &path) {
    struct stat st;
    return stat(path.c_str(), &st) == 0 && S_ISDIR(st.st_mode);
}
 
const String ConfigManager::DEFAULT_PROFILE_NAME = "Default";
const String ConfigManager::GENERIC_PROFILE_NAME = "Generic";
 
ConfigManager &ConfigManager::GetInstance() {
    static ConfigManager instance;
    return instance;
}
 
ConfigManager::ConfigManager() : active_profile_name_(DEFAULT_PROFILE_NAME) {
 
    // Find resources directory relative to the executable
    // Check multiple candidate locations for flexibility
    String resources_base;
 
    // First check EMBER_RESOURCES environment variable
    const char *env_resources = std::getenv("EMBER_RESOURCES");
    if (env_resources && DirectoryExists(String(env_resources) + "/parser_profiles")) {
        resources_base = String(env_resources);
    } else {
        // Get executable directory
        char exe_path[1024];
        ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1);
 
        if (len != -1) {
            exe_path[len] = '\0';
            String exe_dir = String(exe_path);
            size_t last_slash = exe_dir.find_last_of('/');
            if (last_slash != String::npos) {
                exe_dir = exe_dir.substr(0, last_slash);
            }
 
            // Try multiple candidate locations
            std::vector<String> candidates = {
                exe_dir + "/resources",       // resources next to exe
                exe_dir + "/../resources",    // resources in parent (exe in bin/)
                exe_dir + "/../../resources", // resources in grandparent (exe in build/bin/)
            };
 
            for (const auto &candidate : candidates) {
                if (DirectoryExists(candidate + "/parser_profiles")) {
                    resources_base = candidate;
                    break;
                }
            }
        }
    }
 
    // Set paths based on found resources directory, or fallback to relative
    if (!resources_base.empty()) {
        profiles_directory_ = resources_base + "/parser_profiles";
        config_file_ = resources_base + "/parser_profiles/config.json";
    } else {
        // Fallback to relative path (CWD-based, not recommended but maintains compatibility)
        profiles_directory_ = "resources/parser_profiles";
        config_file_ = "resources/parser_profiles/config.json";
        LOG_WARNING("ConfigManager", "Could not find resources directory, using relative path");
    }
 
    LOG_INFO("ConfigManager", "Profiles directory: " + profiles_directory_);
    LOG_INFO("ConfigManager", "Config file: " + config_file_);
 
    // Ensure directory exists and load profiles
    if (EnsureProfilesDirectoryExists()) {
        LoadProfiles();
    }
 
    // If no profiles exist, initialize defaults
    if (profiles_.empty()) {
        InitializeDefaultProfiles();
        SaveProfiles();
    }
 
    // Load config file (contains active profile and other settings)
    LoadConfigFile();
}
 
bool ConfigManager::EnsureProfilesDirectoryExists() {
    // Create parent directories if needed (resources, then parser_profiles)
    String emberforge_dir = profiles_directory_.substr(0, profiles_directory_.find_last_of('/'));
 
    struct stat st;
    if (stat(emberforge_dir.c_str(), &st) != 0) {
        if (mkdir(emberforge_dir.c_str(), 0755) != 0) {
            LOG_ERROR("ConfigManager", "Failed to create .emberforge directory: " + emberforge_dir);
            return false;
        }
    }
 
    // Create parser_profiles directory
    if (stat(profiles_directory_.c_str(), &st) != 0) {
        if (mkdir(profiles_directory_.c_str(), 0755) != 0) {
            LOG_ERROR("ConfigManager", "Failed to create profiles directory: " + profiles_directory_);
            return false;
        }
        LOG_INFO("ConfigManager", "Created profiles directory: " + profiles_directory_);
    }
 
    return true;
}
 
void ConfigManager::InitializeDefaultProfiles() {
    std::lock_guard<std::mutex> lock(mutex_);
    InitializeDefaultProfilesInternal();
}
 
void ConfigManager::InitializeDefaultProfilesInternal() {
    // Note: Mutex must be locked by caller
    LOG_INFO("ConfigManager", "Initializing default profiles");
 
    // Create default profile
    auto default_profile = ParserProfile::CreateDefaultProfile();
    profiles_[DEFAULT_PROFILE_NAME] = default_profile;
 
    // Create generic profile
    auto generic_profile = ParserProfile::CreateGenericProfile();
    profiles_[GENERIC_PROFILE_NAME] = generic_profile;
 
    active_profile_name_ = DEFAULT_PROFILE_NAME;
}
 
bool ConfigManager::LoadProfiles() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    LOG_INFO("ConfigManager", "Loading profiles from: " + profiles_directory_);
 
    DIR *dir = opendir(profiles_directory_.c_str());
    if (!dir) {
        LOG_ERROR("ConfigManager", "Failed to open profiles directory");
        return false;
    }
 
    int loaded_count = 0;
    struct dirent *entry;
    while ((entry = readdir(dir)) != nullptr) {
        String filename = entry->d_name;
 
        // Skip config.json (it's not a profile file)
        if (filename == "config.json") {
            continue;
        }
 
        // Only process .json files
        if (filename.length() > 5 && filename.substr(filename.length() - 5) == ".json") {
            String filepath = profiles_directory_ + "/" + filename;
 
            auto profile = LoadProfileFromFile(filepath);
            if (profile) {
                profiles_[profile->GetName()] = profile;
                loaded_count++;
            }
        }
    }
 
    closedir(dir);
 
    LOG_INFO("ConfigManager", "Loaded " + std::to_string(loaded_count) + " profile(s)");
    return true;
}
 
std::shared_ptr<ParserProfile> ConfigManager::LoadProfileFromFile(const String &filepath) {
    try {
        ParserProfile profile;
        if (profile.LoadFromFile(filepath)) {
            return std::make_shared<ParserProfile>(profile);
        }
    } catch (const std::exception &e) {
        LOG_ERROR("ConfigManager", "Failed to load profile from " + filepath + ": " + e.what());
    }
    return nullptr;
}
 
bool ConfigManager::SaveProfiles() {
    std::lock_guard<std::mutex> lock(mutex_);
    return SaveProfilesInternal();
}
 
bool ConfigManager::SaveProfilesInternal() {
    // Note: Mutex must be locked by caller
    if (!EnsureProfilesDirectoryExists()) {
        return false;
    }
 
    LOG_INFO("ConfigManager", "Saving " + std::to_string(profiles_.size()) + " profile(s)");
 
    bool all_saved = true;
    for (const auto &pair : profiles_) {
        const String &profile_name = pair.first;
        if (!SaveProfile(profile_name)) {
            all_saved = false;
        }
    }
 
    // Save config file (includes active profile)
    SaveConfigFile();
 
    return all_saved;
}
 
bool ConfigManager::SaveProfile(const String &profile_name) {
    auto profile = GetProfileInternal(profile_name);
    if (!profile) {
        LOG_ERROR("ConfigManager", "Profile not found: " + profile_name);
        return false;
    }
 
    String filepath = GetProfileFilePath(profile_name);
    return profile->SaveToFile(filepath);
}
 
bool ConfigManager::AddProfile(std::shared_ptr<ParserProfile> profile) {
    if (!profile) {
        LOG_ERROR("ConfigManager", "Cannot add null profile");
        return false;
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    String profile_name = profile->GetName();
    if (HasProfileInternal(profile_name)) {
        LOG_ERROR("ConfigManager", "Profile already exists: " + profile_name);
        return false;
    }
 
    profiles_[profile_name] = profile;
    SaveProfile(profile_name);
 
    LOG_INFO("ConfigManager", "Added profile: " + profile_name);
    return true;
}
 
bool ConfigManager::RemoveProfile(const String &profile_name) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Don't allow removing default profiles
    if (profile_name == DEFAULT_PROFILE_NAME || profile_name == GENERIC_PROFILE_NAME) {
        LOG_ERROR("ConfigManager", "Cannot remove default profile: " + profile_name);
        return false;
    }
 
    if (!HasProfileInternal(profile_name)) {
        LOG_ERROR("ConfigManager", "Profile not found: " + profile_name);
        return false;
    }
 
    // If this was the active profile, switch to default
    if (active_profile_name_ == profile_name) {
        active_profile_name_ = DEFAULT_PROFILE_NAME;
    }
 
    // Remove from map
    profiles_.erase(profile_name);
 
    // Delete file
    String filepath = GetProfileFilePath(profile_name);
    if (unlink(filepath.c_str()) != 0) {
        LOG_WARNING("ConfigManager", "Failed to delete profile file: " + filepath);
    }
 
    LOG_INFO("ConfigManager", "Removed profile: " + profile_name);
    return true;
}
 
bool ConfigManager::RenameProfile(const String &old_name, const String &new_name) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Don't allow renaming default profiles
    if (old_name == DEFAULT_PROFILE_NAME || old_name == GENERIC_PROFILE_NAME) {
        LOG_ERROR("ConfigManager", "Cannot rename default profile: " + old_name);
        return false;
    }
 
    auto profile = GetProfileInternal(old_name);
    if (!profile) {
        LOG_ERROR("ConfigManager", "Profile not found: " + old_name);
        return false;
    }
 
    if (HasProfileInternal(new_name)) {
        LOG_ERROR("ConfigManager", "Profile with new name already exists: " + new_name);
        return false;
    }
 
    // Update profile name
    profile->SetName(new_name);
    profile->UpdateModifiedTimestamp();
 
    // Move in map
    profiles_[new_name] = profile;
    profiles_.erase(old_name);
 
    // Update active profile name if needed
    if (active_profile_name_ == old_name) {
        active_profile_name_ = new_name;
    }
 
    // Delete old file and save with new name
    String old_filepath = GetProfileFilePath(old_name);
    unlink(old_filepath.c_str());
    SaveProfile(new_name);
 
    LOG_INFO("ConfigManager", "Renamed profile: " + old_name + " -> " + new_name);
    return true;
}
 
std::shared_ptr<ParserProfile> ConfigManager::GetProfileInternal(const String &profile_name) const {
    auto it = profiles_.find(profile_name);
    if (it != profiles_.end()) {
        return it->second;
    }
    return nullptr;
}
 
bool ConfigManager::HasProfileInternal(const String &profile_name) const {
    return profiles_.find(profile_name) != profiles_.end();
}
 
std::shared_ptr<ParserProfile> ConfigManager::GetProfile(const String &profile_name) const {
    std::lock_guard<std::mutex> lock(mutex_);
    return GetProfileInternal(profile_name);
}
 
std::shared_ptr<ParserProfile> ConfigManager::GetActiveProfile() const { return GetProfile(active_profile_name_); }
 
std::vector<String> ConfigManager::GetProfileNames() const {
    std::lock_guard<std::mutex> lock(mutex_);
 
    std::vector<String> names;
    names.reserve(profiles_.size());
 
    for (const auto &pair : profiles_) {
        names.push_back(pair.first);
    }
 
    return names;
}
 
bool ConfigManager::HasProfile(const String &profile_name) const {
    std::lock_guard<std::mutex> lock(mutex_);
    return HasProfileInternal(profile_name);
}
 
bool ConfigManager::SetActiveProfile(const String &profile_name) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!HasProfileInternal(profile_name)) {
        LOG_ERROR("ConfigManager", "Cannot set active profile, profile not found: " + profile_name);
        return false;
    }
 
    active_profile_name_ = profile_name;
 
    // Save config file with new active profile
    SaveConfigFile();
 
    LOG_INFO("ConfigManager", "Active profile set to: " + profile_name);
    return true;
}
 
bool ConfigManager::ExportProfile(const String &profile_name, const String &filepath) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    auto profile = GetProfileInternal(profile_name);
    if (!profile) {
        LOG_ERROR("ConfigManager", "Profile not found for export: " + profile_name);
        return false;
    }
 
    return profile->SaveToFile(filepath);
}
 
bool ConfigManager::ImportProfile(const String &filepath, bool make_active) {
    ParserProfile temp_profile;
    if (!temp_profile.LoadFromFile(filepath)) {
        LOG_ERROR("ConfigManager", "Failed to import profile from: " + filepath);
        return false;
    }
 
    // Check for name conflicts and rename if necessary
    String profile_name = temp_profile.GetName();
    String original_name = profile_name;
    int counter = 1;
 
    while (HasProfile(profile_name)) {
        profile_name = original_name + " (" + std::to_string(counter++) + ")";
    }
 
    if (profile_name != original_name) {
        temp_profile.SetName(profile_name);
        LOG_INFO("ConfigManager", "Renamed imported profile to avoid conflict: " + profile_name);
    }
 
    auto profile = std::make_shared<ParserProfile>(temp_profile);
    if (!AddProfile(profile)) {
        return false;
    }
 
    if (make_active) {
        SetActiveProfile(profile_name);
    }
 
    return true;
}
 
void ConfigManager::ResetToDefaults() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    LOG_INFO("ConfigManager", "Resetting to default profiles");
 
    profiles_.clear();
    InitializeDefaultProfilesInternal(); // Use internal version to avoid re-locking
    SaveProfilesInternal();              // Use internal version to avoid re-locking
}
 
String ConfigManager::GetProfileFilePath(const String &profile_name) const {
    // Create a safe filename from profile name
    String safe_name = profile_name;
    for (char &c : safe_name) {
        if (!isalnum(c) && c != '_' && c != '-') {
            c = '_';
        }
    }
 
    return profiles_directory_ + "/" + safe_name + ".json";
}
 
bool ConfigManager::LoadConfigFile() {
    try {
        std::ifstream file(config_file_);
        if (!file.is_open()) {
            LOG_INFO("ConfigManager", "Config file not found, creating with defaults: " + config_file_);
            return SaveConfigFile(); // Create with current defaults
        }
 
        nlohmann::json json;
        file >> json;
        file.close();
 
        // Load active profile name
        if (json.contains("active_profile")) {
            String loaded_profile = json["active_profile"].get<String>();
 
            // Validate that the profile exists
            if (HasProfile(loaded_profile)) {
                active_profile_name_ = loaded_profile;
                LOG_INFO("ConfigManager", "Loaded active profile: " + active_profile_name_);
            } else {
                LOG_WARNING("ConfigManager",
                            "Config file references non-existent profile '" + loaded_profile + "', using default");
                active_profile_name_ = DEFAULT_PROFILE_NAME;
            }
        }
 
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("ConfigManager", "Failed to load config file: " + String(e.what()));
        return false;
    }
}
 
bool ConfigManager::SaveConfigFile() {
    try {
        nlohmann::json json;
 
        // Save active profile
        json["active_profile"] = active_profile_name_;
 
        // Add version for future compatibility
        json["version"] = "1.0";
 
        // Could add more settings here in the future:
        // json["theme"] = "dark";
        // json["last_opened_file"] = "...";
        // etc.
 
        std::ofstream file(config_file_);
        if (!file.is_open()) {
            LOG_ERROR("ConfigManager", "Failed to open config file for writing: " + config_file_);
            return false;
        }
 
        file << std::setw(4) << json << std::endl;
        file.close();
 
        LOG_INFO("ConfigManager", "Saved config file: " + config_file_);
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("ConfigManager", "Failed to save config file: " + String(e.what()));
        return false;
    }
}
 
} // namespace EmberCore