#!/usr/bin/env ruby
# frozen_string_literal: true

require "json"

require_relative "../lib/sus/config"
config = Sus::Config.load

require_relative "../lib/sus"

verbose = false
guard = Thread::Mutex.new

require "etc"
count = Etc.nprocessors

$stdout.sync = true

require_relative "../lib/sus/output/structured"

input = $stdin.dup
$stdin.reopen(File::NULL)
output = $stdout.dup
$stdout.reopen($stderr)

def messages_for(assertions)
	messages = []
	
	assertions.each_failure do |failure|
		messages << failure.message
	end
	
	return messages
end

while line = input.gets
	message = JSON.parse(line)
	
	if tests = message["run"]
		jobs = Thread::Queue.new
		results = Thread::Queue.new
		
		top = Sus::Assertions.new(measure: true)
		config.before_tests(top)
		
		aggregate = Thread.new do
			while result = results.pop
				top.add(result)
			end
		end
		
		loader = Thread.new do
			registry = config.load_registry(tests)
			
			registry.each do |child|
				jobs << child
			end
			
			jobs.close
		end
		
		workers = count.times.map do |index|
			Thread.new do
				while job = jobs.pop
					guard.synchronize do
						output.puts JSON.generate({started: job.identity})
					end
					
					structured_output = Sus::Output::Structured.buffered(output, job.identity)
					
					assertions = Sus::Assertions.new(output: structured_output, measure: true)
					job.call(assertions)
					results.push(assertions)
					
					guard.synchronize do
						if assertions.passed?
							output.puts JSON.generate({passed: job.identity, messages: messages_for(assertions), duration: assertions.clock.ms})
						elsif assertions.errored?
							output.puts JSON.generate({errored: job.identity, messages: messages_for(assertions), duration: assertions.clock.ms})
						else
							output.puts JSON.generate({failed: job.identity, messages: messages_for(assertions), duration: assertions.clock.ms})
						end
					end
				end
			end
		end
		
		loader.join
		workers.each(&:join)
		results.close
		
		aggregate.join
		config.after_tests(top)
		
		workers.each(&:join)
		
		if config.respond_to?(:covered)
			if covered = config.covered and covered.record?
				covered.policy.each do |coverage|
					output.puts JSON.generate({coverage: coverage.path, counts: coverage.counts})
				end
			end
		end
		
		output.puts JSON.generate({finished: true, message: top.output.string, duration: top.clock.ms})
	else
		$stderr.puts "Unknown message: #{message}"
	end
end
