-- Variable Setup
-- Command Line input Table
local argTable = {...}

-- Flag Variables: These are conditions for different features (all flags are named foo_bar, all other variables are named fooBar)
local cmd_line = false
local cmd_line_resume = false
local cmd_line_cost_only = false
local chain_next_shape = false -- This tells goHome() where to end, if true it goes to (0, 0, positionZ) if false it goes to (-1, -1, 0)
local special_chain = false -- For certain shapes that finish where the next chained shape should start, goHome() will  only turn to face 0 if true
local cost_only = false
local sim_mode = false
local stepUp = false

-- Record Keeping Variables: These are for recoding the blocks and fuel used
local blocks = 0
local fuel = 0
local crescentSlot = 15

-- Position Tracking Variables: These are for keeping track of the turtle's position
local positionX = 0
local positionY = 0
local positionZ = 0
local facing = 0
local gpsPositionX = 0
local gpsPositionY = 0
local gpsPositionZ = 0
local gpsFacing = 0

-- General Variables: Other variables that don't fit in the other categories
local resupply = false
local enderchestRefilling = false
local can_use_gps = false
local returntohome = false -- whether the turtle shall return to start after build
local choice = ""

-- Progress Table: These variables are the tables that the turtle's progress is tracked in
local tempProgTable = {}
local progTable = {} --This is the LOCAL table!  used for local stuff only, and is ONLY EVER WRITTEN when sim_mode is FALSE
local progFileName = "ShapesProgressFile"

-- Utility functions

function writeOut(...) -- ... lets writeOut() pass any arguments to print(). so writeOut(1,2,3) is the same as print(1,2,3). previously writeOut(1,2,3) would have been the same as print(1)
	for i, v in ipairs(arg) do
		print(v)
	end
end

function getInput(inputtype, message, option1, option2)
	local input = ""
	if inputtype == "string" then
		writeOut(message.. "(" ..option1 .. " or "..option2..")" )
		while true do
			input = io.read()
			input = string.lower(input)
			if input ~= option1 and input ~= option2 then
				writeOut("You didn't enter a valid option. Please try again.")
			else
				return input
			end
		end
	end
	if inputtype == "int" then
		writeOut(message)
		while true do
			input = io.read()
			if tonumber(input) ~= nil then
				return tonumber(input)
			else
				writeOut("Need a number. Please try again")
			end
		end
	end
end

function wrapmodules() -- checks for and wraps turtle modules
	local test = 0
	if peripheral.getType("left" )== "resupply" then
		resupplymodule=peripheral.wrap("left")
		resupply = true
	elseif peripheral.getType("right") == "resupply" then
		resupplymodule=peripheral.wrap("right")
		resupply = true
	end
	if peripheral.getType("left") == "modem" then
		modem=peripheral.wrap("left")
		test, _, _ = gps.locate(1)
		if test ~= nil then
			can_use_gps = true
		end
	elseif peripheral.getType("right") == "modem" then
		modem=peripheral.wrap("right")
		test, _, _ = gps.locate(1)
		if test ~= nil then
			can_use_gps = true
		end
	end
	if resupply then
		return "resupply"
	end
end

function linkToRSStation() -- Links to resupply station
	if resupplymodule.link() then
		return true
	else
		writeOut("Please put Resupply Station to the left of the turtle and press Enter to continue")
		io.read()
		linkToRSStation()
	end
end

function compareResources()
	if (turtle.compareTo(1) == false) then
		turtle.drop()
	end
end

function checkResources()
	if resupply then
		if turtle.getItemCount(activeslot) <= 1 then
			while not(resupplymodule.resupply(1)) do
				os.sleep(0.5)
			end
		end
	elseif enderchestRefilling then
		compareResources()
		while (turtle.getItemCount(activeslot) <= 1) do
			if (activeslot == 15) and (turtle.getItemCount(activeslot)<=1) then
				turtle.select(16)
				turtle.digUp()
				for i = 1, 15 do
					turtle.select(i)
					turtle.drop()
				end
				turtle.select(16)
				turtle.placeUp()
				turtle.select(1)
				for i = 1, 15 do
					turtle.suckUp()
				end
				turtle.select(16)
				turtle.digUp()
				activeslot = 1
				turtle.select(activeslot)
			else
				activeslot = activeslot+1
				-- writeOut("Turtle slot empty, trying slot "..activeslot)
				turtle.select(activeslot)
			end
			compareResources()
			os.sleep(0.2)
		end
	else
		compareResources()
		while (turtle.getItemCount(activeslot) <= 1) do
			if (activeslot == 16) and (turtle.getItemCount(activeslot)<=1) then
				writeOut("Turtle is empty, please put building block in slots and press enter to continue")
				io.read()
				activeslot = 1
				turtle.select(activeslot)
			else
				activeslot = activeslot+1
				-- writeOut("Turtle slot almost empty, trying slot "..activeslot)
				turtle.select(activeslot)
			end
			compareResources()
			os.sleep(0.2)
		end
	end
end

function checkFuel()
	if (not(tonumber(turtle.getFuelLevel()) == nil)) then
		while turtle.getFuelLevel() < 50 do
			writeOut("Turtle almost out of fuel, pausing. Please drop fuel in inventory. And press enter.")
			io.read()
			turtle.refuel()
		end
	end
end

function placeBlock()
	blocks = blocks + 1
	simulationCheck()
	if cost_only then
		return
	end
	if turtle.detectDown() and not turtle.compareDown() then
		turtle.digDown()
	end
	checkResources()
	turtle.placeDown()
	progressUpdate()
end

function round(toBeRounded, decimalPlace) -- Needed for hexagon and octagon
	local multiplier = 10^(decimalPlace or 0)
	return math.floor(toBeRounded * multiplier + 0.5) / multiplier
end

-- Navigation functions
-- Allow the turtle to move while tracking its position
-- This allows us to just give a destination point and have it go there

function turnRightTrack()
	simulationCheck()
	facing = facing + 1
	if facing >= 4 then
		facing = 0
	end
	progressUpdate()
	if cost_only then
		return
	end
	turtle.turnRight()
end

function turnLeftTrack()
	simulationCheck()
	facing = facing - 1
	if facing < 0 then
		facing = 3
	end
	progressUpdate()
	if cost_only then
		return
	end
	turtle.turnLeft()
end

function turnAroundTrack()
	turnLeftTrack()
	turnLeftTrack()
end

function turnToFace(direction)
	if direction >= 4 or direction < 0 then
		return false
	end
	while facing ~= direction do
		turnLeftTrack()
	end
	return true
end

function safeForward()
	simulationCheck()
	if facing == 0 then
		positionY = positionY + 1
	elseif facing == 1 then
		positionX = positionX + 1
	elseif facing == 2 then
		positionY = positionY - 1
	elseif facing == 3 then
		positionX = positionX - 1
	end
	fuel = fuel + 1
	progressUpdate()
	if cost_only then
		return
	end
	checkFuel()
	local success = false
	local tries = 0
	while not success do
		success = turtle.forward()
		if not success then
			while (not success) and tries < 6 do
				tries = tries + 1
				turtle.dig()
				success = turtle.forward()
				sleep(0.3)
			end
			if not success then
				writeOut("Blocked attempting to move forward.")
				writeOut("Please clear and press enter to continue.")
				io.read()
			end
		end
	end
end

function safeBack()
	simulationCheck()
	if facing == 0 then
		positionY = positionY - 1
	elseif facing == 1 then
		positionX = positionX - 1
	elseif facing == 2 then
		positionY = positionY + 1
	elseif facing == 3 then
		positionX = positionX + 1
	end
	fuel = fuel + 1
	progressUpdate()
	if cost_only then
		return
	end
	checkFuel()
	local success = false
	local tries = 0
	while not success do
		success = turtle.back()
		if not success then
			turnAroundTrack()
			while turtle.detect() and tries < 6 do
				tries = tries + 1
				if turtle.dig() then
					break
				end
				sleep(0.3)
			end
			turnAroundTrack()
			success = turtle.back()
			if not success then
				writeOut("Blocked attempting to move back.")
				writeOut("Please clear and press enter to continue.")
				io.read()
			end
		end
	end
end

function safeUp()
	simulationCheck()
	positionZ = positionZ + 1
	fuel = fuel + 1
	progressUpdate()
	if cost_only then
		return
	end
	checkFuel()
	local success = false
	while not success do
		success = turtle.up()
		if not success then
			while turtle.detectUp() do
				if not turtle.digUp() then
					writeOut("Blocked attempting to move up.")
					writeOut("Please clear and press enter to continue.")
					io.read()
				end
			end
		end
	end
end

function safeDown()
	simulationCheck()
	positionZ = positionZ - 1
	fuel = fuel + 1
	progressUpdate()
	if cost_only then
		return
	end
	checkFuel()
	local success = false
	while not success do
		success = turtle.down()
		if not success then
			while turtle.detectDown() do
				if not turtle.digDown() then
					writeOut("Blocked attempting to move down.")
					writeOut("Please clear and press enter to continue.")
					io.read()
				end
			end
		end
	end
end

function moveY(targetY)
	if targetY == positionY then
		return
	end
	if (facing ~= 0 and facing ~= 2) then -- Check axis
		turnRightTrack()
	end
	while targetY > positionY do
		if facing == 0 then
			safeForward()
		else
			safeBack()
		end
	end
	while targetY < positionY do
		if facing == 2 then
			safeForward()
		else
			safeBack()
		end
	end
end

function moveX(targetX)
	if targetX == positionX then
		return
	end
	if (facing ~= 1 and facing ~= 3) then -- Check axis
		turnRightTrack()
	end
	while targetX > positionX do
		if facing == 1 then
			safeForward()
		else
			safeBack()
		end
	end
	while targetX < positionX do
		if facing == 3 then
			safeForward()
		else
			safeBack()
		end
	end
end

function moveZ(targetZ)
	if targetZ == positionZ then
		return
	end
	while targetZ < positionZ do
		safeDown()
	end
	while targetZ > positionZ do
		safeUp()
	end
end

-- I *HIGHLY* suggest formatting all shape subroutines to use the format that dome() uses;  specifically, navigateTo(x,y,[z]) then placeBlock().  This should ensure proper "data recording" and also makes readability better
function navigateTo(targetX, targetY, targetZ, move_z_first)
	targetZ = targetZ or positionZ -- If targetZ isn't used in the function call, it defaults to its current z position, this should make it compatible with all previous implementations of navigateTo()
	move_z_first = move_z_first or false -- Defaults to moving z last, if true is passed as 4th argument, it moves vertically first

	if move_z_first then
		moveZ(targetZ)
	end

	if facing == 0 or facing == 2 then -- Y axis
		moveY(targetY)
		moveX(targetX)
	else
		moveX(targetX)
		moveY(targetY)
	end

	if not move_z_first then
		moveZ(targetZ)
	end
end

function goHome()
	if chain_next_shape then
		if not special_chain then
			navigateTo(0, 0) -- So another program can chain multiple shapes together to create bigger structures
		end
	else
		navigateTo(-1, -1, 0) -- So the user can collect the turtle when it is done -- also not 0,0,0 because some shapes use the 0,0 column
	end
	turnToFace(0)
end

-- Shape Building functions

function line(length)
	if length <= 0 then
		error("Error, length can not be 0")
	end
	local i
	for i = 1, length do
		placeBlock()
		if i ~= length then
			safeForward()
		end
	end
end

function rectangle(depth, width)
	if depth <= 0 then
		error("Error, depth can not be 0")
	end
	if width <= 0 then
		error("Error, width can not be 0")
	end
	local lengths = {depth, width, depth, width }
	local j
	for j=1,4 do
		line(lengths[j])
		turnRightTrack()
	end
end

function square(width)
	rectangle(width, width)
end

function wall(length, height)
	local i
	local j
	for i = 1, length do
		for j = 1, height do
			placeBlock()
			if j < height then
				safeUp()
			end
		end
		safeForward()
		for j = 1, height - 1 do
			safeDown()
		end
	end
	turnLeftTrack()
end

function platform(x, y)
	local forward = true
	for counterY = 0, y - 1 do
		for counterX = 0, x - 1 do
			if forward then
				navigateTo(counterX, counterY)
			else
				navigateTo(x - counterX - 1, counterY)
			end
			placeBlock()
		end
		if forward then
			forward = false
		else
			forward = true
		end
	end
end

function cuboid(depth, width, height, hollow)
	platform(depth, width)
	while (facing > 0) do
		turnLeftTrack()
	end
	turnAroundTrack()
	if ((width % 2) == 0) then -- This is for reorienting the turtle to build the walls correct in relation to the floor and ceiling
		turnLeftTrack()
	end
	if not(hollow == "n") then
		for i = 1, height - 2 do
			safeUp()
			if ((width % 2) == 0) then -- This as well
			rectangle(depth, width)
			else
			rectangle(width, depth)
			end
		end
	else
		for i = 1, height - 2 do
			safeUp()
			platform(depth,width)
		end
	end
	safeUp()
	platform(depth, width)
end

function pyramid(length, hollow)
	height = math.ceil(length / 2)
	for i = 1, height do
		if hollow=="y" then
			rectangle(length, length)
		else
			platform(length, length)
			navigateTo(0,0)
			while facing ~= 0 do
				turnRightTrack()
			end
		end
		if i ~= height then
			safeUp()
			safeForward()
			turnRightTrack()
			safeForward()
			turnLeftTrack()
			length = length - 2
		end
	end
end

function stair(width, height)
	turnRightTrack()
	local counterX = 1
	local counterY = 0.0
	local goForward = 0
	while counterY < height do
		while counterX < width do
			placeBlock()
			safeForward()
			counterX = counterX + 1
		end
		placeBlock()
		counterX = 1
		counterY = counterY + 0.5
		if counterY < height then
			if goForward == 1 and stepUp == true then  --gofw 1; stU 1
				turnRightTrack()
				safeForward()
				turnRightTrack()
				goForward = 0
				stepUp = false
			end
			if goForward == 1 and stepUp == false then		--gofw 1; stU 0
				turnRightTrack()
				safeUp()
				safeForward()
				turnRightTrack()
				goForward = 0
				stepUp = true
			end
			if goForward == 0 and stepUp == true then		--gofw 0; stU 1
				turnLeftTrack()
				safeUp()
				safeForward()
				turnLeftTrack()
				goForward = 1
				stepUp = true
				end
			if goForward == 0 and stepUp == false then		--gofw 0; stU 0
				turnLeftTrack()
				safeUp()
				turtle.select(15)
				turtle.placeDown()
				turtle.select(1)
				safeForward()
				turnLeftTrack()
				goForward = 1
				stepUp = true
				end
			end
		end
	end
end

function circle(diameter)
	odd = not (math.fmod(diameter, 2) == 0)
	radius = diameter / 2;
	if odd then
		width = (2 * math.ceil(radius)) + 1;
		offset = math.floor(width/2);
	else
		width = (2 * math.ceil(radius)) + 2;
		offset = math.floor(width/2) - 0.5;
	end
	--diameter --radius * 2 + 1
	sqrt3 = 3 ^ 0.5
	boundaryRadius = radius + 1.0
	boundary2 = boundaryRadius ^ 2
	radius2 = radius ^ 2
	z = math.floor(radius)
	cz2 = (radius - z) ^ 2
	limitOffsetY = (boundary2 - cz2) ^ 0.5
	maxOffsetY = math.ceil(limitOffsetY)
	-- We do first the +x side, then the -x side to make movement efficient
	for side = 0,1 do
			-- On the right we go from small y to large y, on the left reversed
			-- This makes us travel clockwise (from below) around each layer
			if (side == 0) then
				yStart = math.floor(radius) - maxOffsetY
				yEnd = math.floor(radius) + maxOffsetY
				yStep = 1
			else
				yStart = math.floor(radius) + maxOffsetY
				yEnd = math.floor(radius) - maxOffsetY
				yStep = -1
			end
			for y = yStart,yEnd,yStep do
				cy2 = (radius - y) ^ 2
				remainder2 = (boundary2 - cz2 - cy2)
				if remainder2 >= 0 then
					-- This is the maximum difference in x from the centre we can be without definitely being outside the radius
					maxOffsetX = math.ceil((boundary2 - cz2 - cy2) ^ 0.5)
					-- Only do either the +x or -x side
					if (side == 0) then
						-- +x side
						xStart = math.floor(radius)
						xEnd = math.floor(radius) + maxOffsetX
					else
						-- -x side
						xStart = math.floor(radius) - maxOffsetX
						xEnd = math.floor(radius) - 1
					end
					-- Reverse direction we traverse xs when in -y side
					if y > math.floor(radius) then
						temp = xStart
						xStart = xEnd
						xEnd = temp
						xStep = -1
					else
						xStep = 1
					end

					for x = xStart,xEnd,xStep do
						-- Only blocks within the radius but still within 1 3d-diagonal block of the edge are eligible
						if isSphereBorder(offset, x, y, z, radius2) then
							navigateTo(x, y)
							placeBlock()
						end
					end
				end
			end
		end
end

function blockInSphereIsFull(offset, x, y, z, radiusSq)
	x = x - offset
	y = y - offset
	z = z - offset
	x = x ^ 2
	y = y ^ 2
	z = z ^ 2
	return x + y + z <= radiusSq
end

function isSphereBorder(offset, x, y, z, radiusSq)
	spot = blockInSphereIsFull(offset, x, y, z, radiusSq)
	if spot then
		spot = not blockInSphereIsFull(offset, x, y - 1, z, radiusSq) or
			not blockInSphereIsFull(offset, x, y + 1, z, radiusSq) or
			not blockInSphereIsFull(offset, x - 1, y, z, radiusSq) or
			not blockInSphereIsFull(offset, x + 1, y, z, radiusSq) or
			not blockInSphereIsFull(offset, x, y, z - 1, radiusSq) or
			not blockInSphereIsFull(offset, x, y, z + 1, radiusSq)
	end
	return spot
end

function dome(typus, diameter)
	-- Main dome and sphere building routine
	odd = not (math.fmod(diameter, 2) == 0)
	radius = diameter / 2;
	if odd then
		width = (2 * math.ceil(radius)) + 1;
		offset = math.floor(width/2);
	else
		width = (2 * math.ceil(radius)) + 2;
		offset = math.floor(width/2) - 0.5;
	end
	--diameter --radius * 2 + 1
	sqrt3 = 3 ^ 0.5
	boundaryRadius = radius + 1.0
	boundary2 = boundaryRadius ^ 2
	radius2 = radius ^ 2

	if typus == "dome" then
		zstart = math.ceil(radius)
	elseif typus == "sphere" then
		zstart = 1
	elseif typus == "bowl" then
		zstart = 1
	end
	if typus == "bowl" then
		zend = math.floor(radius)
	else
		zend = width - 1
	end

	-- This loop is for each vertical layer through the sphere or dome.
	for z = zstart,zend do
		if not cost_only and z ~= zstart then
			safeUp()
		end
		--writeOut("Layer " .. z)
		cz2 = (radius - z) ^ 2
		limitOffsetY = (boundary2 - cz2) ^ 0.5
		maxOffsetY = math.ceil(limitOffsetY)
		-- We do first the +x side, then the -x side to make movement efficient
		for side = 0,1 do
			-- On the right we go from small y to large y, on the left reversed
			-- This makes us travel clockwise (from below) around each layer
			if (side == 0) then
				yStart = math.floor(radius) - maxOffsetY
				yEnd = math.floor(radius) + maxOffsetY
				yStep = 1
			else
				yStart = math.floor(radius) + maxOffsetY
				yEnd = math.floor(radius) - maxOffsetY
				yStep = -1
			end
			for y = yStart,yEnd,yStep do
				cy2 = (radius - y) ^ 2
				remainder2 = (boundary2 - cz2 - cy2)
				if remainder2 >= 0 then
					-- This is the maximum difference in x from the centre we can be without definitely being outside the radius
					maxOffsetX = math.ceil((boundary2 - cz2 - cy2) ^ 0.5)
					-- Only do either the +x or -x side
					if (side == 0) then
						-- +x side
						xStart = math.floor(radius)
						xEnd = math.floor(radius) + maxOffsetX
					else
						-- -x side
						xStart = math.floor(radius) - maxOffsetX
						xEnd = math.floor(radius) - 1
					end
					-- Reverse direction we traverse xs when in -y side
					if y > math.floor(radius) then
						temp = xStart
						xStart = xEnd
						xEnd = temp
						xStep = -1
					else
						xStep = 1
					end

					for x = xStart,xEnd,xStep do
						-- Only blocks within the radius but still within 1 3d-diagonal block of the edge are eligible
						if isSphereBorder(offset, x, y, z, radius2) then
							navigateTo(x, y)
							placeBlock()
						end
					end
				end
			end
		end
	end
end

function cylinder(diameter, height)
	for i = 1, height do
		circle(diameter)
		safeUp()
	end
end

function hexagon(sideLength)
	local changeX = sideLength / 2
	local changeY = round(math.sqrt(3) * changeX, 0)
	changeX = round(changeX, 0)
	local counter = 0

	navigateTo(changeX, 0)

	for currentSide = 1, 6 do
		counter = 0

		if currentSide == 1 then
			for placed = 1, sideLength do
				navigateTo(positionX + 1, positionY)
				placeBlock()
			end
		elseif currentSide == 2 then
			navigateTo(positionX, positionY + 1)
			while positionY <= changeY do
				if counter == 0 or counter == 2 or counter == 4 then
					navigateTo(positionX + 1, positionY)
				end
				placeBlock()
				navigateTo(positionX, positionY + 1)
				counter = counter + 1
				if counter == 5 then
					counter = 0
				end
			end
		elseif currentSide == 3 then
			while positionY <= (2 * changeY) do
				if counter == 0 or counter == 2 or counter == 4 then
					navigateTo(positionX - 1, positionY)
				end
				placeBlock()
				navigateTo(positionX, positionY + 1)
				counter = counter + 1
				if counter == 5 then
					counter = 0
				end
			end
		elseif currentSide == 4 then
			for placed = 1, sideLength do
				navigateTo(positionX - 1, positionY)
				placeBlock()
			end
		elseif currentSide == 5 then
			navigateTo(positionX, positionY - 1)
			while positionY >= changeY do
				if counter == 0 or counter == 2 or counter == 4 then
					navigateTo(positionX - 1, positionY)
				end
				placeBlock()
				navigateTo(positionX, positionY - 1)
				counter = counter + 1
				if counter == 5 then
					counter = 0
				end
			end
		elseif currentSide == 6 then
			while positionY >= 0 do
				if counter == 0 or counter == 2 or counter == 4 then
					navigateTo(positionX + 1, positionY)
				end
				placeBlock()
				navigateTo(positionX, positionY - 1)
				counter = counter + 1
				if counter == 5 then
					counter = 0
				end
			end
		end
	end
end

function octagon(sideLength)
	local sideLength2 = sideLength - 1
	local change = round(sideLength2 / math.sqrt(2), 0)

	navigateTo(change, 0)

	for currentSide = 1, 8 do
		if currentSide == 1 then
			for placed = 1, sideLength2 do
				navigateTo(positionX + 1, positionY)
				placeBlock()
			end
		elseif currentSide == 2 then
			for placed = 1, change do
				navigateTo(positionX + 1, positionY + 1)
				placeBlock()
			end
		elseif currentSide == 3 then
			for placed = 1, sideLength2 do
				navigateTo(positionX, positionY + 1)
				placeBlock()
			end
		elseif currentSide == 4 then
			for placed = 1, change do
				navigateTo(positionX - 1, positionY + 1)
				placeBlock()
			end
		elseif currentSide == 5 then
			for placed = 1, sideLength2 do
				navigateTo(positionX - 1, positionY)
				placeBlock()
			end
		elseif currentSide == 6 then
			for placed = 1, change do
				navigateTo(positionX - 1, positionY - 1)
				placeBlock()
			end
		elseif currentSide == 7 then
		for placed = 1, sideLength2 do
				navigateTo(positionX, positionY - 1)
				placeBlock()
			end
		elseif currentSide == 8 then
			for placed = 1, change do
				navigateTo(positionX + 1, positionY - 1)
				placeBlock()
			end
		end
	end
end

function sixprism(length, height)
	for i = 1, height do
		hexagon(length)
		safeUp()
	end
end

function eigthprism(length, height)
	for i = 1, height do
		octagon(length)
		safeUp()
	end
end

-- Previous Progress Resuming, Simulation functions, Command Line, and File Backend
-- Will check for a "progress" file.
function CheckForPrevious()
	if fs.exists(progFileName) then
		return true
	else
		return false
	end
end

-- Creates a progress file, containing a serialized table consisting of the shape type, shape input params, and the last known x, y, and z coords of the turtle (beginning of build project)
function ProgressFileCreate()
	if not CheckForPrevious() then
		fs.makeDir(progFileName)
		return true
	else
		return false
	end
end

-- Deletes the progress file (at the end of the project, also at beginning if user chooses to delete old progress)
function ProgressFileDelete()
	if fs.exists(progFileName) then
		fs.delete(progFileName)
		return true
	else
		return false
	end
end

-- To read the shape params from the file.  Shape type, and input params (e.g. "dome" and radius)
function ReadShapeParams()
	-- TODO. Unneeded for now, can just use the table elements directly
end

function WriteShapeParams(...) -- The ... lets it take any number of arguments and stores it to the table arg{} | This is still unused anywhere
	local paramTable = arg
	local paramName = "param"
	local paramName2 = paramName
	for i, v in ipairs(paramTable) do -- Iterates through the args passed to the function, ex. paramTable[1] i = 1 so paramName2 should be "param1", tested and works!
		paramName2 = paramName .. i
		tempProgTable[paramName2] = v
		progTable[paramName2] = v
	end
end

-- function to write the progress to the file (x, y, z)
function writeProgress()
	local progFile
	local progString = ""
	if not (sim_mode or cost_only) then
		progString = textutils.serialize(progTable) -- Put in here to save processing time when in cost_only
		progFile = fs.open(progFileName, "w")
		progFile.write(progString)
		progFile.close()
	end

end

-- Reads progress from file (shape, x, y, z, facing, blocks, param1, param2, param3)
function readProgress()
	local progFile = fs.open(progFileName, "r")
	local readProgTable = textutils.unserialize(progFile.readAll())
	progFile.close()
	return readProgTable
end

-- compares the progress read from the file to the current sim progress.  needs all four params
function compareProgress()
	local progTableIn = progTable
	local readProgTable = readProgress()
	if (progTableIn.shape == readProgTable.shape and progTableIn.x == readProgTable.x and progTableIn.y == readProgTable.y and progTableIn.blocks == readProgTable.blocks and progTableIn.facing == readProgTable.facing) then
		writeOut("All caught up!")
		return true -- We're caught up!
	else
		return false -- Not there yet...
	end
end

function getGPSInfo() -- TODO: finish this
	position = gps.locate()
	gpsPositionX = position.x
	gpsPositionZ = position.y
	gpsPositionY = position.z

end

function setSimFlags(b)
	sim_mode = b
	cost_only = b
	if cmd_line_cost_only then
		cost_only = true
	end
end

function simulationCheck() -- checks state of the simulation
	if sim_mode then
		if compareProgress() then
			setSimFlags(false) -- If we're caught up, un-set flags
		else
			setSimFlags(true)  -- If not caught up, just re-affirm that the flags are set
		end
	end
end

function continueQuery()
	if cmd_line_resume then
		 return true
	else
		 if not cmd_line then
			 writeOut("Do you want to continue the last job?")
			 local yes = io.read()
			 if yes == "y" then
				 return true
			 else
				 return false
			 end
		 end
	end
end

function progressUpdate()  -- This ONLY updates the local table variable.  Writing is handled above. -- I want to change this to allow for any number of params
	progTable = {shape = choice, enderchestRefilling = tempProgTable.enderchestRefilling, param1 = tempProgTable.param1, param2 = tempProgTable.param2, param3 = tempProgTable.param3, param4 = tempProgTable.param4, x = positionX, y = positionY, z = positionZ, facing = facing, blocks = blocks}
	if not sim_mode then
		writeProgress()
	end
end

 -- Command Line
function checkCommandLine() --True if arguments were passed
	if #argTable > 0 then
		cmd_line = true
		return true
	else
		cmd_line = false
		return false
	end
end

function needsHelp() -- True if -h is passed
	for i, v in pairs(argTable) do
		if v == "-h" or v == "-help" or v == "--help" then
			return true
		else
			return false
		end
	end
end

function setFlagsFromCommandLine() -- Sets count_only, chain_next_shape, and sim_mode
	for i, v in pairs(argTable) do
		if v == "-c" or v == "-cost" or v == "--cost" then
			cost_only = true
			cmd_line_cost_only = true
			writeOut("Cost only mode")
		end
		if v == "-z" or v == "-chain" or v == "--chain" then
			chain_next_shape = true
			writeOut("Chained shape mode")
		end
		if v == "-r" or v == "-resume" or v == "--resume" then
			cmd_line_resume = true
			writeOut("Resuming")
		end
	end
end

function setTableFromCommandLine() -- Sets progTable and tempProgTable from command line arguments
	progTable.shape = argTable[1]
	tempProgTable.shape = argTable[1]
	local paramName = "param"
	local paramName2 = paramName
	for i = 2, #argTable do
		local addOn = tostring(i - 1)
		paramName2 = paramName .. addOn
		progTable[paramName2] = argTable[i]
		tempProgTable[paramName2] = argTable[i]
	end
end

-- Menu, Drawing and Main functions

function choiceFunction()
	if sim_mode == false and cmd_line == false then -- If we are NOT resuming progress
		choice = io.read()
		choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
		tempProgTable = {shape = choice}
		progTable = {shape = choice}
		if choice == "next" then
			WriteMenu2()
			choice = io.read()
			choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
		end
		if choice == "end" or choice == "exit" then
			writeOut("Goodbye.")
			return
		end
		if choice == "help" then
			showHelp()
			return
		end
		if choice == "credits" then
			showCredits()
			return
		end
		writeOut("Building a "..choice)
		local yes = getInput("string","Want to just calculate the cost?","y","n")
		if yes == 'y' then
			cost_only = true
		end
		local yes = getInput("string","Want turtle to return to start after build?","y","n")
		if yes == 'y' then
			returntohome = true
		end
		local yes = getInput("string","Want the turtle to refill from enderchest (slot 16)?","y","n")
		if yes == 'y' then
			enderchestRefilling = true
			tempProgTable.enderchestRefilling = true;
		end
	elseif sim_mode == true then -- If we ARE resuming progress
		tempProgTable = readProgress()
		choice = tempProgTable.shape
		choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
		enderchestRefilling =  tempProgTable.enderchestRefilling
	elseif cmd_line == true then -- If running from command line
		choice = tempProgTable.shape
		choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
		enderchestRefilling =  tempProgTable.enderchestRefilling
		writeOut("Building a "..choice)
	end
	if not cost_only then
		turtle.select(1)
		activeslot = 1
		if turtle.getItemCount(activeslot) == 0 then
			if resupply then
				writeOut("Please put building blocks in the first slot.")
			else
				writeOut("Please put building blocks in the first slot (and more if you need them)")
			end
			while turtle.getItemCount(activeslot) == 0 do
				os.sleep(2)
			end
		end
	else
		activeslot = 1
	end
	-- shape selection if cascade
	if choice == "rectangle" then
		local depth = 0
		local width = 0
		if sim_mode == false and cmd_line == false then
			depth = getInput("int","How deep does it need to be?")
			width = getInput("int","How wide does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			depth = tempProgTable.param1
			width = tempProgTable.param2
		end
		tempProgTable.param1 = depth
		tempProgTable.param2 = width
		progTable = {param1 = depth, param2 = width} -- THIS is here because we NEED to update the local table!
		rectangle(depth, width)
	end
	if choice == "square" then
		local sideLength
		if sim_mode == false and cmd_line == false then
			sideLength = getInput("int","What depth/width does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			sideLength = tempProgTable.param1
		end
		tempProgTable.param1 = sideLength
		progTable = {param1 = sideLength}
		square(sideLength)
	end
	if choice == "line" then
		local lineLength = 0
		if sim_mode == false and cmd_line == false then
			lineLength = getInput("int","How long does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			lineLength = tempProgTable.param1
		end
		tempProgTable.param1 = lineLength
		progTable = {param1 = lineLength}
		line(lineLength)
	end
	if choice == "wall" then
	local depth = 0
	local height = 0
		if sim_mode == false and cmd_line == false then
			depth = getInput("int","How deep does it need to be?")
			height = getInput("int","How high does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			depth = tempProgTable.param1
			height = tempProgTable.param2
		end
		tempProgTable.param1 = depth
		tempProgTable.param2 = height
		progTable = {param1 = depth, param2 = height}
		wall(depth, height)
	end
	if choice == "platform" then
		local depth = 0
		local width = 0
		if sim_mode == false and cmd_line == false then
			depth = getInput("int","How deep does it need to be?")
			width = getInput("int","How wide does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			depth = tempProgTable.param1
			width = tempProgTable.param2
		end
		tempProgTable.param1 = depth
		tempProgTable.param2 = width
		progTable = {param1 = depth, param2 = width}
		platform(width, depth)
	end
	if choice == "stair" then
		local width = 0
		local height = 0
		if sim_mode == false and cmd_line == false then
			width = getInput("int","How wide does it need to be?")
			height = getInput("int","How high does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			width = tempProgTable.param1
			height = tempProgTable.param2
		end
		tempProgTable.param1 = width
		tempProgTable.param2 = height
		progTable = {param1 = width, param2 = height}
		stair(width, height)
		special_chain = true
	end
	if choice == "cuboid" then
		local depth = 0
		local width = 0
		local height = 0
		local hollow = ""
		if sim_mode == false and cmd_line == false then
			depth = getInput("int","How deep does it need to be?")
			width = getInput("int","How wide does it need to be?")
			height = getInput("int","How high does it need to be?")
			hollow = getInput("string","Does it need to be hollow?","y","n")
		elseif sim_mode == true or cmd_line == true then
			depth = tempProgTable.param1
			width = tempProgTable.param2
			height = tempProgTable.param3
			hollow = tempProgTable.param4
		end
		tempProgTable.param1 = depth
		tempProgTable.param2 = width
		tempProgTable.param3 = height
		tempProgTable.param4 = hollow
		if height < 3 then
			height = 3
		end
		if depth < 3 then
			depth = 3
		end
		if width < 3 then
			width = 3
		end
		progTable = {param1 = depth, param2 = width, param3 = height}
		cuboid(depth, width, height, hollow)
	end
	if choice == "1/2-sphere" or choice == "1/2 sphere" then
		local diameter = 0
		local half = ""
		if sim_mode == false and cmd_line == false then
			diameter = getInput("int","What diameter does it need to be?")
			half = getInput("string","What half of the sphere does it need to be?","bottom","top")
		elseif sim_mode == true or cmd_line == true then
			diameter = tempProgTable.param1
			half = tempProgTable.param2
		end
		tempProgTable.param1 = diameter
		tempProgTable.param2 = half
		progTable = {param1 = diameter, param2 = half}
		if half == "bottom" then
			dome("bowl", diameter)
		else
			dome("dome", diameter)
		end
	end
	if choice == "dome" then
		local diameter = 0
		if sim_mode == false and cmd_line == false then
			diameter = getInput("int","What diameter does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			diameter = tempProgTable.param1
		end
		tempProgTable.param1 = diameter
		progTable = {param1 = diameter}
		dome("dome", diameter)
	end
	if choice == "bowl" then
		local diameter = 0
		if sim_mode == false and cmd_line == false then
			diameter = getInput("int","What diameter does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			diameter = tempProgTable.param1
		end
		tempProgTable.param1 = diameter
		progTable = {param1 = diameter}
		dome("bowl", diameter)
	end
	if choice == "circle" then
		local diameter = 0
		if sim_mode == false and cmd_line == false then
			diameter = getInput("int","What diameter does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			diameter = tempProgTable.param1
		end
		tempProgTable.param1 = diameter
		progTable = {param1 = diameter}
		circle(diameter)
	end
	if choice == "cylinder" then
		local diameter = 0
		local height = 0
		if sim_mode == false and cmd_line == false then
			diameter = getInput("int","What diameter does it need to be?")
			height = getInput("int","How high does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			diameter = tempProgTable.param1
			height = tempProgTable.param2
		end
		tempProgTable.param1 = diameter
		tempProgTable.param2 = height
		progTable = {param1 = diameter, param2 = height}
		cylinder(diameter, height)
	end
	if choice == "pyramid" then
		local length = 0
		local hollow = ""
		if sim_mode == false and cmd_line == false then
			length = getInput("int","What depth/width does it need to be?")
			hollow = getInput("string","Does it need to be hollow?","y","n")
		elseif sim_mode == true or cmd_line == true then
			length = tempProgTable.param1
			hollow = tempProgTable.param2
		end
		tempProgTable.param1 = length
		tempProgTable.param2 = hollow
		progTable = {param1 = length, param2 = hollow}
		pyramid(length, hollow)
	end
	if choice == "sphere" then
		local diameter = 0
		if sim_mode == false and cmd_line == false then
			diameter = getInput("int","What diameter does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			diameter = tempProgTable.param1
		end
		tempProgTable.param1 = diameter
		progTable = {param1 = diameter}
		dome("sphere", diameter)
	end
	if choice == "hexagon" then
		local length = 0
		if sim_mode == false and cmd_line == false then
			length = getInput("int","How long does each side need to be?")
		elseif sim_mode == true or cmd_line == true then
			length = tempProgTable.param1
		end
		tempProgTable.param1 = length
		progTable = {param1 = length}
		hexagon(length)
	end
	if choice == "octagon" then
		local length = 0
		if sim_mode == false and cmd_line == false then
			length = getInput("int","How long does each side need to be?")
		elseif sim_mode == true or cmd_line == true then
			length = tempProgTable.param1
		end
		tempProgTable.param1 = length
		progTable = {param1 = length}
		octagon(length)
	end
	if choice == "6-prism" or choice == "6 prism" then
		local length = 0
		local height = 0
		if sim_mode == false and cmd_line == false then
			length = getInput("int","How long does each side need to be?")
			height = getInput("int","What height does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			length = tempProgTable.param1
			height = tempProgTable.param2
		end
		tempProgTable.param1 = length
		tempProgTable.param2 = height
		progTable = {param1 = length, param2 = height}
		sixprism(length, height)
	end
	if choice == "8-prism" or choice == "8 prism" then
		local length = 0
		local height = 0
		if sim_mode == false and cmd_line == false then
			length = getInput("int","How long does each side need to be?")
			height = getInput("int","What height does it need to be?")
		elseif sim_mode == true or cmd_line == true then
			length = tempProgTable.param1
			height = tempProgTable.param2
		end
		tempProgTable.param1 = length
		tempProgTable.param2 = height
		progTable = {param1 = length, param2 = height}
		eightprism(length, height)
	end
	if returntohome then
		goHome() -- After all shape building has finished
	end
	writeOut("Done") -- Saves a few lines when put here rather than in each if statement
end

function WriteMenu()
	term.clear()
	term.setCursorPos(1, 1)
	writeOut("Shape Maker 1.5 by Keridos/Happydude/pokemane")
	if resupply then					-- Any ideas to make this more compact/betterlooking (in terms of code)?
		writeOut("Resupply Mode Active")
	elseif (resupply and can_use_gps) then
		writeOut("Resupply and GPS Mode Active")
	elseif can_use_gps then
		writeOut("GPS Mode Active")
	else
		writeOut("")
	end
	if not cmd_line then
		writeOut("What should be built? [page 1/2]");
		writeOut("next for page 2")
		writeOut("+---------+-----------+-------+-------+")
		writeOut("| square  | rectangle | wall  | line  |")
		writeOut("| cylinder| platform  | stair | cuboid|")
		writeOut("| pyramid | 1/2-sphere| circle| next  |")
		writeOut("+---------+-----------+-------+-------+")
		writeOut("")
	end
end

function WriteMenu2()
	term.clear()
	term.setCursorPos(1, 1)
	writeOut("Shape Maker 1.5 by Keridos/Happydude/pokemane")
	if resupply then					-- Any ideas to make this more compact/betterlooking (in terms of code)?
		writeOut("Resupply Mode Active")
	elseif (resupply and can_use_gps) then
		writeOut("Resupply and GPS Mode Active")
	elseif can_use_gps then
		writeOut("GPS Mode Active")
	else
		writeOut("")
	end
	writeOut("What should be built [page 2/2]?");
	writeOut("")
	writeOut("+---------+-----------+-------+-------+")
	writeOut("| hexagon | octagon   | help  |       |")
	writeOut("| 6-prism | 8-prism   | end   |       |")
	writeOut("| sphere  | credits   |       |       |")
	writeOut("+---------+-----------+-------+-------+")
	writeOut("")
end

function showHelp()
	writeOut("Usage: shape [shape-type [param1 param2 param3 ...]] [-c] [-h] [-z] [-r]")
	writeOut("-c: Activate cost only mode")
	writeOut("-h: Show this page")
	writeOut("-z: Set chain_next_shape to true, lets you chain together multiple shapes")
	io.read() -- Pause here
	writeOut("-r: Resume the last shape if there is a resume file")
	writeOut("shape-type can be any of the shapes in the menu")
	writeOut("After shape-type input all of the paramaters for the shape")
	io.read() -- Pause here, too
end

function showCredits()
	writeOut("Credits for the shape builder:")
	writeOut("Based on work by Michiel,Vliekkie, and Aeolun")
	writeOut("Sphere/dome code by pruby")
	writeOut("Additional improvements by Keridos,Happydude and pokemane")
	io.read() -- Pause here, too
end

function main()
	if wrapmodules()=="resupply" then
		linkToRSStation()
	end
	if checkCommandLine() then
		if needsHelp() then
			showHelp()
			return -- Close the program after help info is shown
		end
		setFlagsFromCommandLine()
		setTableFromCommandLine()
	end
	if (CheckForPrevious()) then  -- Will check to see if there was a previous job and gps is enabled, and if so, ask if the user would like to re-initialize to current progress status
		if not continueQuery() then -- If the user doesn't want to continue
			ProgressFileDelete()
			setSimFlags(false) -- Just to be safe
			WriteMenu()
			choiceFunction()
		else	-- If the user wants to continue
			setSimFlags(true)
			choiceFunction()
		end
	else
		setSimFlags(false)
		WriteMenu()
		choiceFunction()
	end
	if (blocks ~= 0) and (fuel ~= 0) then -- Do not show on help or credits page or when selecting end
		writeOut("Blocks used: " .. blocks)
		writeOut("Fuel used: " .. fuel)
	end
	ProgressFileDelete() -- Removes file upon successful completion of a job, or completion of a previous job.
	progTable = {}
	tempProgTable = {}
end

main()