export type OracleTaskPrepareStatus = "answered" | "prepared" | "refused" | "unavailable";
export type OracleTaskLifecycleState =
  | "NONE" | "INTENT" | "QUOTE_COMPARISON" | "SIMULATION" | "PREPARED"
  | "APPROVAL" | "SETTLEMENT" | "BALANCE_DELTA" | "POSITION";

/** Exact request body for POST /api/oracle/task/prepare. */
export interface OracleTaskPrepareRequest {
  schemaVersion: 1;
  prompt: string;
}

export interface OracleTaskCustody {
  mode: "prepare-only";
  requiresWalletSignature: true;
  backendSigner: false;
  signed: false;
  broadcast: false;
}

export interface OracleTaskEvidence {
  lifecycleState: OracleTaskLifecycleState;
  lifecycleHeadHash: string | null;
  prepareVerified: boolean;
}

export interface OracleTaskPreparedArtifact {
  command: string[];
  artifact: Record<string, unknown>;
  checks: {
    unsigned: boolean;
    destination: string;
    slippage: string;
  };
}

/** Exact result body produced for POST /api/oracle/task/prepare. */
export interface OracleTaskPrepareResult {
  schemaVersion: 1;
  taskId: string;
  status: OracleTaskPrepareStatus;
  text: string;
  custody: OracleTaskCustody;
  prepared: OracleTaskPreparedArtifact | null;
  evidence: OracleTaskEvidence;
}

export type OracleTaskEvent =
  | { schemaVersion: 1; taskId: string; type: "accepted"; request: { schemaVersion: 1 } }
  | { schemaVersion: 1; taskId: string; type: "delta"; text: string }
  | { schemaVersion: 1; taskId: string; type: "stage"; stage: "provider" | "tool"; step?: number; tool?: "oracle_cli" | "trade_lifecycle" | "unknown"; outcome?: "complete" | "refused"; reason?: string }
  | { schemaVersion: 1; taskId: string; type: "complete"; result: OracleTaskPrepareResult }
  | { schemaVersion: 1; taskId: string; type: "error"; code: string; message: string };

export interface OracleTaskToolCall {
  id?: string;
  name?: string;
  arguments?: string | Record<string, unknown>;
  args?: Record<string, unknown>;
  input?: Record<string, unknown>;
  function?: { name?: string; arguments?: string };
}

export interface OracleTaskProviderResponse {
  text?: string;
  content?: string;
  message?: { content?: string; tool_calls?: OracleTaskToolCall[] };
  toolCalls?: OracleTaskToolCall[];
  tool_calls?: OracleTaskToolCall[];
}

export interface OracleTaskProviderInput {
  schemaVersion: 1;
  taskId: string;
  messages: Array<Record<string, unknown>>;
  tools: typeof TASK_TOOLS;
  signal: AbortSignal;
  onDelta(delta: string): void;
}

export type OracleTaskProvider =
  | ((input: OracleTaskProviderInput) => Promise<OracleTaskProviderResponse>)
  | { complete(input: OracleTaskProviderInput): Promise<OracleTaskProviderResponse> }
  | { run(input: OracleTaskProviderInput): Promise<OracleTaskProviderResponse> };

export interface OracleTaskAdapterOptions {
  provider: OracleTaskProvider;
  runOracleCli?: (argv: string[], context: { signal: AbortSignal }) => Promise<unknown>;
  toolRunner?: (name: "oracle_cli", args: { argv: string[] }, context: { signal: AbortSignal }) => Promise<unknown>;
  onEvent?: (event: OracleTaskEvent) => void;
  signal?: AbortSignal;
  maxSteps?: number;
  taskIdFactory?: () => string;
  lifecycle?: {
    createTradeLifecycle?: (...args: any[]) => unknown;
    advanceTradeLifecycle?: (...args: any[]) => unknown;
    assertTradeLifecycle?: (...args: any[]) => unknown;
  };
  turnEvent?: (event: OracleTaskEvent) => void;
}

export interface OracleTaskTurnOptions {
  signal?: AbortSignal;
  onEvent?: (event: OracleTaskEvent) => void;
  taskId?: string;
}

export interface OracleTaskAdapter {
  prepare(request: OracleTaskPrepareRequest, options?: OracleTaskTurnOptions): Promise<OracleTaskPrepareResult>;
  stop(reason?: string): void;
  tools: typeof TASK_TOOLS;
}

export const TASK_SCHEMA_VERSION: 1;
export const TASK_RESULT_STATUSES: readonly OracleTaskPrepareStatus[];
export const TASK_CUSTODY_MARKERS: Readonly<OracleTaskCustody>;
export const TASK_PREPARE_REQUEST_SCHEMA: Readonly<Record<string, unknown>>;
export const TASK_TOOLS: readonly [
  Readonly<{ type: "function"; function: Readonly<{ name: "oracle_cli"; description: string; strict: true; parameters: Readonly<Record<string, unknown>> }> }>,
  Readonly<{ type: "function"; function: Readonly<{ name: "trade_lifecycle"; description: string; strict: true; parameters: Readonly<Record<string, unknown>> }> }>,
];

export function validateTaskPrepareRequest(request: unknown):
  | { ok: true; value: OracleTaskPrepareRequest }
  | { ok: false; error: string };
export function assertTaskPrepareRequest(request: unknown): OracleTaskPrepareRequest;
export function validateTaskOracleCommand(argv: unknown): { ok: true } | { ok: false; error: string };
export function createTaskAdapter(options: OracleTaskAdapterOptions): OracleTaskAdapter;
export const createOracleTaskAdapter: typeof createTaskAdapter;
export function prepareOracleTask(request: OracleTaskPrepareRequest, options: OracleTaskAdapterOptions): Promise<OracleTaskPrepareResult>;
export const prepareTask: typeof prepareOracleTask;