import { defineDebug } from "./pi-ext-debug.ts";

const events = [
	"index.module",
	"index.extension.start",
	"index.oauth.model",
	"index.oauth.kind",
	"index.oauth.resolved",
	"index.oauth.fableWarning",
	"index.currentCwd",
	"index.currentSession",
	"index.promptDriftWarning",
	"index.register.unchanged",
	"index.register",
	"index.streamSimple",
	"index.session_start",
	"index.turn_end",
	"index.session_before_switch",
	"index.session_before_fork",
	"index.session_before_compact",
	"index.session_shutdown",
	"bridge.settle.truncated",
	"bridge.create",
	"bridge.listTools",
	"bridge.callTool.start",
	"bridge.callTool.park",
	"bridge.allow",
	"bridge.toolNames",
	"bridge.replaceTools",
	"bridge.hasSchemaChange",
	"bridge.pendingIds",
	"bridge.waitForPending.start",
	"bridge.waitForPending.end",
	"bridge.settle.start",
	"bridge.settle.end",
	"bridge.close.start",
	"bridge.close.end",
	"bridge.errorResult",
	"subscriptionPrompt.rewrite",
	"replay.visibleMessage",
	"replay.contentImages",
	"replay.images.start",
	"replay.images.end",
	"replay.prompt.start",
	"replay.prompt.end",
	"setupToken.exchange.start",
	"setupToken.exchange.response",
	"setupToken.command.start",
	"setupToken.command.cancelled",
	"setupToken.command.minted",
	"setupToken.command.denied",
	"runtime.standard.platformKey.start",
	"runtime.standard.resolve.start",
	"runtime.standard.resolve.end",
	"runtime.standard.resolveCached",
	"runtime.standard.resolve.error",
	"runtime.customHeaders.start",
	"runtime.customHeaders.end",
	"runtime.create.start",
	"runtime.create.configDir",
	"runtime.cleanup.start",
	"runtime.cleanup.end",
	"runtime.create.ready",
	"runtime.create.error",
	"runtime.android.stateRoot",
	"runtime.android.executableOnPath.start",
	"runtime.android.executableOnPath.found",
	"runtime.android.executableOnPath.missing",
	"runtime.android.validLauncher.start",
	"runtime.android.validLauncher.valid",
	"runtime.android.validLauncher.invalid",
	"runtime.android.resolve",
	"runtime.android.resolve.error",
	"runtime.android.prepare.start",
	"runtime.android.prepare.reuse",
	"runtime.android.prepare.install",
	"runtime.android.prepare.installed",
	"runtime.android.prepare.error",
	"sdk.prompt.yield",
	"sdk.toolSchemaError",
	"sdk.prompt.build",
	"sdk.start",
	"sdk.runtime.ready",
	"sdk.bridge.ready",
	"sdk.interrupt.start",
	"sdk.interrupt.end",
	"sdk.cleanup.request",
	"sdk.cleanup.start",
	"sdk.cleanup.end",
	"sdk.close.request",
	"sdk.close.abort",
	"sdk.query.call",
	"sdk.stderr",
	"sdk.hook.preToolUse",
	"sdk.canUseTool",
	"sdk.query.returned",
	"sdk.query.error",
	"sdk.pump.start",
	"sdk.pump.message",
	"sdk.position.candidate",
	"sdk.pump.error",
	"sdk.pump.finally",
	"sdk.handle.ready",
	"sdk.setTools",
	"sdk.send",
	"sdk.handleMessage",
	"sdk.message.init",
	"sdk.message.assistant",
	"sdk.message.mirror_error",
	"sdk.message.apiRetry",
	"sdk.message.permissionDenied",
	"sdk.message.workerShuttingDown",
	"sdk.message.informational",
	"sdk.message.rateLimitRejected",
	"sdk.message.result",
	"sdk.message.resultError",
	"sdk.streamEvent",
	"sdk.contentBlock.stop",
	"sdk.messageDelta",
	"coordinator.sink.create",
	"coordinator.sink.content",
	"coordinator.sink.toolUse",
	"coordinator.sink.done",
	"coordinator.sink.error",
	"coordinator.create",
	"coordinator.stream",
	"coordinator.preparePrimaryCache",
	"coordinator.persistCheckpoint.start",
	"coordinator.persistCheckpoint.skip",
	"coordinator.persistCheckpoint.position",
	"coordinator.persistCheckpoint.end",
	"coordinator.closeAll.start",
	"coordinator.closeAll.end",
	"coordinator.invoke.start",
	"coordinator.invoke.batch",
	"coordinator.invoke.continuation",
	"coordinator.invoke.compatibility",
	"coordinator.invoke.error",
	"coordinator.start.begin",
	"coordinator.start.cacheReady",
	"coordinator.start.memoryCandidate",
	"coordinator.start.checkpointLoadError",
	"coordinator.start.candidates",
	"coordinator.start.completed",
	"coordinator.start.reuseFit",
	"coordinator.start.resumePlan",
	"coordinator.start.request",
	"coordinator.start.payloadHook",
	"coordinator.start.payloadTransformed",
	"coordinator.start.scope",
	"coordinator.start.reuseRejectedByHook",
	"coordinator.start.stateAdded",
	"coordinator.callback.ready",
	"coordinator.callback.activity",
	"coordinator.callback.notice",
	"coordinator.callback.content",
	"coordinator.callback.toolBoundary",
	"coordinator.callback.result",
	"coordinator.checkpoint.published",
	"coordinator.callback.error",
	"coordinator.reuse.swapTools",
	"coordinator.reuse.send",
	"coordinator.reuse.error",
	"coordinator.oauth.resolve.start",
	"coordinator.oauth.resolve.end",
	"coordinator.sdk.start",
	"coordinator.sdk.started",
	"coordinator.handle.attached",
	"coordinator.start.error",
	"coordinator.keepForReuse",
	"coordinator.findReusable",
	"coordinator.findContinuation",
	"coordinator.addState",
	"coordinator.replaceAbort",
	"coordinator.touchState",
	"coordinator.checkpointRoot",
	"coordinator.storeFor",
	"coordinator.armTimeout",
	"coordinator.closeState.start",
	"coordinator.closeState.end",
	"coordinator.thinkingBudget",
	"coordinator.finalUserPrompt",
	"coordinator.recentToolResults.start",
	"coordinator.recentToolResults.end",
	"coordinator.isRequest",
	"cache.validateEntry",
	"cache.memory.append.start",
	"cache.memory.append.end",
	"cache.memory.load",
	"cache.memory.listSubkeys",
	"cache.checkpoints.load.start",
	"cache.checkpoints.load.end",
	"cache.checkpoint.load",
	"cache.checkpoint.save.start",
	"cache.checkpoint.save.end",
	"cache.staging.create",
	"cache.staging.append",
	"cache.staging.load",
	"cache.staging.listSubkeys",
	"cache.staging.commit.start",
	"cache.staging.commit.batch",
	"cache.staging.commit.end",
	"cache.file.create",
	"cache.file.ensureManifest",
	"cache.file.prepare.start",
	"cache.file.prepare.end",
	"cache.file.append.start",
	"cache.file.append.end",
	"cache.file.load.start",
	"cache.file.listSubkeys",
	"models.clamp",
	"models.projectModel",
	"models.projectModels",
	"protocol.isKlausModelId",
	"protocol.toKlausTools",
	"protocol.requiredConstrainedTool",
	"protocol.emptyUsage",
	"protocol.createAssistant",
	"protocol.modelFacingContent",
	"protocol.contextFingerprint.start",
	"protocol.contextFingerprint.end",
	"test.event",
	"test.env",
	"test.disabled",
	"test.failure",
] as const;

export const {
	dbg,
	span: debugSpan,
	closeDebug,
} = defineDebug({
	events,
	spans: ["test.operation", "index.oauth", "index.flush"],
	fields: {
		found: "boolean",
		usingOAuth: "boolean",
		hasAuth: "boolean",
		hasScope: "boolean",
		hasLeaf: "boolean",
		persisted: "boolean",
		alreadyWarned: "boolean",
		copied: "boolean",
		closed: "boolean",
		finished: "boolean",
		aborted: "boolean",
		hasCheckpoint: "boolean",
		hasRoot: "boolean",
		hasHandle: "boolean",
		linearResume: "boolean",
		enabled: "boolean",
		transformed: "boolean",
		hadSignal: "boolean",
		isPiSystemPrompt: "boolean",
		existing: "boolean",
		changed: "boolean",
		incompatible: "boolean",
		cached: "boolean",
		count: "number",
		length: "number",
		index: "number",
		toolCount: "number",
		resultCount: "number",
		stateCount: "number",
		batchCount: "number",
		storedCount: "number",
		entryCount: "number",
		imageCount: "number",
		imageIndex: "number",
		originalLength: "number",
		forwardedCount: "number",
		messageCount: "number",
		promptLength: "number",
		outputBytes: "number",
		retries: "number",
		timeoutMs: "number",
		attempt: "number",
		mode: ["tui", "rpc", "json", "print"],
		kind: [
			"missing-resume-uuid",
			"revoked-oauth",
			"redacted",
			"nu",
			"mcp",
			"aborted",
			"failure",
			"host",
			"oauth",
			"flush",
		],
		type: ["system", "assistant", "user", "result", "stream_event"],
		subtype: [
			"init",
			"success",
			"error",
			"api_error",
			"rate_limit",
			"tool_use",
			"tool_result",
		],
	},
} as const);

export function diagnosticKind(
	value: unknown,
): "missing-resume-uuid" | "revoked-oauth" | "redacted" {
	try {
		const text = value instanceof Error ? value.message : String(value);
		if (/No message found with message\.uuid of:/i.test(text))
			return "missing-resume-uuid";
		if (/OAuth access token has been revoked/i.test(text))
			return "revoked-oauth";
	} catch {
		// Debugging must not surface hostile values.
	}
	return "redacted";
}