import io.github.edadma.gramma.*

// 1. Define your lexer — just declare keywords and delimiters
object MyLexer extends StdLexer:
  delimiters ++= List("(", ")", "+", "-", "*", "/", ",")
  reserved ++= List("if", "then", "else")

// 2. Define your parser — ident, stringLit, numericLit are built in.
//    Bare strings automatically match keywords or delimiters.
object MyParser extends StdParsers(MyLexer):
  import scala.language.implicitConversions

  def expr(using ctx: ParseCtx): P[Int] =
    numericLit ^^ (_.toInt) |
      "if" ~> expr ~ ("then" ~> expr) ~ ("else" ~> expr) ^^ {
        case cond ~ t ~ e => if cond != 0 then t else e
      }

// 3. Parse
MyParser.parseSource("if 1 then 42 else 0")(MyParser.expr)
// Right(42)

libraryDependencies += "io.github.edadma" %%% "gramma" % "0.0.2"

import io.github.edadma.gramma.*

sealed trait JValue
case class JObject(fields: List[(String, JValue)]) extends JValue
case class JArray(elements: List[JValue]) extends JValue
case class JString(value: String) extends JValue
case class JNumber(value: Double) extends JValue
case class JBool(value: Boolean) extends JValue
case object JNull extends JValue

object JSONLexer extends StdLexer:
  delimiters ++= List("{", "}", "[", "]", ":", ",")
  reserved ++= List("true", "false", "null")

object JSONParser extends StdParsers(JSONLexer):
  import scala.language.implicitConversions

  def value(using ctx: ParseCtx): P[JValue] =
    obj | arr | stringLit ^^ (JString(_)) |
      numericLit ^^ (n => JNumber(n.toDouble)) |
      "true" ^^ (_ => JBool(true)) |
      "false" ^^ (_ => JBool(false)) |
      "null" ^^ (_ => JNull)

  def arr(using ctx: ParseCtx): P[JValue] =
    "[" ~> repsep(value, ",") <~ "]" ^^ (JArray(_))

  def obj(using ctx: ParseCtx): P[JValue] =
    "{" ~> repsep(field, ",") <~ "}" ^^ (JObject(_))

  def field(using ctx: ParseCtx): P[(String, JValue)] =
    stringLit ~ (":" ~> value) ^^ { case k ~ v => (k, v) }

// Parse
JSONParser.parseSource("""{"name": "Alice", "age": 30}""")(JSONParser.value)

object YAMLLexer extends StdLexer:
  override protected def indentSensitive: Boolean = true
  delimiters ++= List(":", "-")
  reserved ++= List("true", "false", "null")

object YAMLParser extends StdParsers(YAMLLexer):
  import scala.language.implicitConversions

  def document(using ctx: ParseCtx): P[YValue] =
    blockMap | blockList | scalar

  def blockMap(using ctx: ParseCtx): P[YValue] =
    rep1sep(mapEntry, newline) ^^ (entries => YMap(entries))

  def mapEntry(using ctx: ParseCtx): P[(String, YValue)] =
    ident ~ (":" ~> mapValue) ^^ { case k ~ v => (k, v) }

  def mapValue(using ctx: ParseCtx): P[YValue] =
    scalar | block(value)  // inline value or indented block

  def blockList(using ctx: ParseCtx): P[YValue] =
    rep1sep("-" ~> value, newline) ^^ (items => YList(items))

object MyLexer extends StdLexer:
  delimiters ++= List("<=", ">=", "==", "!=", "<", ">", "=", "+", "-", "*", "/")
  reserved ++= List("if", "then", "else", "true", "false")

// These are equivalent:
keyword("if") ~> expr ~ (keyword("then") ~> expr)
"if" ~> expr ~ ("then" ~> expr)

case class Token(kind: TokenKind, text: String, pos: Pos)

object MyLexer extends Lexers:
  def nextToken(using ctx: LexCtx): P[Token] =
    skipWhitespace("//", "/*", "*/", false)
    val pos = ctx.capturePos()
    firstChar {
      case c if c.isLetter => identifier(_.isLetter, _.isLetterOrDigit) ^^ { text => ... }
      case c if c.isDigit  => decimalLit ^^ { text => ... }
      case '"'             => stringLit('"', '\\') ^^ { text => ... }
      case _               => charIn("+-*/") ^^ { c => ... }
    }

object MyParser extends TokenParsers[Token]:
  def tokenPos(token: Token): Pos = token.pos
  // ... define accept-based matchers for your token type