--LootRepair 0.9
--by Shadow_8472
--This program intended for use on crafty turtle.
--The basic operation:
--0 a repairable item goes in slot 1
--1 item arrives in slot 1
--2 turtle compares slot 1 and 2
--3 if base items mismatch, reject slot 2
--4 if base items matches, reject stray items in slots 3-16 and craft
--5 if slot 1 is in new condition, accept it when a new base item comes in
--6 move new item to slot 1
--7 if errors arise, they propagate upstream (item flow) to the last sorter turtle
--Program takes inventory of the situation and
--the main loop acts on that state.

--configuration variables
local upstream = "top"
local aDownstream = "front"
local rDownstream = "bottom"

----------------------------------------------------------------------
local function evalItem(n)
	--returns a two bit code designating item slot as empty, valid, or bad
		--key sym meaning		flag code
		-- 0 Empty				00
		-- G Good or New		01
		-- X Bad				10
		-- _ Non-empty 			11
		-- ? Unobserved			n/a
		
	if turtle.getItemCount(n) == 0 then--no item
		return 0
	elseif turtle.getItemDetail(n)["maxStackSize"] > 1 then--stackable
		return 2
	elseif turtle.getItemDetail(n)["lifeMaxDuration"] == 0 then--not damageable
		return 2
	else--good item
		return 1
	end
end

--ItemOut, (int, string)
--outputs: bool: success/failure of appropriate turtle.drop() variant
local function itemOut(slot, out1) --(int,string)
	--This function outputs item to either accept or reject paths.
	--Though not used now, this function facilitates dynamic item
	--accept/reject paths. I suppose, if more outputs were needed,
	--they could be added via the first if else statement.
	if out1 == "accept" then--sort between accept and reject mode.
		out = aDownstream
	elseif out1 == "reject" then
		out = rDownstream
	else
		print("Invalid term: "..out1)
		return false--this function designed for only "accept" or "reject"
	end
	
	local mx = 10--number of times to try to output before declaring a failure
	local rt = false--variable rt is the return value saved for console report
	turtle.select(slot)
	for n = 1, mx do--try a few times 
		if rs.getAnalogueInput(out) > 0 then
			--do nothing
		elseif out == "top" then--sort between each of the six faces of a turtle, rotate if need be
			rt = turtle.dropUp()
		elseif out == "front" then
			rt = turtle.drop()
		elseif out == "bottom" then
			rt = turtle.dropDown()
		elseif out == "left" then--elseif statements past here for forward compatibility
			turtle.turnLeft()
			rt = turtle.drop()
			turtle.turnRight()
		elseif out == "right" then
			turtle.turnRight()
			rt = turtle.drop()
			turtle.turnLeft()
		elseif out == "back" then
			turtle.turnLeft()
			turtle.turnLeft()
			rt = turtle.drop()
			turtle.turnLeft()
			turtle.turnLeft()
		else--else statement more for a debug POV.
			print("error: "..out.." is an invalid destination.")
			return false
		end
		
		--console report
		if rt then
			print("Item in slot "..slot.." "..out1.."ed.")
			break
		else--rt is false
			if n < mx then
				os.sleep(.1)
			else
				print("Item in slot "..slot.." could not be "..out1.."ed.")
				rs.setAnalogueOutput(upstream, 15)--call for help
			end
		end
	end
	return rt
end

----------------------------------------------------------------------
--getState()
--outputs: string: state of turtle
local function getState()
	--state variables
		--redstone
			--rs downlines in
		--inventory
			--slot 1
			--slot 2
			--slots 3-16
	--possible states
		--    State Name					code			visual	state#
		--Error States (These states call user for maintenance)
			--Pass ERROR Signal				"passError"		ERR		1
			--No Items						"noItems"		000		9
			
		--Core Operational States
			--Bad Item in Slot 2			"bad2"			GX_		3
			--Just a Good Item in slot 1	"good1"			G0_		4
			--Just a Good Item in slot 2	"good2"			0G_		5
			--New in 1 and good in 2		"accept"		NG_		6
			--Just Good in 1 and 2			"craft"			GG0		7
			
		--Variant states (These states are logical variants of important states)
			--Bad Item in Slot 1			"bad1"			X__		2
			
		--Other states (Usually through a bug or user interference)
			--No crafting table				""
			--Item in Wrong Place			"wrongSlot"		__?		8
		
	local rs = bit32.bor(rs.getAnalogueInput(aDownstream), rs.getAnalogueInput(rDownstream))--get redstone downlines
	local flags = 0--variable to hold three 2 bit flags:
		--slot 3  slot 2  slot 1
		--__      __      __
	if rs == 15 then
		--Pass ERROR Signal upstream
		return "passError"
	end
	
	--cycle through slots and assign flags
	for n = 1,16 do
		if n <= 2 then--if n == 1 or 2
			if turtle.getItemCount(n) > 0 then
				--Set flags for each slot filled. If flags show up ready for crafting, then craft.
				flags = flags + bit32.lshift(evalItem(n), 2*(n-1))--
				if  bit32.band(bit32.rshift(flags, 2*(n-1)), 3) == 2 then--look for item flagged as bad
					--Bad Item in Slot 1
					--Bad Item in Slot 2
					return "bad"..n
				elseif flags == 5 and turtle.getItemDetail(1)["name"] ~= turtle.getItemDetail(2)["name"] then --
					--Bad Item in Slot 2
					return "bad2"
				end--else good item; move on
			end--else do nothing, no item; move to next slot.
		elseif 2 < n then
			if turtle.getItemCount(n) ~= 0 then
				--Item in Wrong Place
				flags = flags + 48--48 = bit32.lshift(3, 2*(n-1)) for n = slot 3
				break--
			end
		end
	end
	
	--evaluate flags
	if bit32.band(flags, 15) == 1 then --check for G0? configuration
		--Just a Good Item in Slot 1
		return "good1"
	elseif bit32.band(flags, 15) == 4 then--check flags for slot 1 and 2.
		--Just a Good Item in Slot 2
		return "good2"
	elseif bit32.band(flags, 15) == 5 then--special case: good items in both 1 and 2
		--wrongSlot	__?
		--accept	NG_
		--craft		GG0
		if turtle.getItemDetail(1)["damage"] > 0 then
			--slot 1 good but not new
			if flags == 5 then--5 = b00 01 01
				--good in 1 and 2, all others empty
				return "craft"
			else--flag 3 must be set to "something else"
				--good in 1 and 2, but something else present
				return "wrongSlot"
			end
		else--new in 1 and good in 2
			return "accept"
		end
	elseif flags == 0 then--flags should only be 0 or more
		--No Items
		return "noItems"
	end--no else, n has no business outside 1 and 16
	return "error"
end

--startup()
rs.setAnalogueOutput(upstream, 1)
while not pcall(turtle.craft, 0) do--try to craft zero items. Loop will break when crafting table is present.
	print("Crafting table not detected.")
	local slot = 0--empty slot tracker
	for n = 1,17 do
		if n == 17 then
			if slot > 0 then--workable slot found
				turtle.select(slot)--refresh turtle memory of right slot
				turtle.equipRight()
				turtle.equipRight()
				if not pcall(turtle.craft, 0) then--check for table with right slot refreshed
					print("No crafting table available in inventory or equipped.")--call error mode
				else
					print("Crafting table located, was already equipped.")--may be in either left or right.
					break--break n loop and skip error and user call.
				end
			else--slot == 0
				print("No available slots to check equipment.")
			end
			rs.setAnalogueOutput(upstream, 15)--extend error
			os.pullEvent("turtle_inventory")--wait
			rs.setAnalogueOutput(upstream, 1)--retract error
			--go to repeat startup loop
		else--loops 1-16
			turtle.select(n)--select n
			if turtle.equipLeft() then--search for 
				--workable slot found
				if pcall(turtle.craft, 0) then
					--crafting table found and curently equipped
					print("Crafting table located and equipped.")
					break--break n loop, back to startup loop
				else
					turtle.equipLeft()--restore equipped item to the left; also refreshes left slot
					slot = n--overwrites for every valid slot found.
				end
			end
		end
	end
end--startup() end

--main()
local event = false --Controls if turtle should wait for an event
local state = "start"
while true do
	state = getState()
	turtle.select(2)
	print("Program state: "..state..".")--output state to console.
	--if state == template then
		--rs upstream = 
		--some code
		--event = true, false, or function
		--logical next states:
			--state1
			--...
	--end
	
	--error states
	if state == "passError" then--problem down stream, pass it upstream.
		rs.setAnalogueOutput(upstream, 15)
		event = true--wait for user
		--next logical states:
			--anything after user action
			
	elseif state == "noItems" then
		rs.setAnalogueOutput(upstream, 15)
		event = true--wait for user
		--logical next states:
			--good1 after user action
			--bad1 after user misaction
	
	--Core Operational States
	elseif state == "good1" then--just a good item in 1
		rs.setAnalogueOutput(upstream, 0)
		event = true--wait for item
		--logical next states:
			--accept
			--bad2
			--craft
	
	elseif state == "bad2" then--just a bad item in 2
		rs.setAnalogueOutput(upstream, 1)
		event = not itemOut(2, "reject")--wait if cannot be immediately output
		--logical next states:
			--good1
			--new1
	
	elseif state == "craft" then--good item in slot 1 and slot 2
		rs.setAnalogueOutput(upstream, 1)
		turtle.select(1)
		event = not turtle.craft()--wait if and until item can be output
		--logical next states:
			--good1
			--new1
	
	elseif state == "accept" then--don't output 
		rs.setAnalogueOutput(upstream, 1)
		event = not itemOut(1, "accept")--wait if and until item can be output
		--logical next events
			--accept
			--good2
	
	elseif state == "good2" then--just a good/new item in 2
		rs.setAnalogueOutput(upstream, 1)
		turtle.select(2)--move slot 2 to slot 1
		turtle.transferTo(1)
		event = false--don't wait
		--logical next states:
			--good1
			--new1
	
	--Variant states (These states are logical variants of important states)
	elseif state == "bad1" then--just a bad item in 1
		rs.setAnalogueOutput(upstream, 1)
		event = not itemOut(1, "reject") --wait if and until item can be output
		--logical next states:
			--noItem
	
	--Other states (Usually through a bug or user interference)
	elseif state == "wrongSlot" then
		rs.setAnalogueOutput(upstream, 1)
		--more complex code in future version should explore good items.
		event = false
		for n = 3,16 do--reject slots 3-16
			if turtle.getItemCount(n) > 0 then
				if not itemOut(n, "reject") then
					event = true--flag event pull
					rs.setAnalogueOutput(upstream, 15)--call operator
					break--Reject plugged. No sense in trying the rest.
				end
			end
		end
		--logical next states:
			--Any Core state
			--noItems
	
	else--invalid state
		rs.setAnalogueOutput(upstream, 15)
		print("State: "..state.. " not programmed into main loop.")
		event = true --wait for user
		--logical next states:
			--Anything
	end
	if event then
		os.sleep(.05)--this line due to a ComputerCraft glitched null event triggered when bad2 or <forgotten> states are triggered.
		os.pullEvent()
	end
end