#pragma once
// Step 1974: TaskitemLibraryAnnotator
// Runs OperationClassifier -> PerTaskLibrarySelector -> LibrarySymbolAdvisor per taskitem.
// Returns EnrichedExecutionContract. Unenriched if domain unknown or no library scores > 0.
// Always sets taskDescription on the returned contract.

#include "EnrichedExecutionContract.h"
#include "OperationClassifier.h"
#include "PerTaskLibrarySelector.h"
#include "LibrarySymbolAdvisor.h"
#include "LibraryCapabilityLedger.h"
#include "LibrarySymbolCatalog.h"
#include <string>
#include <vector>

namespace whetstone {

class TaskitemLibraryAnnotator {
public:
    EnrichedExecutionContract annotate(
            const std::string&              taskDescription,
            const std::vector<std::string>& availableLibraries,
            const LibraryCapabilityLedger&  ledger,
            const LibrarySymbolCatalog&     catalog) const {

        EnrichedExecutionContract ec;
        ec.taskDescription = taskDescription;

        // Step 1: classify the task description into an operation domain
        auto classifier = OperationClassifier::withDefaultTaxonomy();
        auto cr = classifier.classify(taskDescription);
        if (!cr.isKnown) {
            return ec; // domain unknown — unenriched
        }

        // Step 2: select best library for the domain
        PerTaskLibrarySelector selector;
        auto sel = selector.select(cr.domain, availableLibraries, ledger);
        if (!sel.hasSelection()) {
            return ec; // no library scores > 0 — unenriched
        }

        // Step 3: populate enriched fields from selection
        ec.selectedLibrary   = sel.selectedLibrary;
        ec.operationDomain   = sel.operationDomain;
        ec.capabilityScore   = sel.capabilityScore;
        ec.preferredAPIs     = sel.preferredAPIs;
        ec.avoidedLibraries  = sel.avoidedLibraries;
        ec.justification     = sel.justification;

        // Step 4: supplement preferredAPIs from symbol advisor if not already populated
        if (ec.preferredAPIs.empty()) {
            LibrarySymbolAdvisor advisor;
            auto syms = advisor.advise(sel.selectedLibrary, sel.operationDomain, catalog);
            for (const auto& s : syms) {
                ec.preferredAPIs.push_back(s.functionName);
            }
        }

        return ec;
    }
};

} // namespace whetstone