ProjectManager.cpp

Go to the documentation of this file.

#include "Parsers/ProjectManager.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <nlohmann/json.hpp>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
namespace EmberCore {
 
ProjectManager &ProjectManager::GetInstance() {
    static ProjectManager instance;
    return instance;
}
 
ProjectManager::ProjectManager() : active_project_(nullptr), project_modified_(false) {
 
    // Use resources/projects directory relative to the executable
    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);
        }
        projects_directory_ = exe_dir + "/resources/projects";
        config_file_ = exe_dir + "/resources/projects/project_manager.json";
    } else {
        // Fallback to relative path
        projects_directory_ = "resources/projects";
        config_file_ = "resources/projects/project_manager.json";
    }
 
    LOG_INFO("ProjectManager", "Projects directory: " + projects_directory_);
    LOG_INFO("ProjectManager", "Config file: " + config_file_);
 
    // Ensure directory exists and load config
    if (EnsureProjectsDirectoryExists()) {
        LoadConfig();
    }
}
 
bool ProjectManager::EnsureProjectsDirectoryExists() {
    // Create parent directories if needed (resources, then projects)
    String resources_dir = projects_directory_.substr(0, projects_directory_.find_last_of('/'));
 
    struct stat st;
    if (stat(resources_dir.c_str(), &st) != 0) {
        if (mkdir(resources_dir.c_str(), 0755) != 0) {
            LOG_ERROR("ProjectManager", "Failed to create resources directory: " + resources_dir);
            return false;
        }
    }
 
    // Create projects directory
    if (stat(projects_directory_.c_str(), &st) != 0) {
        if (mkdir(projects_directory_.c_str(), 0755) != 0) {
            LOG_ERROR("ProjectManager", "Failed to create projects directory: " + projects_directory_);
            return false;
        }
        LOG_INFO("ProjectManager", "Created projects directory: " + projects_directory_);
    }
 
    return true;
}
 
std::shared_ptr<BehaviorTreeProject> ProjectManager::CreateProject(const String &name, const String &description) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    auto project = std::make_shared<BehaviorTreeProject>(name, description);
 
    LOG_INFO("ProjectManager", "Created new project: " + name);
    return project;
}
 
bool ProjectManager::OpenProject(const String &filepath) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Check if file exists
    std::ifstream file(filepath);
    if (!file.good()) {
        LOG_ERROR("ProjectManager", "Project file not found: " + filepath);
        return false;
    }
    file.close();
 
    // Create new project and load from file
    auto project = std::make_shared<BehaviorTreeProject>();
    if (!project->LoadFromFile(filepath)) {
        LOG_ERROR("ProjectManager", "Failed to load project from: " + filepath);
        return false;
    }
 
    // Close any existing project
    if (active_project_) {
        // Note: In a real implementation, you might want to prompt for save
        active_project_ = nullptr;
    }
 
    active_project_ = project;
    active_project_path_ = filepath;
    project_modified_ = false;
 
    // Add to recent projects
    AddToRecentProjectsInternal(filepath);
    SaveConfig();
 
    LOG_INFO("ProjectManager", "Opened project: " + project->GetName() + " from " + filepath);
    return true;
}
 
bool ProjectManager::SaveProject() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!active_project_) {
        LOG_ERROR("ProjectManager", "No active project to save");
        return false;
    }
 
    if (active_project_path_.empty()) {
        LOG_ERROR("ProjectManager", "No project file path set");
        return false;
    }
 
    if (!active_project_->SaveToFile(active_project_path_)) {
        LOG_ERROR("ProjectManager", "Failed to save project to: " + active_project_path_);
        return false;
    }
 
    project_modified_ = false;
    LOG_INFO("ProjectManager", "Saved project: " + active_project_->GetName());
    return true;
}
 
bool ProjectManager::SaveProjectAs(const String &filepath) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!active_project_) {
        LOG_ERROR("ProjectManager", "No active project to save");
        return false;
    }
 
    if (!active_project_->SaveToFile(filepath)) {
        LOG_ERROR("ProjectManager", "Failed to save project to: " + filepath);
        return false;
    }
 
    active_project_path_ = filepath;
    project_modified_ = false;
 
    // Add to recent projects
    AddToRecentProjectsInternal(filepath);
    SaveConfig();
 
    LOG_INFO("ProjectManager", "Saved project as: " + filepath);
    return true;
}
 
bool ProjectManager::CloseProject() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!active_project_) {
        LOG_WARNING("ProjectManager", "No active project to close");
        return false;
    }
 
    String name = active_project_->GetName();
    active_project_ = nullptr;
    active_project_path_.clear();
    project_modified_ = false;
 
    LOG_INFO("ProjectManager", "Closed project: " + name);
    return true;
}
 
std::shared_ptr<BehaviorTreeProject> ProjectManager::GetActiveProject() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return active_project_;
}
 
bool ProjectManager::HasActiveProject() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return active_project_ != nullptr;
}
 
String ProjectManager::GetActiveProjectPath() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return active_project_path_;
}
 
bool ProjectManager::IsProjectModified() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return project_modified_;
}
 
void ProjectManager::SetProjectModified(bool modified) {
    std::lock_guard<std::mutex> lock(mutex_);
    project_modified_ = modified;
}
 
const std::vector<String> &ProjectManager::GetRecentProjects() const {
    // Note: Returning const reference, caller should hold lock for thread safety
    // In practice, this is typically called from UI thread which handles this
    return recent_projects_;
}
 
void ProjectManager::AddToRecentProjects(const String &filepath) {
    std::lock_guard<std::mutex> lock(mutex_);
    AddToRecentProjectsInternal(filepath);
    SaveConfig();
}
 
void ProjectManager::AddToRecentProjectsInternal(const String &filepath) {
    // Remove if already exists (will be re-added at front)
    RemoveFromRecentProjectsInternal(filepath);
 
    // Add to front
    recent_projects_.insert(recent_projects_.begin(), filepath);
 
    // Trim to max size
    if (recent_projects_.size() > MAX_RECENT_PROJECTS) {
        recent_projects_.resize(MAX_RECENT_PROJECTS);
    }
}
 
void ProjectManager::RemoveFromRecentProjects(const String &filepath) {
    std::lock_guard<std::mutex> lock(mutex_);
    RemoveFromRecentProjectsInternal(filepath);
    SaveConfig();
}
 
void ProjectManager::RemoveFromRecentProjectsInternal(const String &filepath) {
    auto it = std::find(recent_projects_.begin(), recent_projects_.end(), filepath);
    if (it != recent_projects_.end()) {
        recent_projects_.erase(it);
    }
}
 
void ProjectManager::ClearRecentProjects() {
    std::lock_guard<std::mutex> lock(mutex_);
    recent_projects_.clear();
    SaveConfig();
}
 
bool ProjectManager::RecentProjectExists(const String &filepath) const {
    std::ifstream file(filepath);
    return file.good();
}
 
void ProjectManager::ResetToDefaults() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    LOG_INFO("ProjectManager", "Resetting to defaults");
 
    active_project_ = nullptr;
    active_project_path_.clear();
    project_modified_ = false;
    recent_projects_.clear();
 
    SaveConfig();
}
 
bool ProjectManager::LoadConfig() {
    try {
        std::ifstream file(config_file_);
        if (!file.is_open()) {
            LOG_INFO("ProjectManager", "Config file not found, creating with defaults: " + config_file_);
            return SaveConfig();
        }
 
        nlohmann::json json;
        file >> json;
        file.close();
 
        // Load recent projects
        if (json.contains("recent_projects")) {
            recent_projects_ = json["recent_projects"].get<std::vector<String>>();
 
            // Validate that recent projects still exist
            std::vector<String> valid_projects;
            for (const auto &project : recent_projects_) {
                if (RecentProjectExists(project)) {
                    valid_projects.push_back(project);
                } else {
                    LOG_WARNING("ProjectManager", "Recent project no longer exists: " + project);
                }
            }
            recent_projects_ = valid_projects;
        }
 
        LOG_INFO("ProjectManager",
                 "Loaded config with " + std::to_string(recent_projects_.size()) + " recent project(s)");
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("ProjectManager", "Failed to load config file: " + String(e.what()));
        return false;
    }
}
 
bool ProjectManager::SaveConfig() {
    try {
        nlohmann::json json;
 
        // Save recent projects
        json["recent_projects"] = recent_projects_;
 
        // Add version for future compatibility
        json["version"] = "1.0";
 
        std::ofstream file(config_file_);
        if (!file.is_open()) {
            LOG_ERROR("ProjectManager", "Failed to open config file for writing: " + config_file_);
            return false;
        }
 
        file << std::setw(4) << json << std::endl;
        file.close();
 
        LOG_INFO("ProjectManager", "Saved config file: " + config_file_);
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("ProjectManager", "Failed to save config file: " + String(e.what()));
        return false;
    }
}
 
} // namespace EmberCore