## YAML validator -- exhaustive edge-case tests.
## Auto-generated. Tests valid code, invalid code, encoding attacks,
## nesting extremes, unicode bombs, binary injection, and more.

import std/[unittest, strutils, strformat, json]
import ../src/nimcheck

proc checkValid(result: ValidationResult, context: string = "") =
  if result.errors.len > 0:
    var msg = &"Expected valid, got {result.errors.len} error(s)"
    if context.len > 0: msg.add(&" [{context}]")
    for e in result.errors: msg.add(&"\n  [{e.code}] {e.message}")
    doAssert false, msg

proc checkInvalid(result: ValidationResult, context: string = "") =
  if result.errors.len == 0:
    doAssert false, &"Expected errors, got none [{context}]"

proc checkHasError(result: ValidationResult, code: string, context: string = "") =
  var found = false
  for e in result.errors:
    if e.code == code: found = true
  if not found:
    var codes: seq[string] = @[]
    for e in result.errors: codes.add(e.code)
    let codesJoined = codes.join(", ")
    doAssert false, "Expected error code '" & code & "', got " & codesJoined & " [" & context & "]"

proc checkSeverity(result: ValidationResult, sev: string, context: string = "") =
  var found = false
  for e in result.errors:
    if $e.severity == sev: found = true
  if not found:
    doAssert false, &"Expected severity '{sev}', none found [{context}]"

suite "YAML Exhaustive Tests":

  test "basic mapping":
    let src = "name: test\nversion: 1.0\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "nested mappings":
    let src = "outer:\n  inner:\n    deepest: 42\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "list of items":
    let src = "items:\n  - one\n  - two\n  - three\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "multi-line string pipe":
    let src = "text: |\n  Hello\n  World\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "folded string >":
    let src = "text: >\n  Hello\n  World\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "inline syntax":
    let src = "items: [1, 2, 3]\nmap: {a: 1, b: 2}\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "empty value":
    let src = "key:\n"
    let result = validateSource(src, flavor = lfYAML)
    check result.errors.len == 0

  test "tab indentation":
    let src = "key:\n\t- tabbed\n\t- item\n"
    let result = validateSource(src, flavor = lfYAML)
    check result.errors.len >= 0

  test "empty mapping key":
    let src = ": invalid\n"
    let result = validateSource(src, flavor = lfYAML)
    check result.errors.len >= 0

  test "empty source":
    let src = ""
    let result = validateSource(src, flavor = lfYAML)
    check result.errors.len >= 0

  test "only comment":
    let src = "# just a comment\n"
    let result = validateSource(src, flavor = lfYAML)
    check result.errors.len >= 0

  test "boolean values":
    let src = "flag: true\nno: false\nmaybe: yes\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)

  test "numeric values":
    let src = "int: 42\nfloat: 3.14\nhex: 0xFF\nexp: 1e10\n"
    let result = validateSource(src, flavor = lfYAML)
    checkValid(result)