import { readdirSync, statSync, readFileSync } from "node:fs"
import { join } from "node:path"
import { TextDecoder } from "node:util"
import { getDirectiveTokens, splitArgs } from "./scanner"

export type TemplateVariable = {
  path: string
  type: string
}

const VAR_RE = /<@var\(context\.(.+?)(?::(\w+))?\)>/g
const STRING_COMPARE_RE = /^(?:eq|neq)\(context\.(.+?),\s*"(.*)"\)$/
const PATH_RE = /^context\.(.+)$/

function extractCondition(expr: string | undefined, vars: TemplateVariable[]) {
  if (!expr) throw new Error("Missing condition expression")
  for (const operator of ["and", "or"]) {
    const prefix = `${operator}(`
    if (expr.startsWith(prefix) && expr.endsWith(")")) {
      const args = splitArgs(expr.slice(prefix.length, -1))
      if (args.length === 0) throw new Error(`Invalid condition expression: ${expr}`)
      for (const arg of args) extractCondition(arg, vars)
      return
    }
  }
  const stringCompareMatch = expr.match(STRING_COMPARE_RE)
  if (stringCompareMatch) {
    vars.push({ path: stringCompareMatch[1]!, type: "string" })
    return
  }
  const pathMatch = expr.match(PATH_RE)
  if (pathMatch) {
    vars.push({ path: pathMatch[1]!, type: "boolean" })
    return
  }
  throw new Error(`Invalid condition expression: ${expr}`)
}

function extractFromString(text: string, vars: TemplateVariable[]) {
  for (const token of getDirectiveTokens(text)) {
    if (token.type === "if" || token.type === "elseif") {
      extractCondition(token.condition, vars)
    }
  }
  for (const match of text.matchAll(VAR_RE)) {
    vars.push({ path: match[1]!, type: match[2] ?? "string" })
  }
}

function validateIfBlocks(content: string, vars: TemplateVariable[]) {
  const stack: { sawElse: boolean }[] = []

  for (const token of getDirectiveTokens(content)) {
    const directive = token.type
    const condition = token.condition

    if (directive === "if") {
      extractCondition(condition!, vars)
      stack.push({ sawElse: false })
    } else if (directive === "elseif") {
      const frame = stack[stack.length - 1]
      if (!frame) throw new Error("Unexpected <@elseif> without <@if>")
      if (frame.sawElse) throw new Error("Unexpected <@elseif> after <@else>")
      extractCondition(condition!, vars)
    } else if (directive === "else") {
      const frame = stack[stack.length - 1]
      if (!frame) throw new Error("Unexpected <@else> without <@if>")
      if (frame.sawElse) throw new Error("Unexpected duplicate <@else>")
      frame.sawElse = true
    } else if (directive === "endif") {
      if (stack.length === 0) throw new Error("Unexpected <@endif> without <@if>")
      stack.pop()
    }
  }

  if (stack.length > 0) {
    throw new Error("Unmatched <@if> without <@endif>")
  }
}

function isUtf8Text(buffer: Buffer): boolean {
  if (buffer.indexOf(0) !== -1) return false
  try {
    new TextDecoder("utf-8", { fatal: true }).decode(buffer)
    return true
  } catch {
    return false
  }
}

function walkDir(dirPath: string, vars: TemplateVariable[]) {
  const entries = readdirSync(dirPath).sort()
  for (const entry of entries) {
    const fullPath = join(dirPath, entry)
    extractFromString(entry, vars)

    const stat = statSync(fullPath)
    if (stat.isDirectory()) {
      walkDir(fullPath, vars)
    } else if (stat.isFile()) {
      const content = readFileSync(fullPath)
      if (isUtf8Text(content)) {
        const text = content.toString("utf-8")
        extractFromString(text, vars)
        validateIfBlocks(text, vars)
      }
    }
  }
}

export function parse(dirPath: string): TemplateVariable[] {
  const vars: TemplateVariable[] = []
  walkDir(dirPath, vars)
  const seen = new Set<string>()
  return vars.filter(v => {
    const key = `${v.path}:${v.type}`
    if (seen.has(key)) return false
    seen.add(key)
    return true
  })
}