import { resolveCompanyAnchors } from "./companyAnchorResolver";
import {
  applyPolarityHintToExecutionPlan,
  applyTemporalHintToExecutionPlan,
  type DomainPolarityGuardAudit,
  type TemporalGuardAudit,
  resolveDomainPolarityGuard,
  resolveTemporalGuard
} from "./assistantRuntimeGuards";
import { resolveClaimBoundAnchors } from "./assistantClaimBoundEvidence";
import type { RunAssistantDeepTurnAnalysisRuntimeInput } from "./assistantDeepTurnAnalysisRuntimeAdapter";
import type {
  BuildAssistantDeepTurnRuntimeContextInput,
  BuildAssistantDeepTurnRuntimeContextOutput
} from "./assistantDeepTurnContextRuntimeAdapter";
import type {
  BuildAssistantDeepTurnExecutionPlanInput,
  BuildAssistantDeepTurnExecutionPlanOutput
} from "./assistantDeepTurnPlanRuntimeAdapter";
import type {
  AssistantDeepTurnRetrievalExecutionInput,
  AssistantDeepTurnRetrievalExecutionOutput
} from "./assistantDeepTurnRetrievalRuntimeAdapter";
import type {
  AssistantDeepTurnRetrievalGuardPipelineInput,
  AssistantDeepTurnRetrievalGuardPipelineOutput
} from "./assistantDeepTurnGuardRuntimeAdapter";
import type {
  AssistantDeepTurnGroundingRuntimeInput,
  AssistantDeepTurnGroundingRuntimeOutput
} from "./assistantDeepTurnGroundingRuntimeAdapter";
import type {
  BuildAssistantDeepTurnCompositionInput,
  AssistantDeepTurnCompositionOutput
} from "./assistantDeepTurnCompositionRuntimeAdapter";
import type { RunAssistantDeepTurnAnalysisAttemptRuntimeInput } from "./assistantDeepTurnAnalysisAttemptRuntimeAdapter";
import type { CompanyAnchorSet } from "./companyAnchorResolver";

type ExecutionPlanRuntimeArgs = Parameters<RunAssistantDeepTurnAnalysisRuntimeInput["runExecutionPlanRuntime"]>[0];
type RetrievalRuntimeArgs = Parameters<RunAssistantDeepTurnAnalysisRuntimeInput["runRetrievalRuntime"]>[0];
type GuardRuntimeArgs = Parameters<RunAssistantDeepTurnAnalysisRuntimeInput["runGuardRuntime"]>[0];
type GroundingRuntimeArgs = Parameters<RunAssistantDeepTurnAnalysisRuntimeInput["runGroundingRuntime"]>[0];
type CompositionRuntimeArgs = Parameters<RunAssistantDeepTurnAnalysisRuntimeInput["runCompositionRuntime"]>[0];
type ClaimBoundPrimaryPeriod = Parameters<typeof resolveClaimBoundAnchors>[0]["primaryPeriod"];
const KNOWN_GUARD_DOMAINS = [
  "settlements_60_62",
  "vat_document_register_book",
  "month_close_costs_20_44",
  "fixed_asset_amortization"
] as const;

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 toCompanyAnchorSet(value: Partial<CompanyAnchorSet> | null | undefined): CompanyAnchorSet | null {
  if (!value || typeof value !== "object" || Array.isArray(value)) {
    return null;
  }
  const source: Partial<CompanyAnchorSet> = value;
  return {
    contract_numbers: toStringArray(source.contract_numbers),
    document_numbers: toStringArray(source.document_numbers),
    dates: toStringArray(source.dates),
    amounts: toStringArray(source.amounts),
    accounts: toStringArray(source.accounts),
    periods: toStringArray(source.periods),
    document_types: toStringArray(source.document_types),
    all: toStringArray(source.all)
  };
}

function toClaimBoundPrimaryPeriod(value: ClaimBoundPrimaryPeriod | null | undefined): ClaimBoundPrimaryPeriod {
  if (!value || typeof value !== "object") {
    return null;
  }
  const from = typeof value.from === "string" ? value.from.trim() : "";
  const to = typeof value.to === "string" ? value.to.trim() : "";
  const granularity = value.granularity === "day" || value.granularity === "month" ? value.granularity : null;
  if (!from || !to || !granularity) {
    return null;
  }
  return {
    from,
    to,
    granularity
  };
}

function normalizeFocusDomainForGuards(
  value: string | null | undefined
): AssistantDeepTurnRetrievalGuardPipelineInput["focusDomainForGuards"] {
  const normalized = typeof value === "string" ? value.trim() : "";
  if (!normalized) {
    return null;
  }
  if (KNOWN_GUARD_DOMAINS.includes(normalized as (typeof KNOWN_GUARD_DOMAINS)[number])) {
    return normalized as AssistantDeepTurnRetrievalGuardPipelineInput["focusDomainForGuards"];
  }
  return null;
}

const resolveTemporalGuardAdapter: BuildAssistantDeepTurnRuntimeContextInput["resolveTemporalGuard"] = (input) =>
  resolveTemporalGuard({
    userMessage: input.userMessage,
    normalized: input.normalized,
    companyAnchors: toCompanyAnchorSet(input.companyAnchors),
    analysisContext: input.analysisContext
  });

const resolveDomainPolarityGuardAdapter: BuildAssistantDeepTurnRuntimeContextInput["resolveDomainPolarityGuard"] = (
  input
) =>
  resolveDomainPolarityGuard({
    userMessage: input.userMessage,
    companyAnchors: toCompanyAnchorSet(input.companyAnchors),
    focusDomainHint: input.focusDomainHint
  });

const resolveClaimBoundAnchorsAdapter: BuildAssistantDeepTurnRuntimeContextInput["resolveClaimBoundAnchors"] = (
  input
) =>
  resolveClaimBoundAnchors({
    userMessage: input.userMessage,
    companyAnchors: toCompanyAnchorSet(input.companyAnchors),
    focusDomainHint: input.focusDomainHint,
    primaryPeriod: toClaimBoundPrimaryPeriod(input.primaryPeriod)
  });

const applyTemporalHintToExecutionPlanAdapter: BuildAssistantDeepTurnExecutionPlanInput["applyTemporalHintToExecutionPlan"] =
  (executionPlan, temporalGuard) =>
    applyTemporalHintToExecutionPlan(executionPlan, temporalGuard as TemporalGuardAudit);

const applyPolarityHintToExecutionPlanAdapter: BuildAssistantDeepTurnExecutionPlanInput["applyPolarityHintToExecutionPlan"] =
  (executionPlan, domainPolarityGuardInitial) =>
    applyPolarityHintToExecutionPlan(executionPlan, domainPolarityGuardInitial as DomainPolarityGuardAudit);

export interface BuildAssistantDeepTurnAnalysisRuntimeInputInput
  extends RunAssistantDeepTurnAnalysisAttemptRuntimeInput {
  runDeepTurnContextRuntimeSafe: (
    input: BuildAssistantDeepTurnRuntimeContextInput
  ) => BuildAssistantDeepTurnRuntimeContextOutput;
  runDeepTurnPlanRuntimeSafe: (
    input: BuildAssistantDeepTurnExecutionPlanInput
  ) => BuildAssistantDeepTurnExecutionPlanOutput;
  runDeepTurnRetrievalRuntimeSafe: (
    input: AssistantDeepTurnRetrievalExecutionInput
  ) => Promise<AssistantDeepTurnRetrievalExecutionOutput>;
  runDeepTurnGuardRuntimeSafe: (
    input: AssistantDeepTurnRetrievalGuardPipelineInput
  ) => AssistantDeepTurnRetrievalGuardPipelineOutput;
  runDeepTurnGroundingRuntimeSafe: (
    input: AssistantDeepTurnGroundingRuntimeInput
  ) => AssistantDeepTurnGroundingRuntimeOutput;
  runDeepTurnCompositionRuntimeSafe: (
    input: BuildAssistantDeepTurnCompositionInput
  ) => AssistantDeepTurnCompositionOutput;
}

export function buildAssistantDeepTurnContextRuntimeInput(
  input: BuildAssistantDeepTurnAnalysisRuntimeInputInput
): BuildAssistantDeepTurnRuntimeContextInput {
  return {
    userMessage: input.userMessage,
    normalizedPayload: input.normalizedPayload,
    routeSummary: input.routeSummary,
    runtimeAnalysisContext: input.runtimeAnalysisContext,
    followupUsage: input.followupUsage,
    resolveCompanyAnchors,
    resolveBusinessScopeAlignment: input.resolveBusinessScopeAlignment,
    inferP0DomainFromMessage: input.inferP0DomainFromMessage,
    resolveTemporalGuard: resolveTemporalGuardAdapter,
    resolveDomainPolarityGuard: resolveDomainPolarityGuardAdapter,
    resolveClaimBoundAnchors: resolveClaimBoundAnchorsAdapter,
    resolveBusinessScopeFromLiveContext: input.resolveBusinessScopeFromLiveContext
  };
}

export function buildAssistantDeepTurnExecutionPlanRuntimeInput(
  input: BuildAssistantDeepTurnAnalysisRuntimeInputInput,
  runtime: ExecutionPlanRuntimeArgs
): BuildAssistantDeepTurnExecutionPlanInput {
  return {
    routeSummary: runtime.resolvedRouteSummary,
    normalizedPayload: input.normalizedPayload,
    userMessage: input.userMessage,
    claimType: runtime.claimAnchorAudit.claim_type,
    temporalGuard: runtime.temporalGuard,
    domainPolarityGuardInitial: runtime.domainPolarityGuardInitial,
    extractRequirements: input.extractRequirements,
    toExecutionPlan: input.toExecutionPlan,
    enforceRbpLiveRoutePlan: input.enforceRbpLiveRoutePlan,
    enforceFaLiveRoutePlan: input.enforceFaLiveRoutePlan,
    applyTemporalHintToExecutionPlan: applyTemporalHintToExecutionPlanAdapter,
    applyPolarityHintToExecutionPlan: applyPolarityHintToExecutionPlanAdapter
  };
}

export function buildAssistantDeepTurnRetrievalRuntimeInput(
  input: BuildAssistantDeepTurnAnalysisRuntimeInputInput,
  runtime: RetrievalRuntimeArgs
): AssistantDeepTurnRetrievalExecutionInput {
  return {
    executionPlan: runtime.executionPlan,
    liveTemporalHint: runtime.liveTemporalHint,
    executeRouteRuntime: input.executeRouteRuntime,
    mapNoRouteReason: input.mapNoRouteReason,
    buildSkippedResult: input.buildSkippedResult
  };
}

export function buildAssistantDeepTurnGuardRuntimeInput(
  runtime: GuardRuntimeArgs
): AssistantDeepTurnRetrievalGuardPipelineInput {
  return {
    retrievalResults: runtime.retrievalResults,
    domainPolarityGuardInitial: runtime.domainPolarityGuardInitial,
    claimAnchorAudit: runtime.claimAnchorAudit,
    temporalGuard: runtime.temporalGuard,
    focusDomainForGuards: normalizeFocusDomainForGuards(runtime.focusDomainForGuards),
    companyAnchors: toCompanyAnchorSet(runtime.companyAnchors),
    userMessage: runtime.userMessage
  };
}

export function buildAssistantDeepTurnGroundingRuntimeInput(
  input: BuildAssistantDeepTurnAnalysisRuntimeInputInput,
  runtime: GroundingRuntimeArgs
): AssistantDeepTurnGroundingRuntimeInput {
  return {
    claimType: runtime.claimType,
    retrievalResults: runtime.retrievalResults,
    rbpPlanAudit: runtime.rbpPlanAudit,
    faPlanAudit: runtime.faPlanAudit,
    routeSummary: runtime.routeSummary,
    normalizedPayload: input.normalizedPayload,
    userMessage: input.userMessage,
    requirementExtraction: runtime.requirementExtraction,
    extractRequirements: (routeSummary, normalized, userMessage) =>
      input.extractRequirements(routeSummary, normalized ?? null, userMessage),
    evaluateCoverage: input.evaluateCoverage,
    checkGrounding: input.checkGrounding,
    temporalGuard: runtime.temporalGuard,
    polarityAudit: runtime.polarityAudit,
    evidenceAudit: runtime.evidenceAudit,
    claimAnchorAudit: runtime.claimAnchorAudit,
    targetedEvidenceHitRate: runtime.targetedEvidenceHitRate,
    businessScopeResolved: runtime.businessScopeResolved,
    collectRbpLiveRouteAudit: input.collectRbpLiveRouteAudit,
    collectFaLiveRouteAudit: input.collectFaLiveRouteAudit
  };
}

export function buildAssistantDeepTurnCompositionRuntimeInput(
  input: BuildAssistantDeepTurnAnalysisRuntimeInputInput,
  runtime: CompositionRuntimeArgs
): BuildAssistantDeepTurnCompositionInput {
  return {
    userMessage: input.userMessage,
    routeSummary: runtime.resolvedRouteSummary,
    retrievalResults: runtime.retrievalResults,
    requirements: runtime.requirements,
    coverageReport: runtime.coverageReport,
    groundingCheck: runtime.groundingCheck,
    followupUsage: input.followupUsage,
    investigationState: input.investigationState,
    companyAnchors: runtime.companyAnchors,
    normalizedPayload: input.normalizedPayload,
    featureAnswerPolicyV11: input.featureAnswerPolicyV11,
    featureProblemCentricAnswerV1: input.featureProblemCentricAnswerV1,
    featureLifecycleAnswerV1: input.featureLifecycleAnswerV1,
    hasExplicitPeriodAnchor: input.hasExplicitPeriodAnchor
  };
}

export function buildAssistantDeepTurnAnalysisRuntimeInput(
  input: BuildAssistantDeepTurnAnalysisRuntimeInputInput
): RunAssistantDeepTurnAnalysisRuntimeInput {
  return {
    userMessage: input.userMessage,
    runContextRuntime: () => {
      const runtime = input.runDeepTurnContextRuntimeSafe(buildAssistantDeepTurnContextRuntimeInput(input));
      return {
        companyAnchors: toCompanyAnchorSet(runtime.companyAnchors),
        focusDomainForGuards: normalizeFocusDomainForGuards(runtime.focusDomainForGuards),
        temporalGuard: runtime.temporalGuard,
        domainPolarityGuardInitial: runtime.domainPolarityGuardInitial,
        claimAnchorAudit: runtime.claimAnchorAudit,
        businessScopeResolution: runtime.businessScopeResolution,
        resolvedRouteSummary: runtime.resolvedRouteSummary,
        liveTemporalHint: runtime.liveTemporalHint
      };
    },
    runExecutionPlanRuntime: (runtime) => {
      const output = input.runDeepTurnPlanRuntimeSafe(
        buildAssistantDeepTurnExecutionPlanRuntimeInput(input, runtime)
      );
      return {
        requirementExtraction: output.requirementExtraction,
        executionPlan: output.executionPlan,
        rbpRoutePlanEnforcement: output.rbpRoutePlanEnforcement,
        faRoutePlanEnforcement: output.faRoutePlanEnforcement
      };
    },
    runRetrievalRuntime: (runtime) =>
      input.runDeepTurnRetrievalRuntimeSafe(buildAssistantDeepTurnRetrievalRuntimeInput(input, runtime)),
    runGuardRuntime: (runtime) =>
      input.runDeepTurnGuardRuntimeSafe(buildAssistantDeepTurnGuardRuntimeInput(runtime)),
    runGroundingRuntime: (runtime) =>
      input.runDeepTurnGroundingRuntimeSafe(buildAssistantDeepTurnGroundingRuntimeInput(input, runtime)),
    runCompositionRuntime: (runtime) =>
      input.runDeepTurnCompositionRuntimeSafe(buildAssistantDeepTurnCompositionRuntimeInput(input, runtime))
  };
}