import type {
  AssistantAddressRuntimeMetaForDeep,
  AssistantDebugPayload,
  AssistantDebugRouteRecord,
  AssistantExecutionStateRecord,
  AssistantMessageResponsePayload,
  FaLiveRouteAuditDebug,
  RbpLiveRouteAuditDebug
} from "../types/assistant";
import type { NormalizeResponsePayload, RouteHintSummary } from "../types/normalizer";
import type { InvestigationStateWithProblemUnits } from "../types/stage2ProblemUnits";
import {
  runAssistantDeepTurnPackagingRuntime,
  type AssistantDeepTurnPackagingRuntimeInput,
  type AssistantDeepTurnPackagingRuntimeOutput
} from "./assistantDeepTurnPackagingRuntimeAdapter";
import type { RunAssistantDeepTurnAnalysisRuntimeOutput } from "./assistantDeepTurnAnalysisRuntimeAdapter";
import type { AssistantExecutionPlanItem } from "./assistantQueryPlanning";
import {
  finalizeAssistantDeepTurn,
  type FinalizeAssistantDeepTurnInput
} from "./assistantDeepTurnFinalizeRuntimeAdapter";
import type { ClaimBoundAnchorAudit, TargetedEvidenceAcquisitionAudit } from "./assistantClaimBoundEvidence";
import type { CompanyAnchorSet } from "./companyAnchorResolver";
import type {
  DomainPolarityGuardAudit,
  EvidenceAdmissibilityAudit,
  GroundedAnswerEligibilityAudit,
  TemporalGuardAudit
} from "./assistantRuntimeGuards";
import type {
  AssistantRetrievalCallRecord,
  AssistantRetrievalRawResultRecord
} from "./assistantDeepTurnRetrievalRuntimeAdapter";

export interface RunAssistantDeepTurnResponseRuntimeInput {
  featureInvestigationStateV1: boolean;
  featureContractsV11: boolean;
  featureAnswerPolicyV11: boolean;
  sessionId: string;
  questionId: string;
  userMessage: string;
  normalized: {
    trace_id: string;
    prompt_version: string;
    schema_version: string;
    normalized: NormalizeResponsePayload["normalized"];
  };
  normalizedQuestion: string;
  routeSummary: RouteHintSummary | null;
  executionPlan: AssistantExecutionPlanItem[];
  requirementExtractionRequirements: AssistantDeepTurnPackagingRuntimeInput["requirementExtractionRequirements"];
  coverageEvaluationRequirements: AssistantDeepTurnPackagingRuntimeInput["coverageEvaluationRequirements"];
  coverageReport: AssistantDeepTurnPackagingRuntimeInput["coverageReport"];
  groundingCheck: AssistantDeepTurnPackagingRuntimeInput["groundingCheck"];
  retrievalCalls: AssistantRetrievalCallRecord[];
  retrievalResultsRaw: AssistantRetrievalRawResultRecord[];
  retrievalResults: AssistantDeepTurnPackagingRuntimeInput["retrievalResults"];
  questionTypeClass: AssistantDeepTurnPackagingRuntimeInput["questionTypeClass"];
  companyAnchors: CompanyAnchorSet | null;
  runtimeAnalysisContext: {
    active: boolean;
    as_of_date: string | null;
    period_from: string | null;
    period_to: string | null;
    source: string | null;
    snapshot_mode?: "auto" | "force_snapshot" | "force_live";
  };
  businessScopeResolution: RunAssistantDeepTurnAnalysisRuntimeOutput["businessScopeResolution"];
  temporalGuard: TemporalGuardAudit;
  polarityAudit: DomainPolarityGuardAudit;
  claimAnchorAudit: ClaimBoundAnchorAudit;
  targetedEvidenceAudit: TargetedEvidenceAcquisitionAudit;
  evidenceAdmissibilityGateAudit: EvidenceAdmissibilityAudit;
  rbpLiveRouteAudit: RbpLiveRouteAuditDebug | null;
  faLiveRouteAudit: FaLiveRouteAuditDebug | null;
  groundedAnswerEligibilityGuard: GroundedAnswerEligibilityAudit;
  followupStateUsage: AssistantDeepTurnPackagingRuntimeInput["followupStateUsage"];
  followupApplied: boolean;
  composition: AssistantDeepTurnPackagingRuntimeInput["composition"];
  previousInvestigationState: AssistantDeepTurnPackagingRuntimeInput["previousInvestigationState"];
  addressRuntimeMetaForDeep: AssistantDeepTurnPackagingRuntimeInput["addressRuntimeMetaForDeep"];
  extractDroppedIntentSegments: (normalizedPayload: NormalizeResponsePayload["normalized"]) => string[];
  buildDebugRoutes: (routeSummary: RouteHintSummary | null) => AssistantDebugRouteRecord[];
  extractExecutionState: (normalizedPayload: NormalizeResponsePayload["normalized"]) => AssistantExecutionStateRecord[];
  sanitizeReply: (value: string, fallback?: string) => string;
  persistInvestigationState: (sessionId: string, snapshot: InvestigationStateWithProblemUnits) => void;
  messageIdFactory: () => string;
  appendItem: FinalizeAssistantDeepTurnInput["appendItem"];
  getSession: FinalizeAssistantDeepTurnInput["getSession"];
  persistSession: FinalizeAssistantDeepTurnInput["persistSession"];
  cloneConversation: FinalizeAssistantDeepTurnInput["cloneConversation"];
  logEvent: FinalizeAssistantDeepTurnInput["logEvent"];
  runPackagingRuntime?: (
    input: AssistantDeepTurnPackagingRuntimeInput
  ) => AssistantDeepTurnPackagingRuntimeOutput;
  runFinalizeDeepTurn?: (input: FinalizeAssistantDeepTurnInput) => { response: AssistantMessageResponsePayload };
}

export interface RunAssistantDeepTurnResponseRuntimeOutput {
  response: AssistantMessageResponsePayload;
  debug: AssistantDebugPayload;
}

function toNullableString(value: string | null | undefined): string | null {
  if (typeof value !== "string") {
    return null;
  }
  const trimmed = value.trim();
  return trimmed.length > 0 ? trimmed : null;
}

function toStringArray(value: string[] | null | undefined): string[] {
  if (!Array.isArray(value)) {
    return [];
  }
  return value
    .map((item) => (typeof item === "string" ? item.trim() : ""))
    .filter((item) => item.length > 0);
}

function toSnapshotMode(value: string | null | undefined): "auto" | "force_snapshot" | "force_live" {
  return value === "force_snapshot" || value === "force_live" ? value : "auto";
}

function normalizeExecutionPlan(
  value: AssistantExecutionPlanItem[]
): AssistantDeepTurnPackagingRuntimeInput["executionPlan"] {
  if (!Array.isArray(value)) {
    return [];
  }
  return value.map((item, index) => ({
    fragment_id: toNullableString(item.fragment_id) ?? `fragment_${index + 1}`,
    requirement_ids: toStringArray(item.requirement_ids),
    route: toNullableString(item.route) ?? "unknown_route",
    should_execute: Boolean(item.should_execute),
    no_route_reason: toNullableString(item.no_route_reason ?? null),
    clarification_reason: toNullableString(item.clarification_reason ?? null)
  }));
}

function normalizeRuntimeAnalysisContext(
  value: RunAssistantDeepTurnResponseRuntimeInput["runtimeAnalysisContext"] | null | undefined
): AssistantDeepTurnPackagingRuntimeInput["runtimeAnalysisContext"] {
  const source = value;
  return {
    active: Boolean(source?.active),
    as_of_date: toNullableString(source?.as_of_date),
    period_from: toNullableString(source?.period_from),
    period_to: toNullableString(source?.period_to),
    source: toNullableString(source?.source),
    snapshot_mode: toSnapshotMode(source?.snapshot_mode)
  };
}

function normalizeBusinessScopeResolution(
  value: RunAssistantDeepTurnAnalysisRuntimeOutput["businessScopeResolution"] | null | undefined
): AssistantDeepTurnPackagingRuntimeInput["businessScopeResolution"] {
  const source = value;
  return {
    business_scope_raw: toStringArray(source?.business_scope_raw),
    business_scope_resolved: toStringArray(source?.business_scope_resolved),
    company_grounding_applied: Boolean(source?.company_grounding_applied),
    scope_resolution_reason: toStringArray(source?.scope_resolution_reason)
  };
}

function normalizeAddressRuntimeMetaForDeep(
  value: AssistantAddressRuntimeMetaForDeep | null | undefined
): AssistantAddressRuntimeMetaForDeep | null {
  const source = value;
  if (!source) {
    return null;
  }
  return {
    attempted: typeof source.attempted === "boolean" ? source.attempted : undefined,
    applied: typeof source.applied === "boolean" ? source.applied : undefined,
    reason: toNullableString(source.reason),
    provider: toNullableString(source.provider),
    fallbackRuleHit: toNullableString(source.fallbackRuleHit),
    toolGateDecision: toNullableString(source.toolGateDecision),
    toolGateReason: toNullableString(source.toolGateReason),
    predecomposeContract: source.predecomposeContract ?? null,
    orchestrationContract: source.orchestrationContract ?? null
  };
}

export function runAssistantDeepTurnResponseRuntime(
  input: RunAssistantDeepTurnResponseRuntimeInput
): RunAssistantDeepTurnResponseRuntimeOutput {
  const runPackagingRuntimeSafe = input.runPackagingRuntime ?? runAssistantDeepTurnPackagingRuntime;
  const runFinalizeDeepTurnSafe = input.runFinalizeDeepTurn ?? finalizeAssistantDeepTurn;

  const packagingRuntime = runPackagingRuntimeSafe({
    featureInvestigationStateV1: input.featureInvestigationStateV1,
    sessionId: input.sessionId,
    questionId: input.questionId,
    userMessage: input.userMessage,
    normalized: input.normalized,
    normalizedQuestion: input.normalizedQuestion,
    routeSummary: input.routeSummary,
    executionPlan: normalizeExecutionPlan(input.executionPlan),
    requirementExtractionRequirements: input.requirementExtractionRequirements,
    coverageEvaluationRequirements: input.coverageEvaluationRequirements,
    coverageReport: input.coverageReport,
    groundingCheck: input.groundingCheck,
    retrievalCalls: input.retrievalCalls,
    retrievalResultsRaw: input.retrievalResultsRaw,
    retrievalResults: input.retrievalResults,
    questionTypeClass: input.questionTypeClass,
    companyAnchors: input.companyAnchors,
    runtimeAnalysisContext: normalizeRuntimeAnalysisContext(input.runtimeAnalysisContext),
    businessScopeResolution: normalizeBusinessScopeResolution(input.businessScopeResolution),
    temporalGuard: input.temporalGuard,
    polarityAudit: input.polarityAudit,
    claimAnchorAudit: input.claimAnchorAudit,
    targetedEvidenceAudit: input.targetedEvidenceAudit,
    evidenceAdmissibilityGateAudit: input.evidenceAdmissibilityGateAudit,
    rbpLiveRouteAudit: input.rbpLiveRouteAudit ?? null,
    faLiveRouteAudit: input.faLiveRouteAudit ?? null,
    groundedAnswerEligibilityGuard: input.groundedAnswerEligibilityGuard,
    followupStateUsage: input.followupStateUsage,
    followupApplied: input.followupApplied,
    composition: input.composition,
    featureContractsV11: input.featureContractsV11,
    featureAnswerPolicyV11: input.featureAnswerPolicyV11,
    previousInvestigationState: input.previousInvestigationState ?? null,
    addressRuntimeMetaForDeep: normalizeAddressRuntimeMetaForDeep(input.addressRuntimeMetaForDeep),
    extractDroppedIntentSegments: input.extractDroppedIntentSegments,
    buildDebugRoutes: input.buildDebugRoutes,
    extractExecutionState: input.extractExecutionState,
    sanitizeReply: input.sanitizeReply,
    persistInvestigationState: input.persistInvestigationState,
    messageIdFactory: input.messageIdFactory
  });

  const finalization = runFinalizeDeepTurnSafe({
    sessionId: input.sessionId,
    assistantReply: packagingRuntime.safeAssistantReply,
    replyType: input.composition.reply_type,
    assistantItem: packagingRuntime.assistantItem,
    debug: packagingRuntime.debug,
    deepAnalysisLogDetails: packagingRuntime.deepAnalysisLogDetails,
    appendItem: input.appendItem,
    getSession: input.getSession,
    persistSession: input.persistSession,
    cloneConversation: input.cloneConversation,
    logEvent: input.logEvent
  });

  return {
    response: finalization.response,
    debug: packagingRuntime.debug
  };
}