#..
    This File contains actions for making actions and compile-time actions and some helper
    functions to make that easier.

# Helper function
immediately
    lua> ".."
        nomsu.parse_spec = function(nomsu, spec)
            if spec.type == 'List' then
                local names = {};
                for i, alias in ipairs(spec.value) do
                    if alias.type == "FunctionCall" then
                        names[i] = alias.src;
                    elseif alias.type == "Text" then
                        names[i] = nomsu:tree_to_value(alias);
                    end
                end
                local junk, arg_names, junk = nomsu:get_stub(names[1]);
                local args = {};
                for i, a in ipairs(arg_names) do args[i] = nomsu:var_to_lua_identifier(a); end
                return names, args;
            else
                local alias = nomsu:tree_to_value(spec);
                local junk, arg_names, junk = nomsu:get_stub(alias);
                local args = {};
                for i, a in ipairs(arg_names) do args[i] = nomsu:var_to_lua_identifier(a); end
                return {alias}, args;
            end
        end

# Compile-time action to make compile-time actions:
# TODO: reduce code duplication here
immediately
    lua> ".."
        do
            local function compile_to(name_tree, body_tree, kind)
                local names, args = nomsu:parse_spec(name_tree);
                local declared_locals = {};
                for i, arg in ipairs(args) do declared_locals[arg] = true; end
                names, args = repr(names), table.concat(args, ", ");
                local body_lua = nomsu:tree_to_lua(body_tree);
                if body_lua.expr and not body_lua.locals then
                    return [[
        nomsu:define_compile_action(]]..names..[[, ]]..repr(name_tree:get_line_no())..[[, function(]]..args..[[)
            return {]]..kind..[[=]]..body_lua.expr..[[};
        end, ]]..repr(nomsu:source_code())..[[);
        ]];
                end
                local body_code = body_lua.statements or ("return "..body_lua.expr..";");
                local undeclared_locals = {};
                for i, body_local in ipairs(body_lua.locals or {}) do
                    if not declared_locals[body_local] then
                        table.insert(undeclared_locals, body_local);
                    end
                end
                if #undeclared_locals > 0 then
                    body_code = "local "..table.concat(undeclared_locals, ", ")..";\\n"..body_code;
                end
                return [[
        do
            local function compile_action(]]..args..[[)
                ]]..body_code.."\\n"..[[
            end
            nomsu:define_compile_action(]]..names..[[, ]]..repr(name_tree:get_line_no())..[[, function(]]..args..[[)
                return {]]..kind..[[=compile_action(]]..args..[[)};
            end, ]]..repr(nomsu:source_code())..[[);
        end]];
            end
            local src = \(__src__ 1);
            nomsu:define_compile_action("compile %names to %body", \(__line_no__), function(\%names, \%body)
                return {statements=compile_to(\%names, \%body, "expr")};
            end, src);
            nomsu:define_compile_action("compile %names to code %body", \(__line_no__), function(\%names, \%body)
                return {statements=compile_to(\%names, \%body, "statements")};
            end, src);
        end

# Compile-time action to make actions
immediately
    compile [action %names %body] to code
        lua> ".."
            local names, args = nomsu:parse_spec(\%names);
            local declared_locals = {};
            for i, arg in ipairs(args) do declared_locals[arg] = true; end
            names, args = repr(names), table.concat(args, ", ");
            local body_lua = nomsu:tree_to_lua(\%body);
            local body_code = body_lua.statements or ("return "..body_lua.expr..";");
            local undeclared_locals = {};
            for i, body_local in ipairs(body_lua.locals or {}) do
                if not declared_locals[body_local] then
                    table.insert(undeclared_locals, body_local);
                end
            end
            if #undeclared_locals > 0 then
                body_code = "local "..table.concat(undeclared_locals, ", ")..";\\n"..body_code;
            end
            local src = nomsu:dedent(nomsu:source_code(0));
            local def_lua = ([[
            nomsu:define_action(%s, \(__line_no__), function(%s)
                %s
            end, %s);]]):format(names, args, body_code, repr(src));
            return def_lua;

# Macro to make nomsu macros:
immediately
    lua> ".."
        nomsu:define_compile_action("parse %shorthand as %longhand", \(__line_no__), (function(\%shorthand, \%longhand)
            local names, args = nomsu:parse_spec(\%shorthand);
            names, args = repr(names), table.concat(args, ", ");
            local template;
            if \%longhand.type == "Block" then
                template = {};
                for i, line in ipairs(\%longhand.value) do
                    template[i] = nomsu:dedent(line.src);
                end
                template = repr(table.concat(template, "\\n"));
            else
                template = repr(nomsu:dedent(\%longhand.src));
            end
            local junk, arg_names, junk = nomsu:get_stub(\%shorthand.value[1]);
            local replacements = {};
            for i, a in ipairs(arg_names) do replacements[i] = "["..repr(a).."]="..nomsu:var_to_lua_identifier(a); end
            replacements = "{"..table.concat(replacements, ", ").."}";
            local lua_code = ([[
        nomsu:define_compile_action(%s, %s, (function(%s)
            local template = nomsu:parse(%s, %s);
            local replacement = nomsu:tree_with_replaced_vars(template, %s);
            return nomsu:tree_to_lua(replacement);
        end), %s)]]):format(names, repr(\%shorthand:get_line_no()), args, template,
            repr(\%shorthand:get_line_no()), replacements, repr(nomsu:source_code(0)));
            return {statements=lua_code};
        end), \(__src__ 1));

action [remove action %stub]
    lua> ".."
        local fn = ACTIONS[\%stub];
        local metadata = ACTION_METADATA[fn];
        for i=#metadata.aliases,1,-1 do
            metadata.arg_orders[metadata.aliases[i]] = nil;
            table.remove(metadata.aliases, i);
        end
        ACTIONS[\%stub] = nil;

immediately
    action [%tree as lua]
        =lua "nomsu:tree_to_lua(\%tree).expr"
    action [%tree as lua statements]
        lua> ".."
            local lua = nomsu:tree_to_lua(\%tree);
            return lua.statements or (lua.expr..";");
    action [%tree as value]
        =lua "nomsu:tree_to_value(\%tree)"
    compile [repr %obj] to
        "repr(\(%obj as lua))"
    compile [type of %obj] to
        "type(\(%obj as lua))"

immediately
    parse [lua do> %block] as
        lua> "do"
        lua> %block
        lua> "end"

compile [nomsu] to "nomsu"

compile [nomsu's %key] to "nomsu[\(%key as lua)]"
compile [nomsu %method %args] to "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))"
compile [tree %tree with %replacements] to ".."
    nomsu:tree_with_replaced_vars(\(%tree as lua), \(%replacements as lua))

action [action %names metadata]
        =lua "ACTION_METADATA[ACTIONS[\%names]]"

# Get the source code for a function
action [help %action]
    lua> ".."
        local metadata = \(action %action metadata);
        if not metadata then
            nomsu:writeln("Action not found: "..repr(\%action));
        else
            nomsu:writeln(metadata.src or "<unknown source code>");
        end

# Compiler tools
parse [run %code] as: nomsu "run" [%code]
parse [enable debugging] as: lua> "nomsu.debug = true"
parse [disable debugging] as: lua> "nomsu.debug = false"

compile [say %message] to
    lua> ".."
        if \%message.type == "Text" then
            return "nomsu:writeln("..\(%message as lua)..")";
        else
            return "nomsu:writeln(stringify("..\(%message as lua).."))";
        end

# Error functions
compile [barf!] to "error(nil, 0)"
compile [barf %msg] to "error(\(%msg as lua), 0)"
compile [assume %condition] to "assert(\(%condition as lua))"
compile [assume %condition or barf %msg] to "assert(\(%condition as lua), \(%msg as lua))"

# Literals
compile [yes] to "true"
compile [no] to "false"
compile [nothing, nil, null] to "nil"