class Async::Scheduler

def self.supported?
	true
end

def address_resolve(hostname)
	::Resolv.getaddresses(hostname)
end

def async(*arguments, **options, &block)
	task = Task.new(Task.current? || self, **options, &block)
	
	# I want to take a moment to explain the logic of this.
	# When calling an async block, we deterministically execute it until the
	# first blocking operation. We don't *have* to do this - we could schedule
	# it for later execution, but it's useful to:
	# - Fail at the point of the method call where possible.
	# - Execute determinstically where possible.
	# - Avoid scheduler overhead if no blocking operation is performed.
	task.run(*arguments)
	
	# Console.logger.debug "Initial execution of task #{fiber} complete (#{result} -> #{fiber.alive?})..."
	return task
end

def block(blocker, timeout)
	# $stderr.puts "block(#{blocker}, #{Fiber.current}, #{timeout})"
	fiber = Fiber.current
	
	if timeout
		timer = @timers.after(timeout) do
			if fiber.alive?
				fiber.transfer(false)
			end
		end
	end
	
	begin
		@blocked += 1
		@selector.transfer
	ensure
		@blocked -= 1
	end
ensure
	timer&.cancel
end

def close
	# This is a critical step. Because tasks could be stored as instance variables, and since the reactor is (probably) going out of scope, we need to ensure they are stopped. Otherwise, the tasks will belong to a reactor that will never run again and are not stopped.
	self.terminate
	
	Kernel::raise "Closing scheduler with blocked operations!" if @blocked > 0
	
	# We depend on GVL for consistency:
	# @guard.synchronize do
	
	@selector&.close
	@selector = nil
	
	# end
	
	consume
end

def closed?
	@selector.nil?
end

def fiber(...)
	return async(...).fiber
end

def initialize(parent = nil, selector: nil)
	super(parent)
	
	@selector = selector || ::IO::Event::Selector.new(Fiber.current)
	@interrupted = false
	
	@blocked = 0
	
	@timers = ::Timers::Group.new
end

def interrupt
	@interrupted = true
	@selector.wakeup
end

def io_read(io, buffer, length, offset = 0)
	@selector.io_read(Fiber.current, io, buffer, length, offset)
end

def io_wait(io, events, timeout = nil)
	fiber = Fiber.current
	
	if timeout
		timer = @timers.after(timeout) do
			fiber.raise(TimeoutError)
		end
	end
	
	# Console.logger.info(self, "-> io_wait", fiber, io, events)
	events = @selector.io_wait(fiber, io, events)
	# Console.logger.info(self, "<- io_wait", fiber, io, events)
	
	return events
rescue TimeoutError
	return false
ensure
	timer&.cancel
end

def io_write(io, buffer, length, offset = 0)
	@selector.io_write(Fiber.current, io, buffer, length, offset)
end

def kernel_sleep(duration = nil)
	if duration
		self.block(nil, duration)
	else
		self.transfer
	end
end

def process_wait(pid, flags)
	return @selector.process_wait(Fiber.current, pid, flags)
end

def push(fiber)
	@selector.push(fiber)
end

def raise(*arguments)
	@selector.raise(*arguments)
end

def resume(fiber, *arguments)
	@selector.resume(fiber, *arguments)
end

def run(...)
	Kernel::raise RuntimeError, 'Reactor has been closed' if @selector.nil?
	
	initial_task = self.async(...) if block_given?
	
	@interrupted = false
	
	while self.run_once
		if @interrupted
			break
		end
	end
	
	return initial_task
ensure
	Console.logger.debug(self) {"Exiting run-loop because #{$! ? $! : 'finished'}."}
end

def run_once(timeout = nil)
	Kernel::raise "Running scheduler on non-blocking fiber!" unless Fiber.blocking?
	
	# If we are finished, we stop the task tree and exit:
	if self.finished?
		return false
	end
	
	interval = @timers.wait_interval
	
	# If there is no interval to wait (thus no timers), and no tasks, we could be done:
	if interval.nil?
		# Allow the user to specify a maximum interval if we would otherwise be sleeping indefinitely:
		interval = timeout
	elsif interval < 0
		# We have timers ready to fire, don't sleep in the selctor:
		interval = 0
	elsif timeout and interval > timeout
		interval = timeout
	end
	
	begin
		@selector.select(interval)
	rescue Errno::EINTR
		# Ignore.
	end
	
	@timers.fire
	
	# The reactor still has work to do:
	return true
end

def timeout_after(duration, exception, message, &block)
	with_timeout(duration, exception, message) do |timer|
		yield duration
	end
end

def to_s
	"\#<#{self.description} #{@children&.size || 0} children (#{stopped? ? 'stopped' : 'running'})>"
end

def transfer
	@selector.transfer
end

def unblock(blocker, fiber)
	# $stderr.puts "unblock(#{blocker}, #{fiber})"
	
	# This operation is protected by the GVL:
	@selector.push(fiber)
	@selector.wakeup
end

def with_timeout(duration, exception = TimeoutError, message = "execution expired", &block)
	fiber = Fiber.current
	
	timer = @timers.after(duration) do
		if fiber.alive?
			fiber.raise(exception, message)
		end
	end
	
	yield timer
ensure
	timer.cancel if timer
end

def yield
	@selector.yield
end