# selah-bend — pure Bend Bible parse / share / linkify (route.bible)
# Run:     bend main.bend -- "John 3:16"
# Publish: bend main.bend --publish
import Base
import ./parse.bend as P
import ./linkify.bend as L

def join_args(xs: List<&1, String>) -> String:
  match xs:
    case Nil{}:
      ""
    case h <> Nil{}:
      h
    case h <> t:
      String.append(h, String.append(" ", join_args(t)))

def run_linkify_md(+q: String, +src: String, rewrite: Bool) -> IO(Unit):
  IO.print(String.append(L.linkify_markdown_cli(q, src, rewrite), "\n"))

# After --linkify: optional --src <tag> / --rewrite-existing, then text.
type LfPh is Data:
  LfGo{+src: String, rewrite: Bool}
  LfNeedSrc{rewrite: Bool}
  LfHead{+src: String, rewrite: Bool, is_rw: Bool, is_src: Bool, +h: String}

def linkify_cli_go(fuel: Nat, ph: LfPh, xs: List<&1, String>) -> IO(Unit):
  match fuel:
    case 0n:
      match ph:
        case LfGo{+src, rewrite}:
          run_linkify_md(join_args(xs), src, rewrite)
        case LfNeedSrc{rewrite}:
          run_linkify_md(join_args(xs), "", rewrite)
        case LfHead{+src, rewrite, is_rw, is_src, +h}:
          run_linkify_md(join_args(h <> xs), src, rewrite)
    case 1n+p:
      match ph:
        case LfGo{+src, rewrite}:
          match xs:
            case Nil{}:
              run_linkify_md("", src, rewrite)
            case +h <> t:
              linkify_cli_go(
                p,
                LfHead{src, rewrite, String.eq(h, "--rewrite-existing"), String.eq(h, "--src"), h},
                t
              )
        case LfNeedSrc{rewrite}:
          match xs:
            case Nil{}:
              run_linkify_md("", "", rewrite)
            case +tag <> t:
              linkify_cli_go(p, LfGo{tag, rewrite}, t)
        case LfHead{+src, rewrite, is_rw, is_src, +h}:
          match is_rw:
            case True{}:
              linkify_cli_go(p, LfGo{src, True{}}, xs)
            case False{}:
              match is_src:
                case True{}:
                  linkify_cli_go(p, LfNeedSrc{rewrite}, xs)
                case False{}:
                  run_linkify_md(join_args(h <> xs), src, rewrite)

def linkify_cli(xs: List<&1, String>) -> IO(Unit):
  linkify_cli_go(64n, LfGo{"", False{}}, xs)

type MainPh is Data:
  MainLink{is_link: Bool}

def main_go_ph(ph: MainPh, +h: String, t: List<&1, String>) -> IO(Unit):
  match ph:
    case MainLink{is_link}:
      match is_link:
        case True{}:
          linkify_cli(t)
        case False{}:
          P.run_args(h <> t)

def main_go(xs: List<&1, String>) -> IO(Unit):
  match xs:
    case Nil{}:
      P.usage()
    case +h <> t:
      main_go_ph(MainLink{String.eq(h, "--linkify")}, h, t)

def main() -> IO(Unit):
  do IO<Unit>:
    args : List<&1, String> <- IO.args()
    main_go(args)