local weirding = {
	just_placed = {},
}


local function clear() 
	weirding.just_placed = {}
	minetest.after(1, clear)
end

minetest.after(1, clear)




minetest.register_node("weirding:mover", {
	description = "mover",
	tiles = {
		"default_dirt.png^weirding_yellow_arrow.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
	paramtype2 = "facedir",
	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_stone_footstep", gain = 0.25},
	}),
})


minetest.register_abm({
	nodenames = {"weirding:mover"},
-- 	neighbors = {"group:soil"},
	interval = 1,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		
		local back_dir = minetest.facedir_to_dir(node.param2)
		
		local top_dir = ({[0]={x=0, y=1, z=0},
			{x=0, y=0, z=1},
			{x=0, y=0, z=-1},
			{x=1, y=0, z=0},
			{x=-1, y=0, z=0},
			{x=0, y=-1, z=0}})[math.floor(node.param2/4)]
		
		local right_dir = vector.cross(top_dir, back_dir)
		
-- 		local front_dir = vector.multiply(back_dir, -1)
		local backpos = vector.add(pos, top_dir)
		local frontpos = vector.add(backpos, back_dir)
		
		local bnode = minetest.get_node(backpos)
		if bnode == nil or bnode.name == "air" then
			return
		end
		
		local bhash = minetest.hash_node_position(backpos)
		if weirding.just_placed[bhash] == true then
			return
		end
		
		local fnode = minetest.get_node(frontpos)
		if fnode ~= nil and fnode.name ~= "air" then
			return
		end
		
		local fhash = minetest.hash_node_position(frontpos)
		weirding.just_placed[fhash] = true
		
		
		minetest.swap_node(frontpos, bnode)
		minetest.set_node(backpos, {name="air"})
		
		minetest.check_for_falling(frontpos)
	end,
})


minetest.register_node("weirding:dropper", {
	description = "mover",
	tiles = {
		"default_dirt.png^weirding_yellow_arrow_circle.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
	paramtype2 = "facedir",
	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_stone_footstep", gain = 0.25},
	}),
})


minetest.register_abm({
	nodenames = {"weirding:dropper"},
-- 	neighbors = {"group:soil"},
	interval = 1,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		
		local back_dir = minetest.facedir_to_dir(node.param2)
		
		local top_dir = ({[0]={x=0, y=1, z=0},
			{x=0, y=0, z=1},
			{x=0, y=0, z=-1},
			{x=1, y=0, z=0},
			{x=-1, y=0, z=0},
			{x=0, y=-1, z=0}})[math.floor(node.param2/4)]
		
		
		local front_dir = vector.multiply(back_dir, -1)
		local toppos = vector.add(pos, top_dir)
		local backpos = vector.add(pos, back_dir)
		local frontpos = vector.add(pos, back_dir)
		
		local tnode = minetest.get_node(toppos)
		if tnode == nil or tnode.name == "air" then
			return
		end
		
		local thash = minetest.hash_node_position(toppos)
		if weirding.just_placed[thash] == true then
			return
		end
		
		-- try the front
		local fnode = minetest.get_node(frontpos)
		if fnode ~= nil and fnode.name == "air" then
			
			local fhash = minetest.hash_node_position(frontpos)
			weirding.just_placed[fhash] = true
			
			minetest.swap_node(frontpos, tnode)
			minetest.set_node(toppos, {name="air"})
			
			minetest.check_for_falling(frontpos)
			return
		end
		
		-- try moving on
		local frontpos = vector.add(toppos, back_dir)
		local fnode = minetest.get_node(frontpos)
		if fnode ~= nil and fnode.name == "air" then
			
			local fhash = minetest.hash_node_position(frontpos)
			weirding.just_placed[fhash] = true
			
			minetest.swap_node(frontpos, tnode)
			minetest.set_node(toppos, {name="air"})
			
			minetest.check_for_falling(frontpos)
			return
		end
	end,
})


--[[
minetest.register_node("weirding:rotator", {
	description = "rotator",
	tiles = {
		"default_dirt.png^weirding_green_circle_arrow.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
	paramtype2 = "facedir",
	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_stone_footstep", gain = 0.25},
	}),
})


minetest.register_abm({
	nodenames = {"weirding:rotator"},
-- 	neighbors = {"group:soil"},
	interval = 10000000,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		
		local back_dir = minetest.facedir_to_dir(node.param2)
		
		local top_dir = ({[0]={x=0, y=1, z=0},
			{x=0, y=0, z=1},
			{x=0, y=0, z=-1},
			{x=1, y=0, z=0},
			{x=-1, y=0, z=0},
			{x=0, y=-1, z=0}})[math.floor(node.param2/4)]
		
		local right_dir = vector.cross(top_dir, back_dir)
		
-- 		local front_dir = vector.multiply(back_dir, -1)
		local backpos = vector.add(pos, back_dir)
		
		local i = 0
		while true do
			
			local frontpos = vector.add(pos, right_dir)
			
			
			local bnode = minetest.get_node(backpos)
			if bnode == nil or bnode.name == "air" then
				return
			end
			
			local bhash = minetest.hash_node_position(backpos)
			if weirding.just_placed[bhash] == true then
				return
			end
			
			
			local fnode = minetest.get_node(frontpos)
			if fnode ~= nil and fnode.name ~= "air" then
				return
			end
			
			local fhash = minetest.hash_node_position(frontpos)
			weirding.just_placed[fhash] = true
			
			minetest.swap_node(frontpos, bnode)
			minetest.set_node(backpos, {name="air"})
			
			break
		end
	end,
})
]]

minetest.register_abm({
	nodenames = {"weirding:rotator"},
-- 	neighbors = {"group:soil"},
	interval = 1,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		
		local back_dir = minetest.facedir_to_dir(node.param2)
		local backpos = vector.add(pos, back_dir) 
		
		
		
		local front_dir = vector.cross(back_dir, -1)
		local frontpos = vector.add(pos, front_dir)
		
		local bnode = minetest.get_node(backpos)
		if bnode == nil or bnode.name == "air" then
			return
		end
		
		local bhash = minetest.hash_node_position(backpos)
		if weirding.just_placed[bhash] == true then
			return
		end
		
		local fnode = minetest.get_node(frontpos)
		if fnode ~= nil and fnode.name ~= "air" then
			return
		end
		
		local fhash = minetest.hash_node_position(frontpos)
		weirding.just_placed[fhash] = true
		
		minetest.swap_node(frontpos, bnode)
		minetest.set_node(backpos, {name="air"})
		
	end,
})





minetest.register_node("weirding:eater", {
	description = "eater",
	tiles = {
		"default_dirt.png^weirding_red_arrow.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		"default_dirt.png",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
	paramtype2 = "facedir",
	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_stone_footstep", gain = 0.25},
	}),
})


minetest.register_abm({
	nodenames = {"weirding:eater"},
-- 	neighbors = {"group:soil"},
	interval = 1,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		
		local front_dir = minetest.facedir_to_dir(node.param2)
		local frontpos = vector.add(pos, front_dir)
		
		local back_dir = vector.multiply(front_dir, -1)
		local backpos = vector.add(pos, back_dir)
		
		local bnode = minetest.get_node(backpos)
		if bnode == nil or bnode.name == "air" then
			return
		end
	
		local bhash = minetest.hash_node_position(backpos)
		if weirding.just_placed[bhash] == true then
			return
		end
		
		local meta = minetest.get_meta(frontpos)
		if meta == nil then return end
		local inv = meta:get_inventory()
		if inv == nil then return end
		if inv:get_size("main") == 0 then return end
		
		local drops = minetest.get_node_drops(bnode.name, nil)
		for _,v in ipairs(drops) do
			inv:add_item("main", v)
		end
		
		minetest.set_node(backpos, {name="air"})
		
	end,
})


minetest.register_node("weirding:green_node", {
	description = "green node",
	tiles = {
		"default_dirt.png^[colorize:green:120",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
-- 	paramtype2 = "facedir",
-- 	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_glass_footstep", gain = 0.25},
	}),
})

minetest.register_node("weirding:purple_node", {
	description = "purple node",
	tiles = {
		"default_dirt.png^[colorize:purple:120",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
-- 	paramtype2 = "facedir",
-- 	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_glass_footstep", gain = 0.25},
	}),
})
minetest.register_node("weirding:orange_node", {
	description = "orange node",
	tiles = {
		"default_dirt.png^[colorize:orange:120",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
-- 	paramtype2 = "facedir",
-- 	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_glass_footstep", gain = 0.25},
	}),
})



minetest.register_node("weirding:red_node", {
	description = "red node",
	tiles = {
		"default_dirt.png^[colorize:red:120",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
-- 	paramtype2 = "facedir",
-- 	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_glass_footstep", gain = 0.25},
	}),
})

minetest.register_node("weirding:yellow_node", {
	description = "yellow node",
	tiles = {
		"default_dirt.png^[colorize:yellow:120",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
-- 	paramtype2 = "facedir",
-- 	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_glass_footstep", gain = 0.25},
	}),
})

minetest.register_node("weirding:gray_node", {
	description = "gray node",
	tiles = {
		"default_dirt.png^[colorize:gray:120",
		},
	groups = {cracky = 1, oddly_breakable_by_hand = 3},
	is_ground_content = false,
-- 	paramtype2 = "facedir",
-- 	on_place = minetest.rotate_node,
	sounds = default.node_sound_dirt_defaults({
		footstep = {name = "default_glass_footstep", gain = 0.25},
	}),
	
	on_timer = function(pos)
		local meta = minetest.get_meta(pos)
		local n = meta:get_string("name")
		if n ~= "" then
			minetest.set_node(pos, {
				name = n,
				param2 = meta:get_int("param2"),
			})
		end
	end,
})



local function set_later(pos, name)
	local n = name
	local p = {x=pos.x, y=pos.y, z=pos.z}
	minetest.after(1, function()
		minetest.set_node(p, {name=n})
	end)
end
local function set_now(pos, name)
	minetest.set_node(pos, {name=name})
end



minetest.register_abm({
	nodenames = {"weirding:red_node"},
	neighbors = {"weirding:red_node"},
	interval = 2,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		if node.name ~= "weirding:red_node" then return end
		
-- 		local bhash = minetest.hash_node_position(pos)
-- 		if weirding.just_placed[bhash] == true then
-- 			return
-- 		end
-- 		weirding.just_placed[bhash] = true
		
		local red_nodes = minetest.find_nodes_in_area(
			{x=pos.x - 1, y=pos.y - 1, z=pos.z - 1},
			{x=pos.x + 1, y=pos.y + 1, z=pos.z + 1},
			{"weirding:red_node"}
		)
		
--  		if #red_nodes >= 4 then 
-- 			minetest.set_node(pos, {name="weirding:green_node"})
-- 			return
--  		end
		
		for _,rnp in ipairs(red_nodes) do
			
-- 			local bhash = minetest.hash_node_position(rnp)
-- 			if weirding.just_placed[bhash] == true then
-- 				return
-- 			end
-- 			weirding.just_placed[bhash] = true
			
			local d = vector.subtract(pos, rnp);
			local opp = vector.add(pos, d);
			
			local on = minetest.get_node(opp)
			if on ~= nil and (on.name == "air" or minetest.registered_nodes[on.name].buildable_to) then
-- 				minetest.set_node(rnp, {name="air"})
					set_later(opp, "weirding:red_node")
			end
		end
-- 		
-- 		minetest.set_node(pos, {name="weirding:red_node"})
		
	end,
})


minetest.register_abm({
	nodenames = {"weirding:yellow_node"},
	neighbors = {"weirding:red_node"},
	interval = 2,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		if node.name ~= "weirding:yellow_node" then return end
		
		local red_nodes = minetest.find_nodes_in_area(
			{x=pos.x - 1, y=pos.y - 1, z=pos.z - 1},
			{x=pos.x + 1, y=pos.y + 1, z=pos.z + 1},
			{"weirding:red_node"}
		)
		
		for _,rnp in ipairs(red_nodes) do
			
			local bhash = minetest.hash_node_position(rnp)
			if weirding.just_placed[bhash] == true then
				return
			end
			weirding.just_placed[bhash] = true
			
			local d = vector.subtract(pos, rnp);
			local opp = vector.add(pos, d);
			
			local on = minetest.get_node(opp)
			if on ~= nil and on.name ~= "air" then
-- 				minetest.set_node(rnp, {name="air"})
				minetest.set_node(rnp, {name="weirding:gray_node"})
				local meta = minetest.get_meta(rnp)
				meta:set_string("name", on.name)
				meta:set_int("param2", on.param2)
				
				local t = minetest.get_node_timer(rnp)
				t:start(10)
			end
		end
		
	end,
})

minetest.register_abm({
	nodenames = {"weirding:gray_node"},
	neighbors = {"weirding:red_node"},
	interval = 1,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node = minetest.get_node(pos)
		if node.name ~= "weirding:gray_node" then return end
		
		local nmeta = minetest.get_meta(pos)
		local param2 = nmeta:get_int("param2")
		local name = nmeta:get_string("name")
		
		local red_nodes = minetest.find_nodes_in_area(
			{x=pos.x - 1, y=pos.y - 1, z=pos.z - 1},
			{x=pos.x + 1, y=pos.y + 1, z=pos.z + 1},
			{"weirding:red_node"}
		)
		
		for _,rnp in ipairs(red_nodes) do
			
-- 				minetest.set_node(rnp, {name="air"})
				minetest.set_node(rnp, {name="weirding:gray_node"})
				local meta = minetest.get_meta(rnp)
				meta:set_string("name", name)
				meta:set_int("param2", param2)
				
				local t = minetest.get_node_timer(rnp)
				t:start(10)
		end
		
	end,
})

-- clear
minetest.register_abm({
	nodenames = {"weirding:green_node", "weirding:red_node"},
	interval = 100000000,
	chance = 1,
--	catch_up = true,
	action = function(pos)
-- 		minetest.set_node(pos, {name="air"})
	end,
})

minetest.register_abm({
	nodenames = {"weirding:green_node"},
	neighbors = {"weirding:purple_node"},
	interval = 2,
	chance = 1,
--	catch_up = true,
	action = function(pos)
		local node   = minetest.get_node(pos)
		if node.name ~= "weirding:green_node" then 
-- 			minetest.set_node(pos, {name="air"})
			return
		end
		
		local bhash = minetest.hash_node_position(pos)
		if weirding.just_placed[bhash] == true then
			return
		end
		
		
		local purple_nodes = minetest.find_nodes_in_area(
			{x=pos.x - 1, y=pos.y - 1, z=pos.z - 1},
			{x=pos.x + 1, y=pos.y + 1, z=pos.z + 1},
			{"weirding:purple_node"}
		)
		
		if #purple_nodes ~= 1 then 
			minetest.set_node(pos, {name="default:glass"})
			return
		end
		
		local pu_pos = purple_nodes[1]
		
		local orange_nodes = minetest.find_nodes_in_area(
			{x=pu_pos.x - 1, y=pu_pos.y - 1, z=pu_pos.z - 1},
			{x=pu_pos.x + 1, y=pu_pos.y + 1, z=pu_pos.z + 1},
			{"weirding:orange_node"}
		)
		if #orange_nodes ~= 1 then 
			minetest.set_node(pos, {name="default:glass"})
			return
		end
		
		local or_pos = orange_nodes[1]
		local mvdir = vector.subtract(pos, pu_pos)

		local or_next_pos = vector.add(or_pos, mvdir)
		local orn = minetest.get_node(or_next_pos)
		if orn and not minetest.registered_nodes[orn.name].buildable_to then
			minetest.set_node(pos, {name="default:glass"})
			return
		end
		
		
		
		local dir = vector.subtract(pu_pos, or_pos)
-- 		local inv_dir = vector.multiply(dir, -1)
		
		-- from the corner to behind
		local source_pos_a = vector.add(pos, mvdir)
		local target_pos_a = vector.add(source_pos_a, dir)
		
		local src_a = minetest.get_node(source_pos_a)
		local tar_a = minetest.get_node(target_pos_a)
		minetest.swap_node(source_pos_a, tar_a)
		minetest.swap_node(target_pos_a, src_a)
	
		
		local mvdir = vector.subtract(pos, pu_pos)
		minetest.set_node(pu_pos, {name="air"})
		minetest.set_node(or_pos, {name="air"})
		minetest.set_node(pos, {name="air"})
		set_now(vector.add(pu_pos, mvdir), "weirding:purple_node")
		set_now(vector.add(or_pos, mvdir), "weirding:orange_node")
		set_now(vector.add(pos, mvdir), "weirding:green_node")
		
		weirding.just_placed[minetest.hash_node_position(vector.add(pos, mvdir))] = true
		
		
	end,
})