/**
 * Comparisons & Synthesis agent — runtime entry point.
 */

import {
  type AgentResult,
  type HITLEscalation,
  LOW_CONFIDENCE_THRESHOLD,
  makeConfidence,
} from '../../../standards.js';
import type {
  ExecutionContext,
  FailureObject,
  Handoff,
  JobRequest,
  Lineage,
  UnresolvedIssue,
} from '../../../types.js';
import { nowIso } from '../../../types.js';
import {
  AGENT_NAME,
  AGENT_VERSION,
  comparisonsSynthesisContract,
} from './matrix.js';
import {
  type ComparisonsSynthesisInput,
  type ComparisonsSynthesisOutput,
  comparisonsSynthesisInputSchema,
} from './schema.js';
import {
  buildComparisons,
  MODEL_NAME,
  TOOL_COUNT,
  TOOL_NAMES,
  type ToolCallTrace,
} from './llm.js';

export { comparisonsSynthesisContract } from './matrix.js';
export type { ComparisonsSynthesisOutput } from './schema.js';

export interface ComparisonsSynthesisSideContext {
  readonly jobRequest: JobRequest;
  readonly upstreamLineage: Lineage;
}

function trace(ctx: ExecutionContext, standard: number, step: string, detail: string): void {
  ctx.trace.push({ agent: AGENT_NAME, standard, step, detail, at: nowIso() });
  // eslint-disable-next-line no-console
  console.log(`  [${AGENT_NAME}][Std ${standard}] ${step} — ${detail}`);
}

function failure(
  ctx: ExecutionContext,
  category: FailureObject['category'],
  reason: string,
  context: Record<string, unknown>,
  lineage: Lineage,
): FailureObject {
  return {
    agent: AGENT_NAME,
    agentVersion: AGENT_VERSION,
    category,
    reason,
    context,
    lineage,
    attempts: ctx.retries,
    recursionDepth: ctx.recursionDepth,
    occurredAt: nowIso(),
  };
}

export async function runComparisonsSynthesis(
  rawInput: unknown,
  side: ComparisonsSynthesisSideContext,
  ctx: ExecutionContext,
): Promise<AgentResult<ComparisonsSynthesisOutput>> {
  /* Step 1 (Std 2): receive-metrics. */
  const parsed = comparisonsSynthesisInputSchema.safeParse(rawInput);
  if (!parsed.success) {
    return {
      ok: false,
      escalations: [],
      failure: failure(
        ctx,
        'invalid-input',
        'Comparisons & Synthesis input failed schema validation.',
        { issues: parsed.error.issues },
        side.upstreamLineage,
      ),
    };
  }
  const metrics: ComparisonsSynthesisInput = parsed.data;
  trace(ctx, 2, comparisonsSynthesisContract.runbook[0]!.name,
    `received ${metrics.metrics.length} computed metric(s); ${metrics.methodologyGaps.length} upstream methodology gap(s)`);

  const unresolved: UnresolvedIssue[] = [];
  const escalations: HITLEscalation[] = [];

  if (metrics.metrics.length === 0) {
    return {
      ok: false,
      escalations,
      failure: failure(
        ctx,
        'analytical-table-incomplete',
        'No metrics were supplied — nothing to compare.',
        { input: metrics },
        side.upstreamLineage,
      ),
    };
  }

  trace(ctx, 5, comparisonsSynthesisContract.runbook[1]!.name,
    `delegating comparison construction to LLM (${MODEL_NAME}) with ${TOOL_COUNT} methodology tool(s) available: [${TOOL_NAMES.join(', ')}]`);

  const onToolCall = (t: ToolCallTrace): void => {
    const args = Object.entries(t.input).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(', ');
    ctx.trace.push({
      agent: AGENT_NAME,
      standard: 5,
      step: 'tool-call',
      detail: `${t.toolName}(${args}) → ${t.ok ? t.resultSummary : `ERROR: ${t.errorMessage ?? 'unknown'}`}`,
      at: t.at,
    });
    // eslint-disable-next-line no-console
    console.log(`  [${AGENT_NAME}][Std 5] tool-call — ${t.toolName}(${args}) → ${t.ok ? t.resultSummary : `ERROR: ${t.errorMessage}`}`);
  };

  const llm = await buildComparisons(metrics, side.jobRequest, onToolCall);
  if (!llm.ok) {
    const isKey = llm.failure.category === 'needs-api-key';
    escalations.push({
      agent: AGENT_NAME,
      reason: 'critical-validation-failure',
      failureContext: llm.failure.reason,
      lineage: side.upstreamLineage,
      validation: {
        status: 'review',
        confidence: makeConfidence(0, 'LLM unavailable or invalid response'),
        checks: [{ name: 'llm-available', passed: false, detail: llm.failure.hint }],
      },
      recommendedReviewer: isKey ? 'engineer' : 'domain-expert',
      raisedAt: nowIso(),
    });
    return {
      ok: false,
      escalations,
      failure: failure(
        ctx,
        isKey ? 'tool-unavailable' : 'comparability-failure',
        llm.failure.reason,
        { llmFailure: llm.failure },
        side.upstreamLineage,
      ),
    };
  }

  const out = llm.value.comparisons;
  trace(ctx, 7, comparisonsSynthesisContract.runbook[4]!.name,
    `${out.comparisons.length} comparison(s) produced; ${out.comparabilityFailures.length} comparability failure(s)`);

  /* Std 8: comparability failures → triggers. */
  for (const f of out.comparabilityFailures) {
    unresolved.push({
      category: 'comparability-failure',
      detail: `comparison "${f.comparisonId}" attempted="${f.attempted}": ${f.reason}`,
      blocking: false,
      context: { failure: f },
    });
  }

  /* Std 8: per-comparison comparabilityCheckStatus !== passed. */
  for (const c of out.comparisons) {
    if (c.comparabilityCheckStatus === 'failed') {
      unresolved.push({
        category: 'comparability-failure',
        detail: `comparison "${c.comparisonId}" comparability check failed; notes=${c.comparabilityNotes.join(' | ')}`,
        blocking: false,
      });
    }
  }

  const avgConf = out.comparisons.length === 0
    ? 0
    : out.comparisons.reduce((s, c) => s + c.confidence, 0) / out.comparisons.length;
  const blocking = unresolved.filter(u => u.blocking).length;
  const confidence = makeConfidence(
    Math.max(0, avgConf - 0.05 * Math.min(out.comparabilityFailures.length, 5)),
    `avg per-comparison confidence ${avgConf.toFixed(2)} with ${out.comparabilityFailures.length} comparability failure(s)`,
  );

  /* Step 9 (Std 11): handoff. */
  const lineage: Lineage = {
    sourceUrl: side.upstreamLineage.sourceUrl,
    capturedAt: nowIso(),
    effectiveAs: side.upstreamLineage.effectiveAs,
    agentVersion: AGENT_VERSION,
    upstream: Array.from(new Set([
      ...side.upstreamLineage.upstream,
      ...out.comparisons.flatMap(c => c.inputLineage),
    ])),
  };
  const validationStatus =
    blocking > 0 ? 'review' : confidence.value < LOW_CONFIDENCE_THRESHOLD ? 'flagged' : 'passed';

  const handoff: Handoff<ComparisonsSynthesisOutput> = {
    fromAgent: AGENT_NAME,
    fromAgentVersion: AGENT_VERSION,
    toAgent: 'intelligence.insight-synthesis',
    payload: out,
    metadata: {
      analysisId: ctx.analysisId,
      capabilities: comparisonsSynthesisContract.capabilities,
      appliedMethodologies: out.appliedMethodologies,
      comparabilityFailureCount: out.comparabilityFailures.length,
      toolCallCount: llm.value.toolCalls.length,
      toolCalls: llm.value.toolCalls.map(t => ({
        toolName: t.toolName,
        ok: t.ok,
        input: t.input,
        resultSummary: t.resultSummary,
        errorMessage: t.errorMessage,
        at: t.at,
      })),
    },
    confidence,
    validation: {
      status: validationStatus,
      checks: [
        { name: 'at-least-one-comparison', passed: out.comparisons.length > 0, detail: `${out.comparisons.length}` },
        { name: 'comparability-checks-recorded', passed: out.comparisons.every(c => !!c.comparabilityCheckStatus) },
      ],
    },
    unresolvedIssues: unresolved,
    lineage,
    timestamp: nowIso(),
  };
  trace(ctx, 11, comparisonsSynthesisContract.runbook[8]!.name,
    `handoff → ${handoff.toAgent} (validation=${validationStatus} confidence=${confidence.tier})`);

  return { ok: true, handoff, escalations };
}