import { nanoid } from "nanoid";
import type {
  AssistantConversationItem,
  AssistantDebugPayload,
  AssistantRequirement,
  AnswerGroundingCheck,
  RequirementCoverageReport,
  UnifiedRetrievalResult
} from "../types/assistant";
import type { NormalizeResponsePayload, RouteHintSummary } from "../types/normalizer";
import type { InvestigationStateWithProblemUnits } from "../types/stage2ProblemUnits";
import type { AssistantDeepTurnInputBuilderArgs } from "./assistantDeepTurnInputBuilder";
import { buildAssistantDeepTurnPackagingInput } from "./assistantDeepTurnInputBuilder";
import { assembleAssistantDeepTurnPackaging } from "./assistantDeepTurnPackaging";
import type {
  AssistantAnalysisContextForContract,
  AssistantRuntimeAnalysisContextForPrePackaging
} from "./assistantDeepTurnPrePackagingContext";
import { buildAssistantDeepTurnPrePackagingContext } from "./assistantDeepTurnPrePackagingContext";
import {
  buildAssistantInvestigationStateSnapshot,
  persistAssistantInvestigationStateSnapshot
} from "./assistantInvestigationStateRuntimeAdapter";

type AssistantDeepTurnCompositionForPackaging = AssistantDeepTurnInputBuilderArgs["composition"] & {
  assistant_reply: string;
};

export interface AssistantDeepTurnPackagingRuntimeInput {
  featureInvestigationStateV1: 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: AssistantDeepTurnInputBuilderArgs["executionPlan"];
  requirementExtractionRequirements: AssistantRequirement[];
  coverageEvaluationRequirements: AssistantRequirement[];
  coverageReport: RequirementCoverageReport;
  groundingCheck: AnswerGroundingCheck;
  retrievalCalls: Array<Record<string, unknown>>;
  retrievalResultsRaw: unknown[];
  retrievalResults: UnifiedRetrievalResult[];
  questionTypeClass: string;
  companyAnchors: unknown;
  runtimeAnalysisContext: AssistantDeepTurnInputBuilderArgs["runtimeAnalysisContext"];
  businessScopeResolution: AssistantDeepTurnInputBuilderArgs["businessScopeResolution"];
  temporalGuard: Record<string, unknown>;
  polarityAudit: Record<string, unknown>;
  claimAnchorAudit: Record<string, unknown>;
  targetedEvidenceAudit: unknown;
  evidenceAdmissibilityGateAudit: unknown;
  rbpLiveRouteAudit: unknown | null;
  faLiveRouteAudit: unknown | null;
  groundedAnswerEligibilityGuard: Record<string, unknown>;
  followupStateUsage?: unknown;
  followupApplied: boolean;
  composition: AssistantDeepTurnCompositionForPackaging;
  featureContractsV11: boolean;
  featureAnswerPolicyV11: boolean;
  previousInvestigationState: InvestigationStateWithProblemUnits | null | undefined;
  addressRuntimeMetaForDeep:
    | {
        attempted?: boolean;
        applied?: boolean;
        reason?: string | null;
        provider?: string | null;
        fallbackRuleHit?: string | null;
        toolGateDecision?: string | null;
        toolGateReason?: string | null;
        predecomposeContract?: unknown;
        orchestrationContract?: unknown;
      }
    | null
    | undefined;
  extractDroppedIntentSegments: (normalizedPayload: NormalizeResponsePayload["normalized"]) => string[];
  buildDebugRoutes: (routeSummary: RouteHintSummary | null) => Array<Record<string, unknown>>;
  extractExecutionState: (normalizedPayload: NormalizeResponsePayload["normalized"]) => unknown;
  sanitizeReply: (value: string, fallback?: string) => string;
  persistInvestigationState: (sessionId: string, snapshot: InvestigationStateWithProblemUnits) => void;
  nowIso?: () => string;
  messageIdFactory?: () => string;
  buildPrePackagingContextFn?: typeof buildAssistantDeepTurnPrePackagingContext;
  buildInvestigationStateSnapshotFn?: typeof buildAssistantInvestigationStateSnapshot;
  persistInvestigationStateSnapshotFn?: typeof persistAssistantInvestigationStateSnapshot;
  buildDeepTurnPackagingInputFn?: typeof buildAssistantDeepTurnPackagingInput;
  assembleDeepTurnPackagingFn?: typeof assembleAssistantDeepTurnPackaging;
}

export interface AssistantDeepTurnPackagingRuntimeOutput {
  messageId: string;
  investigationStateSnapshot: InvestigationStateWithProblemUnits | null;
  droppedIntentSegments: string[];
  analysisContextForContract: AssistantAnalysisContextForContract | null;
  routesForDebug: Array<Record<string, unknown>>;
  resolvedExecutionState: unknown;
  safeAssistantReplyBase: string;
  safeAssistantReply: string;
  debug: AssistantDebugPayload;
  assistantItem: AssistantConversationItem;
  deepAnalysisLogDetails: Record<string, unknown>;
}

export function runAssistantDeepTurnPackagingRuntime(
  input: AssistantDeepTurnPackagingRuntimeInput
): AssistantDeepTurnPackagingRuntimeOutput {
  const buildPrePackagingContextSafe = input.buildPrePackagingContextFn ?? buildAssistantDeepTurnPrePackagingContext;
  const buildInvestigationStateSnapshotSafe =
    input.buildInvestigationStateSnapshotFn ?? buildAssistantInvestigationStateSnapshot;
  const persistInvestigationStateSnapshotSafe =
    input.persistInvestigationStateSnapshotFn ?? persistAssistantInvestigationStateSnapshot;
  const buildDeepTurnPackagingInputSafe = input.buildDeepTurnPackagingInputFn ?? buildAssistantDeepTurnPackagingInput;
  const assembleDeepTurnPackagingSafe = input.assembleDeepTurnPackagingFn ?? assembleAssistantDeepTurnPackaging;

  const deepTurnPrePackagingContext = buildPrePackagingContextSafe({
    normalizedPayload: input.normalized.normalized,
    routeSummary: input.routeSummary,
    runtimeAnalysisContext: input.runtimeAnalysisContext as AssistantRuntimeAnalysisContextForPrePackaging,
    assistantReply: input.composition.assistant_reply,
    extractDroppedIntentSegments: input.extractDroppedIntentSegments,
    buildDebugRoutes: input.buildDebugRoutes,
    extractExecutionState: input.extractExecutionState,
    sanitizeReply: input.sanitizeReply
  });
  const investigationStateSnapshot = buildInvestigationStateSnapshotSafe({
    featureEnabled: input.featureInvestigationStateV1,
    previousState: input.previousInvestigationState,
    timestamp: input.nowIso ? input.nowIso() : new Date().toISOString(),
    questionId: input.questionId,
    userMessage: input.userMessage,
    routeSummary: input.routeSummary,
    requirements: input.coverageEvaluationRequirements,
    coverageReport: input.coverageReport,
    retrievalResults: input.retrievalResults,
    replyType: input.composition.reply_type,
    followupApplied: input.followupApplied
  });
  persistInvestigationStateSnapshotSafe({
    featureEnabled: input.featureInvestigationStateV1,
    sessionId: input.sessionId,
    snapshot: investigationStateSnapshot,
    persist: input.persistInvestigationState
  });
  const messageId = input.messageIdFactory ? input.messageIdFactory() : `msg-${nanoid(10)}`;
  const deepTurnPackagingInput = buildDeepTurnPackagingInputSafe({
    sessionId: input.sessionId,
    messageId,
    userMessage: input.userMessage,
    normalized: input.normalized,
    normalizedQuestion: input.normalizedQuestion,
    routeSummary: input.routeSummary,
    droppedIntentSegments: deepTurnPrePackagingContext.droppedIntentSegments,
    analysisContextForContract: deepTurnPrePackagingContext.analysisContextForContract,
    executionPlan: input.executionPlan,
    requirementExtractionRequirements: input.requirementExtractionRequirements,
    coverageEvaluationRequirements: input.coverageEvaluationRequirements,
    coverageReport: input.coverageReport,
    groundingCheck: input.groundingCheck,
    retrievalCalls: input.retrievalCalls,
    retrievalResultsRaw: input.retrievalResultsRaw,
    retrievalResults: input.retrievalResults,
    routesForDebug: deepTurnPrePackagingContext.routesForDebug,
    resolvedExecutionState: deepTurnPrePackagingContext.resolvedExecutionState,
    questionTypeClass: input.questionTypeClass,
    companyAnchors: input.companyAnchors,
    runtimeAnalysisContext: input.runtimeAnalysisContext,
    businessScopeResolution: input.businessScopeResolution,
    temporalGuard: input.temporalGuard,
    polarityAudit: input.polarityAudit,
    claimAnchorAudit: input.claimAnchorAudit,
    targetedEvidenceAudit: input.targetedEvidenceAudit,
    evidenceAdmissibilityGateAudit: input.evidenceAdmissibilityGateAudit,
    rbpLiveRouteAudit: input.rbpLiveRouteAudit,
    faLiveRouteAudit: input.faLiveRouteAudit,
    groundedAnswerEligibilityGuard: input.groundedAnswerEligibilityGuard,
    followupStateUsage: input.followupStateUsage,
    composition: {
      reply_type: input.composition.reply_type,
      fallback_type: input.composition.fallback_type,
      answer_structure_v11: input.composition.answer_structure_v11,
      problem_centric_answer_applied: input.composition.problem_centric_answer_applied,
      problem_units_used_count: input.composition.problem_units_used_count,
      problem_answer_mode: input.composition.problem_answer_mode,
      problem_unit_ids_used: input.composition.problem_unit_ids_used
    },
    safeAssistantReplyBase: deepTurnPrePackagingContext.safeAssistantReplyBase,
    featureContractsV11: input.featureContractsV11,
    featureAnswerPolicyV11: input.featureAnswerPolicyV11,
    investigationStateSnapshot,
    addressRuntimeMetaForDeep: input.addressRuntimeMetaForDeep
  });
  const deepTurnPackaging = assembleDeepTurnPackagingSafe(deepTurnPackagingInput);

  return {
    messageId,
    investigationStateSnapshot,
    droppedIntentSegments: deepTurnPrePackagingContext.droppedIntentSegments,
    analysisContextForContract: deepTurnPrePackagingContext.analysisContextForContract,
    routesForDebug: deepTurnPrePackagingContext.routesForDebug,
    resolvedExecutionState: deepTurnPrePackagingContext.resolvedExecutionState,
    safeAssistantReplyBase: deepTurnPrePackagingContext.safeAssistantReplyBase,
    safeAssistantReply: deepTurnPackaging.deepAnswerArtifacts.safeAssistantReply,
    debug: deepTurnPackaging.debug,
    assistantItem: deepTurnPackaging.assistantItem,
    deepAnalysisLogDetails: deepTurnPackaging.deepAnalysisLogDetails
  };
}