export const APPLICATION_COMMAND_ERROR_CODES = [
  'invalid-command-arguments',
  'invalid-command-result',
  'command-unavailable',
  'command-failed',
  'session-details-conflict',
  'session-size-limit',
  'session-revision-conflict',
  'SESSION_RUNTIME_WRITER_LOST',
  'csl-file-too-large',
  'csl-invalid-xml',
  'csl-unsupported-doctype',
  'csl-unsupported-style',
  'csl-missing-metadata',
  'csl-dependent-style',
  'csl-undefined-macro',
  'csl-missing-sections'
] as const

export type ApplicationCommandErrorCode = (typeof APPLICATION_COMMAND_ERROR_CODES)[number]

export type RuntimeCodec<Value> = Readonly<{
  parse: (value: unknown) => Value
}>

export const validationCodec = <Value>(codec: RuntimeCodec<Value>): RuntimeCodec<Value> =>
  Object.freeze({
    parse: (value): Value => {
      codec.parse(value)
      return value as Value
    }
  })

export type ApplicationCommandContract<Args extends readonly unknown[], Result> = Readonly<{
  args: RuntimeCodec<Args>
  result: RuntimeCodec<Result>
}>

// Domain modules compose runtime-validated command contracts with this helper so arg/result codecs
// stay colocated with the shared domain types they parse.
export const defineApplicationCommandContract = <Args extends readonly unknown[], Result>(
  args: ApplicationCommandContract<Args, Result>['args'],
  result: ApplicationCommandContract<Args, Result>['result']
): ApplicationCommandContract<Args, Result> => Object.freeze({ args, result })

export type ApplicationCommandErrorEnvelope = Readonly<{
  code: ApplicationCommandErrorCode
  message: string
  parameters?: Readonly<{ macro: string }>
}>

export type ApplicationCommandOutcome<Result> =
  | Readonly<{ ok: true; result: Result }>
  | Readonly<{ ok: false; error: ApplicationCommandErrorEnvelope }>

const errorCodes = new Set<string>(APPLICATION_COMMAND_ERROR_CODES)

export const isApplicationCommandErrorCode = (
  value: unknown
): value is ApplicationCommandErrorCode => typeof value === 'string' && errorCodes.has(value)

export class ApplicationCommandError extends Error {
  constructor(
    readonly code: ApplicationCommandErrorCode,
    message: string,
    readonly parameters?: Readonly<{ macro: string }>
  ) {
    super(message)
    this.name = 'ApplicationCommandError'
  }
}

export const toApplicationCommandErrorEnvelope = (
  error: unknown
): ApplicationCommandErrorEnvelope =>
  Object.freeze(
    error instanceof ApplicationCommandError
      ? {
          code: error.code,
          message: error.message,
          ...(error.code === 'csl-undefined-macro' && error.parameters
            ? { parameters: { macro: error.parameters.macro } }
            : {})
        }
      : {
          code: 'command-failed' as const,
          message: error instanceof Error ? error.message : String(error)
        }
  )

const invalidOutcome = (): ApplicationCommandError =>
  new ApplicationCommandError(
    'invalid-command-result',
    'Application command returned an invalid response.'
  )

export const parseApplicationCommandError = (
  error: unknown
): ApplicationCommandError | undefined => {
  if (
    error != null &&
    typeof error === 'object' &&
    'code' in error &&
    isApplicationCommandErrorCode(error.code) &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    const parameters = 'parameters' in error ? error.parameters : undefined
    if (error.code === 'csl-undefined-macro') {
      if (
        !parameters ||
        typeof parameters !== 'object' ||
        !('macro' in parameters) ||
        typeof parameters.macro !== 'string' ||
        Object.keys(parameters).length !== 1
      )
        return undefined
      return new ApplicationCommandError(error.code, error.message, {
        macro: parameters.macro
      })
    }
    if (parameters !== undefined) return undefined
    return new ApplicationCommandError(error.code, error.message)
  }
  return undefined
}

export const unwrapApplicationCommandOutcome = <Result>(value: unknown): Result => {
  if (!value || typeof value !== 'object' || !('ok' in value)) throw invalidOutcome()
  if (value.ok === true && 'result' in value) return value.result as Result
  if (value.ok === false && 'error' in value) {
    throw parseApplicationCommandError(value.error) ?? invalidOutcome()
  }
  throw invalidOutcome()
}