tur

-- api

os.loadAPI("config")
pos = {}
local conf = config.new(".apidata", "Turtle API Data")

-- internal functions

-- returns 1 if positive, -1 if negative, or 0 if 0
local function sign(n)
    return n > 0 and 1 or (n < 0 and -1 or 0)
end

-- recieves case/command pairs in {}s, optional default value
-- ie switch(dir, {"up", "placeUp"}, {"down", "placeDown"}, "place")
local function switch(exp, ...)
    local args = {...}
    local def = table.remove(args)
    for pair, case in ipairs(args) do
        if exp == case[1] then
            return case[2]
        end
    end
    return def
end

local function isint(n)
    return type(n) == "number" and (math.modf(n) == n)
end

-- errors msg if any expression in ... fails
local function check(msg, ...)
    for _, exp in pairs({...}) do
        if not exp then
            error(msg, 2)
        end
    end
end

local function init()
    conf:load()
    if conf:containsKey("loaded") then
        conf:setBoolean("loaded", true)
        local input = {x = nil, y = nil, z = nil, f = nil}
        for k, _ in ipairs(input) do
            write("Enter current "..k)
            input[k] = read()
            pos[k] = input[k]
            conf:setNumber(k, input[k])
            term.clearLine()
        end
    else
        pos.x = conf:getNumber("x")
        pos.y = conf:getNumber("y")
        pos.z = conf:getNumber("z")
        pos.f = conf:getNumber("f")
    end
    conf:save()
end

-- syncs the storage file with the locally stored position data
local function fupdate()
    init()
    conf:load()
    for k, v in ipairs(pos) do
        conf:setNumber(k, v)
    end
    conf:save
end

-- turns left or right f times
-- -f = left, +f = right
-- @return new_f
local function fturn(f)
    init()
    for rep = 1, math.abs(f) do
        turtle[f > 0 and "turnRight" or "turnLeft"]()
        pos.f = switch(pos.f + sign(f), {5, 1}, {0, 4}, pos.f + sign(f))
        fupdate()
    end
    return pos.f
end

-- moves x, y, z on each axis
-- @return [true + new_coords or false + error]
local function fmove(x, y, z)
    local axes = {
        x = {x, "forward", "back"};
        y = {y, "forward", "back"};
        z = {z, "up", "down"};
    }
    init()
    for axis, data in ipairs(axes) do
        for rep = 1, math.abs(data[1]) do
            if turtle[sign(data[1]) > 0 and data[2] or data[3]]() then
                pos[axis] = sign(data[1])
                fupdate()
            else
                return false, "Failed move "..rep.." of "..math.abs(data[1])
            end
        end
    end
    return true, pos
end

-- external functions

-- turns left or right
-- @return new_f
function turn(d, r)
    check("Expected 'left' or 'right', got "..d, d == "left" or d == "right")
    check("Expected a positive integer, got "..r, type(r) == "number", r > 0, isint(r))
    init()
    d = d == "left" and -1 or 1
    r = r % 4 == 3 and -1 or r % 4
    fturn(r * d)
    return pos.f
end

-- sets direction to f
-- @return new_f
function setf(f)
    check("Expected an integer between 1 and 4, got "..f, f >= 1, f <= 4, isint(f))
    init()
    if f ~= pos.f then
        turn(sign(f - pos.f) == 1 and "right" or "left", math.abs(f - pos.f))
    end
    return pos.f
end

-- moves x, y, z on each axis and turns to f
-- @return success + [new_coords or error]
function move(x, y, z, f)
    check("Expected an integer, got "..(isint(x) and (isint(y) and z or y) or x), isint(x), isint(y), isint(z))
    check("Expected an integer between 1 and 4, got "..f, f > 1, f < 4, isint(f))
    init()
    local ok, err = fmove(x, y, z)
    setf(f)
    return ok, ok and pos or err
end

-- moves to the specified coords and turns to f
-- @return success + [new_coords or error]
function goto(x, y, z, f)
    check("Expected an integer, got "..(isint(x) and (isint(y) and z or y) or x), isint(x), isint(y), isint(z))
    check("Expected an integer between 1 and 4, got "..f, f > 1, f < 4, isint(f))
    init()
    return move(x - pos.x, y - pos.y, z - pos.z, f)
end

-- places the item in slot s in direction d (defaults to front)
-- @return success + remaining_items
function place(s, d)
    check("Expected an integer between 1 and 16, got "..s, type(s) == "number", s >= 1, s <= 16)
    check("Expected 'front', 'up', or 'down', got "..d, d == "front" or d == "up" or d == "down")
    init()
    d = switch(d, {"up", "placeUp"}, {"down", "placeDown"}, "place")
    turtle.select(s)
    return turtle[d](), turtle.getItemCount(s)
end

-- resets the coordinates and direction
-- @return old_pos
function reset(x, y, z, f)
    check("Expected an integer, got "..(isint(x) and (isint(y) and z or y) or x), isint(x), isint(y), isint(z))
    check("Expected an integer between 1 and 4, got "..f, f > 1, f < 4, isint(f))
    init()
    local old = pos
    pos.x = x
    pos.y = y
    pos.z = z
    pos.f = f
    fupdate()
    return old
end

-- syncs with the position data in the persistance file
function sync()
    init()
    conf:load()
    pos.x = conf:getNumber("x")
    pos.y = conf:getNumber("y")
    pos.z = conf:getNumber("z")
    pos.f = conf:getNumber("f")
    conf:save()
end