enderchest = peripheral.wrap("top")
chest = peripheral.wrap("bottom")
inventory = peripheral.wrap("right")

info = {
    max_height = 19
}

me = {
    column = 0,
    level = -1,
    direction = 0
}

positions = {
    last_position = {
        column = 0,
        level = 0,
        direction = 0
    },
    open_positions = {}
}

chests = {
    todeposit = {"black","orange","black"},
    mistakes = {"black","black","red"}
}

function go_to(target)
    if me.column ~= target.column then
        local new_target = {column = me.column}
        local up_distance = (info.max_height - me.level) + (info.max_height - target.level)
        local down_distance = me.level + target.level
        if up_distance < down_distance then
            new_target.level = info.max_height + 1
        else
            new_target.level = 0
        end
        if me.column < target.column then
            new_target.direction = 2
        else
            new_target.direction = 0
        end
        go_to(new_target)
        for i = me.column * 3, target.column * 3 - 1 do
            while not turtle.forward() do
                turtle.dig()
            end
        end
        me.column = target.column
    end
	while me.level < target.level do
		if turtle.up() then
            me.level = me.level + 1
        else
            turtle.digDown()
        end
    end
	while me.level > target.level do
		if turtle.down() then
            me.level = me.level - 1
        else
            turtle.digDown()
        end
	end
    if me.direction == (target.direction + 1) % 4 then
        turtle.turnLeft()
        me.direction = target.direction
    else
        while me.direction ~= target.direction do
            turtle.turnRight()
            me.direction = (me.direction + 1) % 4
        end
    end
end

function position_after(position)
    local new_position = {}
    if position.direction == 3 then
        new_position.direction = 0
        if position.level == info.max_height then
            new_position.level = 0
            new_position.column = position.column + 1
        else
            new_position.level = position.level + 1
        end
    else
        new_position.direction = position.direction + 1
    end
    return new_position
end

function next_open_position()
    if #positions.open_positions > 0 then
        local position = {positions.open_positions[1], 1}
        for i = 2, #positions.open_positions do
            if positions.open_positions[i].column > position[1].column
            or positions.open_positions[i].level > position[1].column
            or positions.open_positions[i].direction > position[1].direction then
            else
                position = {positions.open_positions[i], i}
            end
        end
        table.remove(positions.open_positions, position[2])
        return position[1]
    else
        local position = positions.last_position
        positions.last_position = position_after(position)
        return positions.last_position
    end
end

function place_enderchest(group)
    turtle.select(1)
    while not turtle.placeUp() do
        turtle.down()
        me.level = me.level - 1
    end
    enderchest.setColorNames(group[1],group[2],group[3])
end

function same_item(item, stack)
    return item.string_id == stack.string_id
end

function safe_string(text)
    local new_text = {}
    for i = 1, #text do
        local val = string.byte(text, i)
        new_text[i] = (val > 31 and val < 127) and val or 32
    end
    return string.char(unpack(new_text))
end

function is_registered(stack)
    stack.string_id = safe_string(stack.id..stack.dmg..stack.raw..stack.display)
    for _, item in ipairs(items) do
        if same_item(item, stack) then
            return item
        end
    end
end

function register(stack)
    local item = is_registered(stack)
    if not item then
        item.string_id = stack.string_id
        item.damage = stack.dmg
        item.max_damage = stack.max_dmg
        item.max_stack = stack.max_size
        item.recipes = {}
        item.quantity = 0
        item.position = next_open_position()
    end
    return item
end

function check_items_to_sort()
    local items_to_sort = {}
    local inventory_items = inventory.getAllStacks()
    for i = 2, #inventory_items do
        table.insert(items_to_sort, register(inventory_items[i].basic()))
    end
    local enderchest_items = enderchest.getAllStacks()
    for _, item in ipairs(enderchest_items) do
        table.insert(items_to_sort, register(item.basic()))
    end
    return items_to_sort
end

function distance_away(position)
    local distance = 0
    local up_distance = (info.max_height - me.level) + (info.max_height - position.level)
    local down_distance = me.level + position.level
    distance = distance + min(up_distance, down_distance)
    distance = distance + 3 * (me.column)
    if up_distance < down_distance then
        new_position.level = info.max_height + 1
    else
        new_position.level = 0
    end
end

function sort_order(item_1, item_2)
    return distance_away(item_1.position) > distance_away(item_2.position)
end

function sort_inventory(items_to_sort)
    local inventory_items = inventory.getAllStacks()
    for i = 2, #inventory_items do
        inventory_items[i].slot = i
    end
    table.sort(items_to_sort, sort_order)
    return items_to_sort
end

function slice(table, first, last)
    local sliced = {}
    for i = first, math.min(last, #table) do
        table.insert(sliced, table[i])
    end
    return sliced
end

function deposit_item(item)
    go_to(item.position)
    turtle.select(item.slot)
    local start_amount = turtle.getItemCount()
    turtle.drop()
    item.quantity = item.quantity + start_amount - turtle.getItemCount()
end

function store_mistakes()
    inventory.condenseItems()
    local stacks = inventory.getAllStacks()
    if #stacks > 1 then
        place_enderchest(chests.mistakes)
    end
    for i = 2, #stacks do
        turtle.select(i)
        turtle.dropUp()
    end
end

function begin_sorting(total_items_to_sort)
    local items_to_sort = slice(total_items_to_sort, 1, 15)
    total_items_to_sort = slice(total_items_to_sort, 16, #total_items_to_sort)
    while #items_to_sort > 0 do
        closest_item = sort_inventory(items_to_sort)[#items_to_sort]
        deposit_item(closest_item)
        table.remove(items_to_sort)
    end
    store_mistakes()
end

function begin_depositing()
    inventory.condenseItems()
    chest.condenseItems()
    local chest_item_amount = #chest.getAllStacks()
    while chest_item_amount > 0 or #inventory.getAllStacks() > 1 do
        while turtle.suckDown() do
        end
        if chest_item_amount > 0 then
            place_enderchest(chests.todeposit)
            while turtle.suckDown() do
                if not turtle.dropUp() then
                    turtle.dropDown()
                    break
                end
            end
        end
        local items_to_sort = check_items_to_sort()
        begin_sorting(items_to_sort)
        chest.condenseItems()
        chest_item_amount = #chest.getAllStacks()
    end
end

while true do
    command = io.read()
    if command == ">" then
        begin_depositing()
    end
end