CL

function trim(s)
    return (tostring(s):gsub("^%s*(.-)%s*$", "%1"))
end

local key, proc, rank = {}, {}, {}

local vars = {}

-- for $varname : start, end, step { statement; };
key["for"] = "for%s-%$(%S+)%s-:%s-([^,]-),%s-([^,{]-),%s-([^{]-)%s-(%b{});"
proc["for"] = function(lvars, var, start, stop, step, src)
    lvars[var] = start
    while tonumber(lvars[var]) <= tonumber(stop) do
        parse(src:sub(2, -2), lvars)
        lvars[var] = lvars[var] + eval(step, lvars)
    end
end
rank["for"] = 0
-- while conditions { statement; };
key["while"] = "while%s-([^{]-)%s-(%b{});"
proc["while"] = function(lvars, conditions, src)
    --lvars[var] = start
    while isTrue(conditions, lvars) do
        parse(src:sub(2, -2), lvars)
    end
end
rank["while"] = 0

-- if conditions { statement; };
key["if"] = "if%s-([^{]-)%s-(%b{});"
proc["if"] = function(lvars, conditions, src)
    --lvars[var] = start
    if isTrue(conditions, lvars) then
        parse(src:sub(2, -2), lvars)
    end
end
rank["if"] = 0

key["if.-{.-}%s-else%s-%b{}"] = "if%s-([^{]-)%s-(%b{})%s-else%s-(%b{});"
proc["if.-{.-}%s-else%s-%b{}"] = function(lvars, conditions, src, src2)
    --lvars[var] = start
    if isTrue(conditions, lvars) then
        parse(src:sub(2, -2), lvars)
    else
        parse(src2:sub(2, -2), lvars)
    end
end
rank["if.-{.-}%s-else%s-%b{}"] = 1

key["if.-{.-}%s-elseif"] = "if%s-([^{]-)%s-(%b{})%s-(elseif%s-[^}]+%s-%b{}.-;~)"
proc["if.-{.-}%s-elseif"] = function(lvars, conditions, src, chunk2)
    --lvars[var] = start
    if isTrue(conditions, lvars) then
        parse(src:sub(2, -2), lvars)
    else
        parse(chunk2:sub(5, -1), lvars)
    end
end
rank["if.-{.-}%s-elseif"] = 2

key["return"] = "return(.-);"
proc["return"] = function(lvars, args)
    --print("Returning...")
    args = trim(args)
    --[[
    _RETURN = ""
    for arg in args:gmatch("([^,]-),") do
        _RETURN = eval(arg, lvars)
    end
    --]]
    _RETURN = eval(args, lvars)
    --print(_RETURN)
end
rank["return"] = 0

key["print"] = "print%s+(.-);"
proc["print"] = function(lvars, stuff)
    stuff = "," .. stuff .. ","
    for v in stuff:gmatch(",%s-(.-),") do
        print(eval(v, lvars))
    end
end
rank["if.-{.-}%s-elseif"] = 2

local ops, opProc = {}, {}

ops["="] = "$([%w_]+)%s-=%s-([^;]+);"
opProc["="] = function(lvars, var, val)
    vars[var] = eval(val, lvars)
end

ops["+="] = "$([%w_]+)%s-%+%s-=%s-([^;]+);"
opProc["+="] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."+="..val, "Operation on undefined variable "..var)
        return
    end
    local res = eval(val, lvars)
    if not(tonumber(res)) then
        clError("$"..var.."+="..val, "Operation on numeric $" .. var .. " using non-numeric value")
        return
    end
    vars[var] = vars[var] + eval(val, lvars)
end

ops["++"] = "$([%w_]+)%s-%+%s-%+%s-;"
opProc["++"] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."++", "Operation on undefined variable "..var)
        return
    elseif not tonumber(vars[var]) then
        clError("$"..var.."++", "Numeric operation on variable "..var .. " of non-numeric type " .. type(vars[var]))
        return
    end
    vars[var] = vars[var] + 1
end

ops["-="] = "$([%w_]+)%s-%-%s-=%s-([^;]+);"
opProc["-="] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."-="..val, "Operation on undefined variable "..var)
        return
    elseif not tonumber(vars[var]) then
        clError("$"..var.."+="..val, "Numeric operation on variable "..var .. " of non-numeric type " .. type(vars[var]))
        return
    end
    local res = eval(val, lvars)
    if not(tonumber(res)) then
        clError("$"..var.."-="..val, "Operation on numeric $" .. var .. " using non-numeric value")
        return
    end
    vars[var] = vars[var] + eval(val, lvars)
end

ops["--"] = "$([%w_]+)%s-%-%s-%-%s-;"
opProc["--"] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."--", "Operation on undefined variable "..var)
        return
    elseif not tonumber(vars[var]) then
        clError("$"..var.."++", "Numeric operation on variable "..var .. " of non-numeric type " .. type(vars[var]))
        return
    end
    vars[var] = vars[var] - 1
end

ops[".="] = "$([%w_]+)%s-%.%s-=%s-([^;]+);"
opProc[".="] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var..".="..val, "Operation on undefined variable "..var)
        return
    end
    vars[var] = tostring(vars[var]) .. tostring(eval(val, lvars))
end

local preProc, preFunc = {}, {}
preProc.def = "def%s-(%S+)%s+([^\n]+)"
preFunc.def = function(src, n, v)
    return src:gsub("@" .. n, v)
end

local func = {}
_RETURNSTACK ={}

key["function"] = "function%s-(%w-)%s-:%s-(.-)(%b{});"
proc["function"] = function(lvars, name, args, src)
    local s = "return function("
    args = trim(args:gsub("%s", "") .. ",")
    local a = {}
    for arg in args:gmatch("([^,]-),") do
        --s = s .. arg .. ","
        table.insert(a, arg)
    end
    s = s .. table.concat(a, ",") .. ")\nlocal lvars = {}\n"
    for i, v in ipairs(a) do
        s = s .. "lvars['" .. v .. "']=" .. v .. "\n"
    end
    s = s .. "parse([[" .. src:sub(2, -2) .. "]], lvars)\n return _RETURN end"
    --print(s)
    local f, err = loadstring(s)
    if f then
        func[name] = f()
    else
        print(err)
    end
end

func.print = function(lvars, ...)
    local t = {}
    for i, v in ipairs{...} do
        table.insert(t, eval(v, lvars))
    end
    print(unpack(t))
end

func.set = function(lvars, name, val)
    vars[name] = val
end

func.lua = function(lvars, s) return loadstring(s:gsub("vars", "({...})[1]"))(vars) end

getFunc = function(n) return func[n] end

CL_LOC = ""

function clError(loc, msg)
    print('Error: ' .. loc .. '\n' .. msg)
end

function eval(statement, lvars)
    statement = tostring(statement)
    lvars = lvars or {}
    local value
    for i, v in pairs(lvars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    for i, v in pairs(vars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    --[[
    string.gsub(statement, "([%w_]+)%s-(%b%(%))", function(active, argStr)
        local args = {}
        for arg in argStr:gmatch("([^,]-),") do
            arg = trim(arg)
            arg = eval(arg, lvars) or arg
            table.insert(args, arg)
        end
        if func[active] then
            local r = func[active](unpack(args))
            return r or ""
        end
    end)
    --]]
    statement = string.gsub(statement, "([%w_]+)%s-(%b())", "(getFunc('%1'))%2")
    local f, err = loadstring("return " .. statement)
    local s, val = pcall(f)
    if not err then value = val or statement else value = statement end
    return value
end

function isTrue(statement, lvars)
    statement = tostring(statement)
    lvars = lvars or {}
    local value
    for i, v in pairs(lvars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    for i, v in pairs(vars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    statement = statement:gsub("([%w_]-)%s-(%b%(%))", function(active, argStr)
        local args = {}
        for arg in argStr:gmatch("([^,]-),") do
            arg = trim(arg)
            arg = eval(arg, lvars) or arg
            table.insert(args, arg)
        end
        local r = func[active](unpack(args))
        return r or ""
    end)
    local f, err = loadstring("return " .. statement)
    if not err then value = f() else value = statement end
    return value, err
end

function parse(str, lvars)
    for i, v in pairs(preProc) do
        --print(preFunc[i])
        str = str:gsub(v, preFunc[i])
    end
    lvars = lvars or {}
    while str:match("  ") do
        str = str:gsub("  ", " ")
    end
    str = str:gsub("%[#.-#%]", "")
    str = str:gsub("##.-\n", "")
    local pos = 0
    local p = true
    while (pos < #str) and p do
        local active = str:sub(pos, str:find("[^%w_]", pos) -1)
        if str:sub(pos, pos+1):find("%s") then
            pos = pos + 1
        elseif str:sub(pos, pos) == "$" then
            for i, v in pairs(ops) do
                if str:find(v, pos) == pos then
                    local opStr = trim(str:sub(pos, str:find(";", pos + 1)))
                    opProc[i](lvars, opStr:gmatch(ops[i])())
                    pos = str:find(";", pos + 1)
                end
            end
        elseif key[active] and str:find(key[active], pos-1) == pos then
            local b, e = str:find(key[active], pos-1)
            proc[active](lvars or {}, str:gmatch(key[active], pos-1)())
            pos = pos + e - b
        elseif func[active] then
            local argStr = (str:match("%b()", pos):sub(2, -2) .. ","):gsub(",%s+", ",")
            local args = {}
            local aPos, aCount, aCurrent, aLevel, aLChar = 1, 1, "", 0, ""
            local aChars = {["("] = ")", ["{"] = "}"}
            --[[
            for arg in argStr:gmatch("([^,]-),") do
                arg = trim(arg)
                arg = eval(arg, lvars) or arg
                table.insert(args, arg)
            end
            --[=[
            --]]
            local aStr = ""
            --print(argStr)
            while aPos <= #argStr do
                local cc = argStr:sub(aPos, aPos)
                aStr = aStr .. cc .. ": level " .. aLevel .. ", end " .. aLChar .. "\n"
                if cc == "(" or cc == "{" then
                    aLevel = aLevel + 1
                    aLChar = aChars[cc]
                    aCurrent = aCurrent .. cc
                elseif cc == aLChar then
                    aLevel = aLevel - 1
                    aCurrent = aCurrent .. cc
                    aLChar = ""
                elseif cc == "," and aLevel == 0 then
                    table.insert(args, aCurrent)
                    --print("Arg: ", aCurrent)
                    aCurrent = ""
                    aPos = aPos + 1
                else
                    aCurrent = aCurrent .. cc
                end
                --print(cc)
                aPos = aPos + 1

            end
            --print(aStr)
            --print(table.concat(args, "; "))
            func[active](lvars, unpack(args))
            pos = str:find("%)%s-;", pos+1) + 1
        else
            local r, match = -1, ""
            for i, v in pairs(key) do
                local b, e = str:find(v, pos-1)
                if (b == pos) and e then
                    if rank[i] > r then
                        r = rank[i]
                        match = i
                    end
                end
            end
            if r == -1 then
                pos = pos + 1
            else
                --print("match")
                local b, e = str:find(key[match], pos-1)
                proc[match](lvars or {}, str:gmatch(key[match], pos-1)())
                pos = pos + e - b
                match = true
            end
        end
        --[[
        _LOG = (_LOG or "") .. str:sub(1, pos-1) .. "#" .. str:sub(pos+1, -1) .. "\n\n"
        saveProjectTab("Log", "--[=[" .. _LOG .. "--]=]")
        --]]
    end
end