# SPDX-FileCopyrightText: ☭ Emery Hemingway
# SPDX-License-Identifier: Unlicense

import std/[options, sequtils, tables, unittest]

import preserves, syndicate, syndicate/protocols/[gatekeeper, timer]

import ./test_schema

suite "example":
  var pat: Pattern
  check pat.fromPreserves parsePreserves"""
      <group <arr> {
        0: <lit 1>
        1: <bind <group <arr> {
          0: <bind <_>>
          1: <_>
        }>>
        2: <_>
      }>
    """

  const A = "[1 2 3]"
  test A:
    let v = parsePreserves A
    check:
      not pat.matches(v)

  const B = "[1 [2 3] 4]"
  test B:
    let
      v = parsePreserves B
      c = parsePreserves "[[2 3] 2]"
    check pat.matches(v)
    check pat.capture(v).toPreserves == c

  const C = "[1 [2] 5]"
  test C:
    let v = parsePreserves C
    check:
      not pat.matches(v)

  const D = "[1 [2 3 4] 5]"
  test D:
    let
      v = parsePreserves D
      c = parsePreserves "[[2 3 4] 2]"
    check pat.matches(v)
    check pat.capture(v).toPreserves == c

  const E = "[1 [<x> <y>] []]"
  test E:
    let
      v = parsePreserves E
      c = parsePreserves "[[<x> <y>] <x>]"
    check pat.matches(v)
    check pat.capture(v).toPreserves == c

suite "meta":

  test "pattern-of-pattern":
    let
      pat = grabRecord("foo".toSymbol, {666: drop()})
      meta = pat.toPreserves.drop()
    check $meta == "<group <rec group> {0: <group <rec rec> {0: <lit foo>}> 1: <group <dict> {666: <_>}>}>"

  test "observe":
    let
      val = Observe(pattern: LaterThan ?: {0: drop 12.24}).toPreserves
      pat = grab(val)
    check pat.matches(val)
    check pat.capture(val) == @[val]
    let
      meta = observePattern(!LaterThan, {@[0.toPreserves]: grabLit()})
      res = parsePreserves "[12.24]"
    check meta.matches(val)
    check meta.capture(val).toPreserves == res

  test "connect-transport":
    let pat = parsePreserves"""
        <group <rec connect-transport> {0: <group <rec unix> {0: <lit "/run/user/1000/dataspace">}> 2: <group <rec accepted> {0: <bind <_>>}>}>
      """.preservesTo(Pattern).get
    let val = parsePreserves"""
        <connect-transport <unix "/run/user/1000/dataspace"> #:#f <accepted #:#f>>
      """
    check pat.matches(val)
    check pat.capture(val).toPreserves == parsePreserves "[#:#f]"