import type {
  AnswerGroundingCheck,
  AssistantRequirement,
  RequirementCoverageReport,
  RbpLiveRouteAuditDebug,
  FaLiveRouteAuditDebug,
  GroundedAnswerEligibilityGuardDebug,
  UnifiedRetrievalResult
} from "../types/assistant";
import type { NormalizeResponsePayload, RouteHintSummary } from "../types/normalizer";
import type { AssistantRequirementExtractionResult, AssistantCoverageEvaluationResult } from "./assistantOrchestrationRuntimeAdapter";
import { runAssistantCoverageGroundingPipeline } from "./assistantOrchestrationRuntimeAdapter";
import type { AssistantDeepTurnGroundingEligibilityOutput } from "./assistantDeepTurnGuardRuntimeAdapter";
import {
  applyAssistantDeepTurnGroundingEligibility,
  type AssistantDeepTurnGroundingEligibilityInput
} from "./assistantDeepTurnGuardRuntimeAdapter";

export interface AssistantDeepTurnGroundingRuntimeInput {
  claimType: string;
  retrievalResults: UnifiedRetrievalResult[];
  rbpPlanAudit: RbpLiveRouteAuditDebug["plan_override"];
  faPlanAudit: FaLiveRouteAuditDebug["plan_override"];
  routeSummary: RouteHintSummary | null;
  normalizedPayload: NormalizeResponsePayload["normalized"] | null | undefined;
  userMessage: string;
  requirementExtraction: AssistantRequirementExtractionResult;
  extractRequirements: (
    routeSummary: RouteHintSummary | null,
    normalized: NormalizeResponsePayload["normalized"] | null | undefined,
    userMessage: string
  ) => AssistantRequirementExtractionResult;
  evaluateCoverage: (
    requirements: AssistantRequirement[],
    retrievalResults: UnifiedRetrievalResult[]
  ) => AssistantCoverageEvaluationResult;
  checkGrounding: (
    userMessage: string,
    requirements: AssistantRequirement[],
    coverage: RequirementCoverageReport,
    retrievalResults: UnifiedRetrievalResult[]
  ) => AnswerGroundingCheck;
  temporalGuard: AssistantDeepTurnGroundingEligibilityInput<AnswerGroundingCheck>["temporalGuard"];
  polarityAudit: AssistantDeepTurnGroundingEligibilityInput<AnswerGroundingCheck>["polarityAudit"];
  evidenceAudit: AssistantDeepTurnGroundingEligibilityInput<AnswerGroundingCheck>["evidenceAudit"];
  claimAnchorAudit: AssistantDeepTurnGroundingEligibilityInput<AnswerGroundingCheck>["claimAnchorAudit"];
  targetedEvidenceHitRate?: number | null;
  businessScopeResolved?: string[] | null;
  collectRbpLiveRouteAudit: (input: {
    claimType: string;
    retrievalResults: UnifiedRetrievalResult[];
    planAudit: RbpLiveRouteAuditDebug["plan_override"];
  }) => RbpLiveRouteAuditDebug | null;
  collectFaLiveRouteAudit: (input: {
    claimType: string;
    retrievalResults: UnifiedRetrievalResult[];
    planAudit: FaLiveRouteAuditDebug["plan_override"];
  }) => FaLiveRouteAuditDebug | null;
  runCoverageGroundingPipelineFn?: typeof runAssistantCoverageGroundingPipeline;
  applyGroundingEligibilityFn?: (
    input: AssistantDeepTurnGroundingEligibilityInput<AnswerGroundingCheck>
  ) => AssistantDeepTurnGroundingEligibilityOutput<AnswerGroundingCheck>;
}

export interface AssistantDeepTurnGroundingRuntimeOutput {
  rbpLiveRouteAudit: RbpLiveRouteAuditDebug | null;
  faLiveRouteAudit: FaLiveRouteAuditDebug | null;
  coverageEvaluation: AssistantCoverageEvaluationResult;
  groundingCheckBase: AnswerGroundingCheck;
  groundedAnswerEligibilityGuard: GroundedAnswerEligibilityGuardDebug;
  groundingCheck: AnswerGroundingCheck;
}

export function runAssistantDeepTurnGroundingRuntime(
  input: AssistantDeepTurnGroundingRuntimeInput
): AssistantDeepTurnGroundingRuntimeOutput {
  const runCoverageGroundingPipelineSafe = input.runCoverageGroundingPipelineFn ?? runAssistantCoverageGroundingPipeline;
  const applyGroundingEligibilityDefault: NonNullable<
    AssistantDeepTurnGroundingRuntimeInput["applyGroundingEligibilityFn"]
  > = (payload) => applyAssistantDeepTurnGroundingEligibility(payload);
  const applyGroundingEligibilitySafe =
    input.applyGroundingEligibilityFn ?? applyGroundingEligibilityDefault;

  const rbpLiveRouteAudit = input.collectRbpLiveRouteAudit({
    claimType: input.claimType,
    retrievalResults: input.retrievalResults,
    planAudit: input.rbpPlanAudit
  });
  const faLiveRouteAudit = input.collectFaLiveRouteAudit({
    claimType: input.claimType,
    retrievalResults: input.retrievalResults,
    planAudit: input.faPlanAudit
  });
  const orchestrationRuntime = runCoverageGroundingPipelineSafe({
    routeSummary: input.routeSummary,
    normalized: input.normalizedPayload,
    userMessage: input.userMessage,
    retrievalResults: input.retrievalResults,
    requirementExtraction: input.requirementExtraction,
    extractRequirements: input.extractRequirements,
    evaluateCoverage: input.evaluateCoverage,
    checkGrounding: input.checkGrounding
  });
  const coverageEvaluation = orchestrationRuntime.coverageEvaluation;
  const groundingCheckBase = orchestrationRuntime.groundingCheckBase;
  const groundingEligibilityRuntime = applyGroundingEligibilitySafe({
    groundingCheckBase,
    temporalGuard: input.temporalGuard,
    polarityAudit: input.polarityAudit,
    evidenceAudit: input.evidenceAudit,
    claimAnchorAudit: input.claimAnchorAudit,
    targetedEvidenceHitRate: input.targetedEvidenceHitRate,
    businessScopeResolved: input.businessScopeResolved
  });

  return {
    rbpLiveRouteAudit,
    faLiveRouteAudit,
    coverageEvaluation,
    groundingCheckBase,
    groundedAnswerEligibilityGuard: groundingEligibilityRuntime.groundedAnswerEligibilityGuard,
    groundingCheck: groundingEligibilityRuntime.groundingCheck
  };
}