#!/usr/bin/env bash

source $[dirname $0]/reader.sh
source $[dirname $0]/printer.sh
source $[dirname $0]/env.sh
source $[dirname $0]/core.sh

# read
proc READ {
    test $(1) && setglobal r = $(1) || READLINE
    READ_STR $(r)
}

# eval
proc EVAL_AST {
    local ast="$(1)" env="$(2)"
    #_pr_str "${ast}"; echo "EVAL_AST '${ast}:${r} / ${env}'"
    _obj_type $(ast); local ot="$(r)"
    match $(ot) {
    with symbol
        ENV_GET $(env) $(ast)
        return 
    with list
        _map_with_type _list EVAL $(ast) $(env) 
    with vector
        _map_with_type _vector EVAL $(ast) $(env) 
    with hash_map
        local res="" key= val="" hm="$(ANON["${ast}"])"
        _hash_map; local new_hm="$(r)"
        eval local keys="\${!$(hm)[@]}"
        for key in [$(keys)] {
            eval val="\${$(hm)[\"$(key)\"]}"
            EVAL $(val) $(env)
            _assoc! $(new_hm) $(key) $(r)
        }
        setglobal r = $(new_hm) 
    with *
        setglobal r = $(ast) 
    }
}

proc EVAL {
    local ast="$(1)" env="$(2)"
    while true {
    setglobal r = ''
    [[ "${__ERROR}" ]] && return 1
    #_pr_str "${ast}"; echo "EVAL '${r} / ${env}'"
    _obj_type $(ast); local ot="$(r)"
    if [[ "${ot}" != "list" ]] {
        EVAL_AST $(ast) $(env)
        return
    }
    _empty? $(ast) && setglobal r = $(ast) && return

    # apply list
    _nth $(ast) 0; local a0="$(r)"
    _nth $(ast) 1; local a1="$(r)"
    _nth $(ast) 2; local a2="$(r)"
    match $(ANON["${a0}"]) {
        with def! EVAL $(a2) $(env)
              [[ "${__ERROR}" ]] && return 1
              ENV_SET $(env) $(a1) $(r)
              return 
        with let* ENV $(env); local let_env="$(r)"
              local let_pairs=(${ANON["${a1}"]})
              local idx=0 {
                  EVAL $(let_pairs[$(( idx + 1))]) $(let_env)
                  ENV_SET $(let_env) $(let_pairs[${idx}]) $(r)
                  setglobal idx = $shExpr(' idx + 2')
              }
              setglobal ast = $(a2)
              setglobal env = $(let_env)
              # Continue loop
              
        with do   _count $(ast)
              _slice $(ast) 1 $shExpr(' ${r} - 2 ')
              EVAL_AST $(r) $(env)
              [[ "${__ERROR}" ]] && setglobal r = '' && return 1
              _last $(ast)
              setglobal ast = $(r)
              # Continue loop
              
        with if   EVAL $(a1) $(env)
              [[ "${__ERROR}" ]] && return 1
              if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]] {
                  # eval false form
                  _nth $(ast) 3; local a3="$(r)"
                  if [[ "${a3}" ]] {
                      setglobal ast = $(a3)
                  } else {
                      setglobal r = $(__nil)
                      return
                  }
              } else {
                  # eval true condition
                  setglobal ast = $(a2)
              }
              # Continue loop
              
        with fn*  _function "ENV \"$(env)\" \"$(a1)\" \"\${@}\"; \
                         EVAL \"$(a2)\" \"\${r}\"" \
                        $(a2) $(env) $(a1)
              return 
        with *    EVAL_AST $(ast) $(env)
              [[ "${__ERROR}" ]] && setglobal r = '' && return 1
              local el="$(r)"
              _first $(el); local f="$(ANON["${r}"])"
              _rest $(el); local args="$(ANON["${r}"])"
              #echo "invoke: [${f}] ${args}"
              if [[ "${f//@/ }" != "${f}" ]] {
                  set -- $(f//@/ )
                  setglobal ast = $(2)
                  ENV $(3) $(4) $(args)
                  setglobal env = $(r)
              } else {
                  eval $(f%%@*) $(args)
                  return
              }
              # Continue loop
              
    }
    }
}

# print
proc PRINT {
    if [[ "${__ERROR}" ]] {
        _pr_str $(__ERROR) yes
        setglobal r = ""Error: $(r)""
        setglobal __ERROR = ''
    } else {
        _pr_str $(1) yes
    }
}

# repl
ENV; setglobal REPL_ENV = $(r)
proc REP {
    setglobal r = ''
    READ $(1)
    EVAL $(r) $(REPL_ENV)
    PRINT $(r)
}

# core.sh: defined using bash
proc _fref {
    _symbol $(1); local sym="$(r)"
    _function "$(2) \"\${@}\""
    ENV_SET $(REPL_ENV) $(sym) $(r)
}
for n in [$(!core_ns[@])] { _fref $(n) $(core_ns["${n}"]); }
proc _eval { EVAL $(1) $(REPL_ENV); }
_fref "eval" _eval
_list; setglobal argv = $(r)
for _arg in [$(@:2)] { _string $(_arg); _conj! $(argv) $(r); }
_symbol "__STAR__ARGV__STAR__"
ENV_SET $(REPL_ENV) $(r) $(argv);

# core.mal: defined using the language itself
REP "(def! not (fn* (a) (if a false true)))"
REP "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"

# load/run file from command line (then exit)
if [[ "${1}" ]] {
    REP "(load-file \"$(1)\")"
    exit 0
} 

# repl loop
while true {
    READLINE "user> " || exit "$?"
    [[ "${r}" ]] && REP $(r) && echo $(r)
}