import { APIProviderRateLimitError, isProviderRateLimitError } from '#/llm-adapter/contract/errors';

import { linkAbortSignal, userCancellationReason } from '#/_base/utils/abort';
import type { IAgentScopeHandle } from '#/_base/di/scope';
import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
import type { ContextMessage, PromptOrigin } from '#/agent/contextMemory/types';
import { Error2, ErrorCodes, toKimiErrorPayload, type KimiErrorPayload } from '#/errors';
import {
  IAgentLoopService,
  isMaxStepsExceededError,
  type Turn,
  type TurnResult,
} from '#/agent/loop/loop';
import { agentContextOf } from '#/agent/scopeContext/scopeContext';
import { ISessionUsageService } from '#/session/usage/sessionUsage';

import type { AgentRunCompletion, AgentRunHandle, AgentRunRequest } from './subagent';

export const AGENT_RUN_PROMPT_ORIGIN: PromptOrigin = {
  kind: 'system_trigger',
  name: 'subagent',
};

const SUBAGENT_MAX_TOKENS_ERROR =
  'Subagent turn failed before completing its final summary: reason=max_tokens';

type CompletedTurnResult = Extract<TurnResult, { readonly type: 'completed' }>;

export interface RunAgentTurnOptions {
  readonly signal: AbortSignal;
  readonly onReady?: () => void;
}

export async function runAgentTurn(
  target: IAgentScopeHandle,
  request: AgentRunRequest,
  options: RunAgentTurnOptions,
): Promise<AgentRunHandle> {
  options.signal.throwIfAborted();
  const loop = target.accessor.get(IAgentLoopService);
  const { id } = request.kind === 'prompt'
    ? loop.submit({
        message: { role: 'user', content: [{ type: 'text', text: request.prompt }] },
        meta: { origin: AGENT_RUN_PROMPT_ORIGIN, tracked: true },
      })
    : loop.submit({
        message: { role: 'user', content: [] },
        meta: { origin: { kind: 'retry' } },
      });
  const turn = await loop.promptHandle(id)?.launched;
  if (turn === undefined) throw new Error2(ErrorCodes.INTERNAL, 'Agent turn could not be started');

  if (options.onReady !== undefined) {
    void turn.ready.then(() => options.onReady?.()).catch(() => {});
  }

  const completion = awaitRun(target, turn, options);
  return { agentId: target.id, turn, completion };
}

async function awaitRun(
  target: IAgentScopeHandle,
  turn: Turn,
  options: RunAgentTurnOptions,
): Promise<AgentRunCompletion> {
  const controller = new AbortController();
  const unlink = linkAbortSignal(options.signal, controller);
  const cancelTurn = (reason: unknown): void => {
    turn.cancel(reason);
  };
  try {
    const result = classifyTurnResult(await awaitTurn(turn, controller, cancelTurn));
    const summary = latestAssistantText(target.accessor.get(IAgentContextMemoryService).get());
    const stopReason = result.stopReason;
    if (summary.trim().length === 0) {
      throw new Error2(
        ErrorCodes.AGENT_NO_FINAL_MESSAGE,
        noFinalMessageError(stopReason),
        stopReason === undefined ? undefined : { details: { stopReason } },
      );
    }
    const usage = target.accessor.get(ISessionUsageService)?.status(agentContextOf(target)).total;
    return { summary, usage, stopReason };
  } finally {
    unlink();
    if (controller.signal.aborted) {
      cancelTurn(controller.signal.reason);
    }
  }
}

async function awaitTurn(
  turn: Turn,
  controller: AbortController,
  cancelTurn: (reason: unknown) => void,
): Promise<TurnResult> {
  const cancelOnAbort = (): void => {
    cancelTurn(controller.signal.reason);
  };
  controller.signal.addEventListener('abort', cancelOnAbort, { once: true });
  try {
    if (controller.signal.aborted) {
      cancelOnAbort();
    }
    const result = await turn.result;
    controller.signal.throwIfAborted();
    return result;
  } finally {
    controller.signal.removeEventListener('abort', cancelOnAbort);
  }
}

function classifyTurnResult(result: TurnResult): CompletedTurnResult {
  switch (result.type) {
    case 'completed':
      if (result.truncated) {
        throw new Error2(ErrorCodes.AGENT_MAX_TOKENS_EXCEEDED, SUBAGENT_MAX_TOKENS_ERROR);
      }
      return result;
    case 'failed': {
      const error = result.error;
      if (isProviderRateLimitError(error)) throw error;
      const payload = toKimiErrorPayload(error);
      if (payload.code === ErrorCodes.PROVIDER_RATE_LIMIT) {
        throw providerRateLimitErrorFromPayload(payload);
      }
      if (isMaxStepsExceededError(error)) {
        throw maxStepsErrorFromPayload(payload);
      }
      throw toRunError(error);
    }
    case 'cancelled':
      throw toRunError(result.reason ?? userCancellationReason());
  }
}

function noFinalMessageError(stopReason: string | undefined): string {
  const base = 'Subagent turn ended without a final message';
  return stopReason === undefined ? `${base}.` : `${base} (stop reason: ${stopReason}).`;
}

function maxStepsErrorFromPayload(payload: KimiErrorPayload): Error2 {
  const maxSteps = payload.details?.['maxSteps'];
  const cap = typeof maxSteps === 'number' ? ` (maxSteps=${String(maxSteps)})` : '';
  return new Error2(
    ErrorCodes.LOOP_MAX_STEPS_EXCEEDED,
    `Subagent hit the per-turn step cap${cap} before finishing its handoff.`,
    typeof maxSteps === 'number' ? { details: { maxSteps } } : undefined,
  );
}

function toRunError(error: unknown): Error {
  if (error instanceof Error) return error;
  if (error === undefined || error === null) return new Error('Agent turn failed');
  return new Error(stringifyRunError(error));
}

function stringifyRunError(value: unknown): string {
  if (typeof value === 'string') return value;
  return String(value);
}

function providerRateLimitErrorFromPayload(error: KimiErrorPayload): APIProviderRateLimitError {
  const requestId =
    typeof error.details?.['requestId'] === 'string' ? error.details['requestId'] : null;
  return new APIProviderRateLimitError(error.message, requestId);
}

function latestAssistantText(messages: readonly ContextMessage[]): string {
  for (let i = messages.length - 1; i >= 0; i--) {
    const message = messages[i]!;
    if (message.role !== 'assistant') continue;
    return contentText(message.content);
  }
  return '';
}

function contentText(content: ContextMessage['content']): string {
  if (typeof content === 'string') return content;
  return content
    .filter((part): part is Extract<(typeof content)[number], { type: 'text' }> => part.type === 'text')
    .map((part) => part.text)
    .join('');
}