#!/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)"
    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')
              }
              EVAL $(a2) $(let_env)
              return 
        with do   _rest $(ast)
              EVAL_AST $(r) $(env)
              [[ "${__ERROR}" ]] && setglobal r = '' && return 1
              _last $(r)
              return 
        with if   EVAL $(a1) $(env)
              [[ "${__ERROR}" ]] && return 1
              if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]] {
                  # eval false form
                  _nth $(ast) 3; local a3="$(r)"
                  if [[ "${a3}" ]] {
                      EVAL $(a3) $(env)
                  } else {
                      setglobal r = $(__nil)
                  }
              } else {
                  # eval true condition
                  EVAL $(a2) $(env)
              }
              return 
        with fn*  _function "ENV \"$(env)\" \"$(a1)\" \"\${@}\"; \
                         EVAL \"$(a2)\" \"\${r}\""
              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}"
              eval $(f) $(args)
              return 
    }
}

# 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}"]); }

# core.mal: defined using the language itself
REP "(def! not (fn* (a) (if a false true)))"

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