"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveAssistantRuntimeContractShadow = resolveAssistantRuntimeContractShadow;
exports.buildAssistantRuntimeContractShadowFields = buildAssistantRuntimeContractShadowFields;
exports.attachAssistantRuntimeContractShadow = attachAssistantRuntimeContractShadow;
const assistantRuntimeContracts_1 = require("../types/assistantRuntimeContracts");
const assistantRuntimeContractRegistry_1 = require("./assistantRuntimeContractRegistry");
function toRecordObject(value) {
    if (!value || typeof value !== "object" || Array.isArray(value)) {
        return null;
    }
    return value;
}
function toNonEmptyString(value) {
    if (value === null || value === undefined) {
        return null;
    }
    const text = String(value).trim();
    return text.length > 0 ? text : null;
}
function isAddressIntent(value) {
    return Boolean(value) && value !== "unknown";
}
function asNumber(value) {
    if (typeof value === "number" && Number.isFinite(value)) {
        return value;
    }
    if (typeof value === "string" && value.trim().length > 0) {
        const parsed = Number(value);
        return Number.isFinite(parsed) ? parsed : null;
    }
    return null;
}
function runtimeMetaFrom(input) {
    const direct = toRecordObject(input.addressRuntimeMeta);
    if (direct) {
        return direct;
    }
    const debug = toRecordObject(input.addressDebug);
    if (!debug) {
        return null;
    }
    const dialogContinuationContract = toRecordObject(debug.dialog_continuation_contract_v2);
    const orchestrationContract = toRecordObject(debug.orchestration_contract_v1);
    if (!dialogContinuationContract && !orchestrationContract) {
        return null;
    }
    return {
        dialogContinuationContract,
        orchestrationContract,
        toolGateDecision: debug.tool_gate_decision,
        toolGateReason: debug.tool_gate_reason
    };
}
function resolveCapabilityContractId(debug, meta) {
    const explicitCapabilityId = toNonEmptyString(debug.capability_id);
    if (explicitCapabilityId && (0, assistantRuntimeContractRegistry_1.getAssistantCapabilityContract)(explicitCapabilityId)) {
        return {
            capabilityId: explicitCapabilityId,
            reasons: ["debug_capability_id_matched_contract"]
        };
    }
    const orchestrationContract = toRecordObject(meta?.orchestrationContract) ?? toRecordObject(debug.orchestration_contract_v1);
    const intent = toNonEmptyString(debug.detected_intent) ??
        toNonEmptyString(orchestrationContract?.address_intent);
    if (isAddressIntent(intent)) {
        const contract = (0, assistantRuntimeContractRegistry_1.getAssistantCapabilityContractByIntent)(intent);
        if (contract) {
            return {
                capabilityId: contract.capability_id,
                reasons: ["intent_matched_capability_contract"]
            };
        }
    }
    return {
        capabilityId: null,
        reasons: explicitCapabilityId ? ["debug_capability_id_has_no_contract"] : ["capability_contract_not_resolved"]
    };
}
function isSelectedObjectCapability(capabilityId) {
    if (!capabilityId) {
        return false;
    }
    const contract = (0, assistantRuntimeContractRegistry_1.getAssistantCapabilityContract)(capabilityId);
    return Boolean(contract?.requires_focus_object);
}
function resolveTransitionId(input) {
    const dialogContinuationContract = toRecordObject(input.meta?.dialogContinuationContract) ??
        toRecordObject(input.debug.dialog_continuation_contract_v2);
    const orchestrationContract = toRecordObject(input.meta?.orchestrationContract) ??
        toRecordObject(input.debug.orchestration_contract_v1);
    const finalDecision = toRecordObject(orchestrationContract?.final_decision);
    const hardMetaMode = toNonEmptyString(orchestrationContract?.hard_meta_mode);
    const toolGateReason = toNonEmptyString(input.meta?.toolGateReason) ??
        toNonEmptyString(input.debug.tool_gate_reason) ??
        toNonEmptyString(finalDecision?.tool_gate_reason);
    const continuationDecision = toNonEmptyString(dialogContinuationContract?.decision);
    const targetIntent = toNonEmptyString(dialogContinuationContract?.target_intent) ??
        toNonEmptyString(input.debug.detected_intent);
    const currentFrameKind = toNonEmptyString(toRecordObject(input.debug.address_root_frame_context)?.current_frame_kind);
    const missingFilters = Array.isArray(input.debug.missing_required_filters) ? input.debug.missing_required_filters.length : 0;
    if (input.groundingStatus === "route_mismatch_blocked" ||
        input.debug.route_expectation_status === "mismatch" ||
        input.debug.limited_reason_category === "execution_error") {
        return { transitionId: "T10", reasons: ["blocked_or_route_mismatch_debug_status"] };
    }
    if (missingFilters > 0 || input.debug.limited_reason_category === "missing_anchor") {
        return { transitionId: "T7", reasons: ["missing_anchor_or_filter_requires_clarification"] };
    }
    if (toolGateReason === "memory_recap_followup_detected") {
        return { transitionId: "T9", reasons: ["memory_recap_tool_gate_reason"] };
    }
    if (hardMetaMode === "capability" || toolGateReason === "assistant_capability_query_detected") {
        return { transitionId: "T8", reasons: ["capability_meta_followup_tool_gate_reason"] };
    }
    if (isSelectedObjectCapability(input.capabilityId)) {
        if (continuationDecision === "continue_previous") {
            return { transitionId: "T4", reasons: ["selected_object_capability_continue_previous"] };
        }
        if (continuationDecision === "new_topic") {
            return { transitionId: "T3", reasons: ["selected_object_capability_explicit_entry"] };
        }
        return { transitionId: "T5", reasons: ["selected_object_capability_without_explicit_continuation_decision"] };
    }
    if (currentFrameKind === "inventory_drilldown" && targetIntent && targetIntent !== "inventory_on_hand_as_of_date") {
        return { transitionId: "T6", reasons: ["root_context_reused_after_drilldown_context"] };
    }
    if (continuationDecision === "continue_previous") {
        return { transitionId: "T2", reasons: ["root_followup_continue_previous"] };
    }
    if (input.capabilityId) {
        return { transitionId: "T1", reasons: ["capability_contract_root_or_new_entry"] };
    }
    return { transitionId: null, reasons: ["transition_contract_not_resolved"] };
}
function resolveTruthGateStatus(input) {
    if (input.groundingStatus === "route_mismatch_blocked" || input.debug.route_expectation_status === "mismatch") {
        return "blocked_route_expectation_failure";
    }
    if (input.debug.limited_reason_category === "execution_error") {
        return "blocked_execution_error";
    }
    if (input.debug.limited_reason_category === "missing_anchor") {
        return "blocked_missing_anchor";
    }
    if (input.debug.temporal_guard_outcome === "ambiguous_limited" ||
        input.debug.temporal_alignment_status === "conflicting") {
        return "limited_temporal_or_contextual";
    }
    if (input.debug.limited_reason_category || input.groundingStatus === "partial") {
        return "partial_supported";
    }
    const rowsMatched = asNumber(input.debug.rows_matched);
    const routeExpectationStatus = toNonEmptyString(input.debug.route_expectation_status);
    if ((input.groundingStatus === "grounded" || (rowsMatched !== null && rowsMatched > 0)) && (!routeExpectationStatus || routeExpectationStatus === "matched")) {
        return "full_confirmed";
    }
    return "unknown";
}
function carryoverEligibilityFor(transitionId, truthGateStatus) {
    if (truthGateStatus.startsWith("blocked")) {
        return "none";
    }
    if (transitionId === "T3" || transitionId === "T4" || transitionId === "T5") {
        return "object_only";
    }
    if (transitionId === "T8" || transitionId === "T9") {
        return "meta_only";
    }
    if (transitionId === "T1" || transitionId === "T2" || transitionId === "T6") {
        return "root_only";
    }
    if (transitionId === "T7") {
        return "full";
    }
    return "none";
}
function resolveAssistantRuntimeContractShadow(input) {
    const debug = toRecordObject(input.addressDebug) ?? {};
    const meta = runtimeMetaFrom(input);
    const groundingStatus = toNonEmptyString(input.groundingStatus) ??
        toNonEmptyString(toRecordObject(debug.answer_grounding_check)?.status);
    const capability = resolveCapabilityContractId(debug, meta);
    const transition = resolveTransitionId({
        debug,
        meta,
        capabilityId: capability.capabilityId,
        groundingStatus
    });
    const transitionContract = transition.transitionId ? (0, assistantRuntimeContractRegistry_1.getAssistantTransitionContract)(transition.transitionId) : null;
    const truthGateStatus = resolveTruthGateStatus({ debug, groundingStatus });
    return {
        schema_version: assistantRuntimeContracts_1.ASSISTANT_RUNTIME_CONTRACTS_SCHEMA_VERSION,
        transition_contract_id: transition.transitionId,
        transition_contract_title: transitionContract?.title ?? null,
        transition_contract_reason: transition.reasons,
        capability_contract_id: capability.capabilityId,
        capability_contract_reason: capability.reasons,
        truth_gate_contract_status: truthGateStatus,
        carryover_eligibility: carryoverEligibilityFor(transition.transitionId, truthGateStatus)
    };
}
function buildAssistantRuntimeContractShadowFields(input) {
    const decision = resolveAssistantRuntimeContractShadow(input);
    return {
        assistant_runtime_contract_v1: decision,
        transition_contract_id: decision.transition_contract_id,
        capability_contract_id: decision.capability_contract_id,
        truth_gate_contract_status: decision.truth_gate_contract_status
    };
}
function attachAssistantRuntimeContractShadow(debugPayload, input) {
    return {
        ...debugPayload,
        ...buildAssistantRuntimeContractShadowFields({
            ...input,
            addressDebug: debugPayload
        })
    };
}