import type { UnifiedRetrievalResult } from "../types/assistant";
import { applyTargetedEvidenceAcquisition } from "./assistantClaimBoundEvidence";
import {
  applyDomainPolarityGuardToRetrievalResults,
  applyEvidenceAdmissibilityGate,
  applyEligibilityToGroundingCheck,
  evaluateGroundedAnswerEligibility
} from "./assistantRuntimeGuards";

type GroundingCheckLike = {
  status: string;
  reasons: string[];
};

type ApplyEligibilityToGroundingCheckFn = <T extends GroundingCheckLike>(
  groundingCheck: T,
  eligibility: ReturnType<typeof evaluateGroundedAnswerEligibility>
) => T;

export interface AssistantDeepTurnRetrievalGuardPipelineInput {
  retrievalResults: UnifiedRetrievalResult[];
  domainPolarityGuardInitial: Parameters<typeof applyDomainPolarityGuardToRetrievalResults>[0]["guard"];
  claimAnchorAudit: Parameters<typeof applyTargetedEvidenceAcquisition>[0]["claimAudit"];
  temporalGuard: Parameters<typeof applyEvidenceAdmissibilityGate>[0]["temporal"];
  focusDomainForGuards: Parameters<typeof applyEvidenceAdmissibilityGate>[0]["focusDomainHint"];
  companyAnchors?: Parameters<typeof applyEvidenceAdmissibilityGate>[0]["companyAnchors"];
  userMessage: string;
  applyDomainPolarityGuardFn?: typeof applyDomainPolarityGuardToRetrievalResults;
  applyTargetedEvidenceFn?: typeof applyTargetedEvidenceAcquisition;
  applyEvidenceAdmissibilityGateFn?: typeof applyEvidenceAdmissibilityGate;
}

export interface AssistantDeepTurnRetrievalGuardPipelineOutput {
  retrievalResults: UnifiedRetrievalResult[];
  polarityGuardResult: ReturnType<typeof applyDomainPolarityGuardToRetrievalResults>;
  targetedEvidenceResult: ReturnType<typeof applyTargetedEvidenceAcquisition>;
  evidenceGateResult: ReturnType<typeof applyEvidenceAdmissibilityGate>;
}

export function applyAssistantDeepTurnRetrievalGuards(
  input: AssistantDeepTurnRetrievalGuardPipelineInput
): AssistantDeepTurnRetrievalGuardPipelineOutput {
  const applyDomainPolarityGuardSafe = input.applyDomainPolarityGuardFn ?? applyDomainPolarityGuardToRetrievalResults;
  const applyTargetedEvidenceSafe = input.applyTargetedEvidenceFn ?? applyTargetedEvidenceAcquisition;
  const applyEvidenceAdmissibilityGateSafe = input.applyEvidenceAdmissibilityGateFn ?? applyEvidenceAdmissibilityGate;

  const polarityGuardResult = applyDomainPolarityGuardSafe({
    retrievalResults: input.retrievalResults,
    guard: input.domainPolarityGuardInitial
  });
  const targetedEvidenceResult = applyTargetedEvidenceSafe({
    retrievalResults: polarityGuardResult.retrievalResults,
    claimAudit: input.claimAnchorAudit
  });
  const evidenceGateResult = applyEvidenceAdmissibilityGateSafe({
    retrievalResults: targetedEvidenceResult.retrievalResults,
    temporal: input.temporalGuard,
    focusDomainHint: input.focusDomainForGuards,
    polarity: polarityGuardResult.audit.polarity,
    companyAnchors: input.companyAnchors,
    userMessage: input.userMessage
  });

  return {
    retrievalResults: evidenceGateResult.retrievalResults,
    polarityGuardResult,
    targetedEvidenceResult,
    evidenceGateResult
  };
}

export interface AssistantDeepTurnGroundingEligibilityInput<T extends GroundingCheckLike> {
  groundingCheckBase: T;
  temporalGuard: Parameters<typeof evaluateGroundedAnswerEligibility>[0]["temporal"];
  polarityAudit: Parameters<typeof evaluateGroundedAnswerEligibility>[0]["polarity"];
  evidenceAudit: Parameters<typeof evaluateGroundedAnswerEligibility>[0]["evidence"];
  claimAnchorAudit?: Parameters<typeof evaluateGroundedAnswerEligibility>[0]["claimAnchors"];
  targetedEvidenceHitRate?: number | null;
  businessScopeResolved?: string[] | null;
  evaluateGroundedAnswerEligibilityFn?: typeof evaluateGroundedAnswerEligibility;
  applyEligibilityToGroundingCheckFn?: ApplyEligibilityToGroundingCheckFn;
}

export interface AssistantDeepTurnGroundingEligibilityOutput<T extends GroundingCheckLike> {
  groundedAnswerEligibilityGuard: ReturnType<typeof evaluateGroundedAnswerEligibility>;
  groundingCheck: T;
}

export function applyAssistantDeepTurnGroundingEligibility<T extends GroundingCheckLike>(
  input: AssistantDeepTurnGroundingEligibilityInput<T>
): AssistantDeepTurnGroundingEligibilityOutput<T> {
  const evaluateGroundedAnswerEligibilitySafe =
    input.evaluateGroundedAnswerEligibilityFn ?? evaluateGroundedAnswerEligibility;
  const applyEligibilityToGroundingCheckSafe =
    input.applyEligibilityToGroundingCheckFn ??
    ((groundingCheck, eligibility) => applyEligibilityToGroundingCheck(groundingCheck, eligibility));

  const groundedAnswerEligibilityGuard = evaluateGroundedAnswerEligibilitySafe({
    temporal: input.temporalGuard,
    polarity: input.polarityAudit,
    evidence: input.evidenceAudit,
    claimAnchors: input.claimAnchorAudit,
    targetedEvidenceHitRate: input.targetedEvidenceHitRate,
    businessScopeResolved: input.businessScopeResolved
  });
  const groundingCheck = applyEligibilityToGroundingCheckSafe(input.groundingCheckBase, groundedAnswerEligibilityGuard);

  return {
    groundedAnswerEligibilityGuard,
    groundingCheck
  };
}