dependency_resolver.hpp

#pragma once
 
#include "plugify/extension.hpp"
 
namespace plugify {
    struct DependencyIssue {
        UniqueId affectedExtension{ -1 };
        UniqueId involvedExtension{ -1 };
        std::string problem;
        std::string description;
        std::optional<std::vector<std::string>> suggestedFixes;
        bool isBlocking{ true };  // True if this issue prevents loading the extension
 
        // Generate detailed description with constraint info
        std::string GetDetailedDescription() const {
            std::string buffer;
            auto it = std::back_inserter(buffer);
 
            std::format_to(it, "{}: {}", problem, description);
 
            if (suggestedFixes && !suggestedFixes->empty()) {
                std::format_to(it, "\n  Suggestions:");
                for (const auto& fix : *suggestedFixes) {
                    std::format_to(it, "\n    - ", fix);
                }
            }
 
            return buffer;
        }
    };
 
    struct ResolutionReport {
        // Main report data
        std::unordered_map<UniqueId, std::vector<DependencyIssue>> issues;
 
        // Dependency graph
        std::unordered_map<UniqueId, std::vector<UniqueId>> dependencyGraph;  // For quick dep checks
        std::unordered_map<UniqueId, std::vector<UniqueId>> reverseDependencyGraph;  // For skipping
                                                                                // dependents
 
        // Load order
        std::vector<UniqueId> loadOrder;
        bool isLoadOrderValid{ false };  // False if circular deps prevent valid ordering
    };
 
    class IDependencyResolver {
    public:
        virtual ~IDependencyResolver() = default;
 
        virtual ResolutionReport Resolve(std::span<const Extension> extensions) = 0;
    };
}  // namespace plugify