import { createLogger } from '@sim/logger'

import { getErrorMessage } from '@sim/utils/errors'

import { EVALUATOR } from '@/executor/constants'

const logger = createLogger('JSONUtils')

export function parseJSON<T>(value: unknown, fallback: T): T {

if (typeof value !== 'string') {

return fallback

}

try {

return JSON.parse(value.trim())

} catch (error) {

return fallback

}

}

export function parseJSONOrThrow(value: string): any {

try {

return JSON.parse(value.trim())

} catch (error) {

throw new Error(`Invalid JSON: ${getErrorMessage(error, 'Parse error')}`)

}

}

export function normalizeJSONString(value: string): string {

return value.replace(/'/g, '"')

}

export function stringifyJSON(value: any, indent?: number): string {

try {

return JSON.stringify(value, null, indent ?? EVALUATOR.JSON_INDENT)

} catch (error) {

logger.warn('Failed to stringify value, returning string representation', { error })

return String(value)

}

}

export function isJSONString(value: string): boolean {

const trimmed = value.trim()

return trimmed.startsWith('{') || trimmed.startsWith('[')

}

/**

* Recursively parses JSON strings within an object or array.

* Useful for normalizing data that may contain stringified JSON at various levels.

*/

export function parseObjectStrings(data: unknown): unknown {

if (typeof data === 'string') {

try {

const parsed = JSON.parse(data)

if (typeof parsed === 'object' && parsed !== null) {

return parseObjectStrings(parsed)

}

return parsed

} catch {

return data

}

} else if (Array.isArray(data)) {

return data.map((item) => parseObjectStrings(item))

} else if (typeof data === 'object' && data !== null) {

const result: Record<string, unknown> = {}

for (const [key, value] of Object.entries(data)) {

result[key] = parseObjectStrings(value)

}

return result

}

return data

}