const std = @import("std");
const warn = @import("std").debug.print;

pub fn unit_vector(v: vec) vec {
    return v / scalar(3);
}

pub fn ray_color(r: ray) vec {
    const direction = unit_vector(r.direction);
    const t = 0.5 * (direction[1] + 1.0);
    return scalar(1.0 - t) * vec{ 1.0, 1.0, 1.0 } + scalar(t) * vec{ 0.5, 0.7, 1.0 };
}

pub fn write_color(stdout: anytype, v: vec) !void {
    const r = @floatToInt(usize, v[0] * 255.999);
    const g = @floatToInt(usize, v[1] * 255.999);
    const b = @floatToInt(usize, v[2] * 255.999);
    try stdout.print("{} {} {}\n", .{ r, g, b });
}

const vec = @Vector(3, f32);
pub fn scalar(x: f32) vec {
    return @splat(3, x);
}

const ray = struct { origin: vec, direction: vec };

pub fn main() !void {
    const aspect_ratio: f32 = 16.0 / 9.0;
    const width: usize = 1000;
    const height: usize = @floatToInt(usize, @intToFloat(f32, width) / aspect_ratio);
    const stdout_file = std.io.getStdOut().writer();
    var bw = std.io.bufferedWriter(stdout_file);
    const stdout = bw.writer();

    const viewport_height = 2.0;
    const viewport_width = aspect_ratio * viewport_height;
    const focal_length = 1.0;
    const origin = vec{ 0, 0, 0 };
    const horizontal = vec{ viewport_width, 0, 0 };
    const vertical = vec{ 0, viewport_height, 0 };
    const lower_left_corner = origin - (horizontal / scalar(2.0)) - (vertical / scalar(2.0)) - vec{ 0, 0, focal_length };

    try stdout.print("P3\n{} {}\n255\n", .{ width, height });

    var j: usize = height;
    while (j > 0) : (j -= 1) {
        warn("remaining: {}\n", .{j});
        var i: usize = 0;
        while (i < width) : (i += 1) {
            var u = scalar(@intToFloat(f32, i) / @intToFloat(f32, width - 1));
            var v = scalar(@intToFloat(f32, j) / @intToFloat(f32, height - 1));
            var color = ray_color(ray{ .origin = origin, .direction = lower_left_corner + u * horizontal + v * vertical - origin });

            try write_color(stdout, color);
        }
    }
    try bw.flush();
}