const coral = @import("coral");

const kym = @import("kym");

const ona = @import("ona");

const transform_typeid = @typeName(ona.canvas.Transform);

fn new_canvas_item(environment: *kym.vm.Environment, canvas_item: ona.CanvasItem) !*kym.vm.Object {
	const typeid = @typeName(ona.CanvasItem);

	var object = try environment.new(.{
		.userdata = coral.io.bytes_of(&canvas_item),
		.identity = typeid,
	});

	errdefer environment.release(object);

	return object;
}

fn new_transform(environment: *kym.Environment, transform: ona.canvas.Transform) !*kym.vm.Object {
	var object = try environment.new(.{
		.userdata = coral.io.bytes_of(&transform),
		.identity = transform_typeid,
	});

	errdefer environment.release(object);

	return object;
}

pub fn main() anyerror!void {
	return ona.App.run(anyerror, start);
}

fn start(app: *ona.App) anyerror!void {
	var kym_environment = try kym.vm.Environment.init(ona.allocator, .{
		.stack_max = 256,
		.calls_max = 256,
	});

	defer kym_environment.deinit();

	const Ona = struct {
		app: *ona.App,

		const typeid = @typeName(ona.App);
	};

	var ona_lib = try kym_environment.new(.{
		.userdata = coral.io.bytes_of(&Ona{
			.app = app,
		}),

		.identity = Ona.typeid,
	});

	defer kym_environment.release(ona_lib);

	try kym_environment.global_set("ona", ona_lib.as_value());

	{
		var sprite_creator = try kym_environment.new(.{.behavior = &.{.caller = struct {
			fn call(context: kym.vm.Object.CallContext) kym.vm.RuntimeError!kym.vm.Value {
				try context.env.check(context.args.len == 2, "2 arguments expected");

				var item = try ona.CanvasItem.init((try context.env.user_cast(context.caller, Ona.typeid, Ona)).app, .{
					.transform = (try context.env.user_cast(context.args[0].object, transform_typeid, ona.canvas.Transform)).*,
					.options = .{.sprite = .{}},
				});

				errdefer item.deinit();

				return (try new_canvas_item(context.env, item)).as_value();
			}
		}.call}});

		defer kym_environment.release(sprite_creator);

		try kym_environment.raw_set(ona_lib, "create_sprite", sprite_creator.as_value());
	}

	{
		const index_path = "index.kym";
		const index_file = try app.data_fs().open_readable(index_path);

		defer if (!index_file.close()) ona.log_error(&.{.{.string = "failed to close "}, .{.string = index_path}});

		const index_size = (try app.data_fs().query(index_path)).size;
		const index_allocation = try coral.io.allocate_many(u8, index_size, ona.allocator);

		defer coral.io.deallocate(ona.allocator, index_allocation);

		var index_buffer = coral.buffer.Fixed{.data = index_allocation[0 .. index_size]};

		{
			var stream_buffer = [_]u8{0} ** 1024;

			if ((try coral.io.stream(index_buffer.as_writer(), index_file.as_reader(), &stream_buffer)) != index_size)
				return error.IoUnavailable;
		}

		{
			const index_script = try kym_environment.new_script(.{
				.name = index_path,
				.data = index_buffer.data
			});

			defer kym_environment.release(index_script);

			_ = try kym_environment.call(index_script, &.{});
		}
	}

	app.loop();
}