const std = @import("std");
const root = @import("../main.zig");
const argument = root.argument;
const Generator = root.Generator;
const Scheduler = root.Scheduler;

const GenerateArgs = argument.GenerateArgs;

const RandomGenerator = Generator(struct {
	const Self = @This();

	pub fn next(_: *Self, n: usize) usize {
		return std.crypto.random.uintLessThan(usize, n);
	}
});

fn generate_word(
	args: *GenerateArgs,
	generator: *RandomGenerator,
	allocator: std.mem.Allocator
) []const u8 {
	while (true) {
		const text = generator.sentential_from_grammar(
			&args.grammar,
			10000,
			allocator
		) catch continue;
		if (text.len >= args.min_length) {
			return text;
		}

		allocator.free(text);
	}
}

pub fn generate(args: *GenerateArgs, allocator: std.mem.Allocator) !void {
	var writer = args.output.file.writer();

	var scheduler: Scheduler(generate_word) = undefined;
	try scheduler.init(allocator);
	var generator = RandomGenerator {};

	for (0..args.count) |_| {
		try scheduler.push_task(.{args, &generator, allocator});
	}
	
	const results = try scheduler.deinit();
	defer allocator.free(results);

	for (results) |result| {
		try writer.print("{s}\n", .{result});
		allocator.free(result);
	}
}