export * as ConfigParse from "./parse"

import { type ParseError as JsoncParseError, parse as parseJsonc, printParseErrorCode } from "jsonc-parser"
import z from "zod"
import { ConfigVariable } from "./variable"
import { InvalidError, JsonError } from "./error"

type Schema<T> = z.ZodType<T>
type VariableMode = "error" | "empty"

export type LoadOptions =
  | {
      type: "path"
      path: string
      missing?: VariableMode
      normalize?: (data: unknown, source: string) => unknown
    }
  | {
      type: "virtual"
      dir: string
      source: string
      missing?: VariableMode
      normalize?: (data: unknown, source: string) => unknown
    }

function issues(text: string, errors: JsoncParseError[]) {
  const lines = text.split("\n")
  return errors
    .map((e) => {
      const beforeOffset = text.substring(0, e.offset).split("\n")
      const line = beforeOffset.length
      const column = beforeOffset[beforeOffset.length - 1].length + 1
      const problemLine = lines[line - 1]

      const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
      if (!problemLine) return error

      return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
    })
    .join("\n")
}

export function parse<T>(schema: Schema<T>, text: string, filepath: string): T {
  const errors: JsoncParseError[] = []
  const data = parseJsonc(text, errors, { allowTrailingComma: true })
  if (errors.length) {
    throw new JsonError({
      path: filepath,
      message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${issues(text, errors)}\n--- End ---`,
    })
  }

  const parsed = schema.safeParse(data)
  if (parsed.success) return parsed.data

  throw new InvalidError({
    path: filepath,
    issues: parsed.error.issues,
  })
}

export async function load<T>(schema: Schema<T>, text: string, options: LoadOptions): Promise<T> {
  const source = options.type === "path" ? options.path : options.source
  const expanded = await ConfigVariable.substitute(
    text,
    options.type === "path" ? { type: "path", path: options.path } : options,
    options.missing,
  )
  const data = parse(z.unknown(), expanded, source)
  const normalized = options.normalize ? options.normalize(data, source) : data
  const parsed = schema.safeParse(normalized)
  if (!parsed.success) {
    throw new InvalidError({
      path: source,
      issues: parsed.error.issues,
    })
  }

  return parsed.data
}