@kody/sentry

import type {
	IssueTriage,
	JsonRecord,
	SentryBreadcrumbSummary,
	SentryEvent,
	SentryEventSummary,
	SentryExceptionSummary,
	SentryIssue,
	SummarizeIssueEventOptions,
} from './types.ts'

export function summarizeIssueEvent(
	event: SentryEvent,
	options: SummarizeIssueEventOptions = {},
): SentryEventSummary {
	const eventRecord = asRecord(event) ?? {}
	const metadata = asRecord(eventRecord.metadata) ?? {}
	const contexts = asRecord(eventRecord.contexts) ?? {}
	const entries = asArray(eventRecord.entries).map((entry) => asRecord(entry)).filter(Boolean) as JsonRecord[]
	const exceptionChain = extractExceptionChain(entries, options.maxFramesPerException ?? 8)
	const breadcrumbs = extractBreadcrumbs(entries, options.maxBreadcrumbs ?? 20)
	const tags = normalizeTags(eventRecord.tags)

	return {
		id: stringValue(eventRecord.id),
		eventId: stringValue(eventRecord.eventID) ?? stringValue(eventRecord.eventId),
		title: stringValue(eventRecord.title) ?? stringValue(metadata.title),
		message: stringValue(eventRecord.message) ?? stringValue(metadata.value),
		culprit: stringValue(eventRecord.culprit),
		platform: stringValue(eventRecord.platform),
		projectId: stringValue(eventRecord.projectID) ?? stringValue(eventRecord.projectId),
		groupId: stringValue(eventRecord.groupID) ?? stringValue(eventRecord.groupId),
		release: stringValue(eventRecord.release) ?? stringValue(tags.release),
		environment: stringValue(eventRecord.environment) ?? stringValue(tags.environment),
		timestamp: stringValue(eventRecord.dateCreated) ?? stringValue(eventRecord.dateReceived),
		exceptionChain,
		tags,
		breadcrumbs,
		contexts,
		contextKeys: Object.keys(contexts),
		user: eventRecord.user,
		request: eventRecord.request,
	}
}

export function summarizeIssueMetadata(issue: SentryIssue): IssueTriage['issue'] {
	return {
		id: issue.id,
		shortId: issue.shortId,
		title: issue.title,
		status: issue.status,
		level: stringValue(issue.level),
		permalink: issue.permalink,
		firstSeen: stringValue(issue.firstSeen),
		lastSeen: stringValue(issue.lastSeen),
		count: issue.count as string | number | undefined,
		userCount: issue.userCount as string | number | undefined,
		project: issue.project,
		assignedTo: issue.assignedTo,
	}
}

export function uniqueStrings(values: Array<string | undefined>): string[] {
	return [...new Set(values.filter(Boolean) as string[])]
}

function extractExceptionChain(entries: JsonRecord[], maxFramesPerException: number): SentryExceptionSummary[] {
	return entries
		.filter((entry) => entry.type === 'exception')
		.flatMap((entry) => {
			const data = asRecord(entry.data) ?? {}
			return asArray(data.values)
		})
		.map((exception) => {
			const exceptionRecord = asRecord(exception) ?? {}
			const stacktrace = asRecord(exceptionRecord.stacktrace) ?? {}
			const frames = asArray(stacktrace.frames).map((frame) => asRecord(frame)).filter(Boolean) as JsonRecord[]
			const selectedFrames = frames.slice(-maxFramesPerException).map(summarizeFrame)

			return {
				type: stringValue(exceptionRecord.type),
				value: stringValue(exceptionRecord.value),
				module: stringValue(exceptionRecord.module),
				mechanism: exceptionRecord.mechanism,
				frameCount: frames.length,
				frames: selectedFrames,
			}
		})
}

function summarizeFrame(frame: JsonRecord): SentryExceptionSummary['frames'][number] {
	return {
		function: stringValue(frame.function),
		module: stringValue(frame.module),
		filename: stringValue(frame.filename),
		absPath: stringValue(frame.absPath) ?? stringValue(frame.abs_path),
		lineNo: numberValue(frame.lineNo) ?? numberValue(frame.lineno),
		colNo: numberValue(frame.colNo) ?? numberValue(frame.colno),
		inApp: booleanValue(frame.inApp) ?? booleanValue(frame.in_app),
		contextLine: stringValue(frame.contextLine) ?? stringValue(frame.context_line),
	}
}

function extractBreadcrumbs(entries: JsonRecord[], maxBreadcrumbs: number): SentryBreadcrumbSummary[] {
	const breadcrumbEntry = entries.find((entry) => entry.type === 'breadcrumbs')
	const data = asRecord(breadcrumbEntry?.data) ?? {}

	return asArray(data.values)
		.slice(-maxBreadcrumbs)
		.map((breadcrumb) => {
			const record = asRecord(breadcrumb) ?? {}
			return {
				timestamp: stringValue(record.timestamp),
				type: stringValue(record.type),
				category: stringValue(record.category),
				level: stringValue(record.level),
				message: stringValue(record.message),
				data: record.data,
			}
		})
}

function normalizeTags(tags: unknown): Record<string, unknown> {
	if (Array.isArray(tags)) {
		return Object.fromEntries(
			tags
				.map((tag) => {
					const record = asRecord(tag)
					if (!record) return null
					const key = stringValue(record.key) ?? stringValue(record.name)
					if (!key) return null
					return [key, record.value]
				})
				.filter(Boolean) as Array<[string, unknown]>,
		)
	}

	return asRecord(tags) ?? {}
}

function asArray(value: unknown): unknown[] {
	return Array.isArray(value) ? value : []
}

function asRecord(value: unknown): JsonRecord | null {
	if (value && typeof value === 'object' && !Array.isArray(value)) {
		return value as JsonRecord
	}
	return null
}

function stringValue(value: unknown): string | undefined {
	return typeof value === 'string' && value.length > 0 ? value : undefined
}

function numberValue(value: unknown): number | undefined {
	return typeof value === 'number' && Number.isFinite(value) ? value : undefined
}

function booleanValue(value: unknown): boolean | undefined {
	return typeof value === 'boolean' ? value : undefined
}