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

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

pub fn length(v: vec) f32 {
    return @sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
}

pub fn ray_color(r: ray) vec {
    if (hit_sphere(vec{ 0, 0, -1 }, 0.5, r)) |t| {
        const n = unit_vector(r.origin + scalar(t) * r.direction - vec{ 0, 0, -1 });
        return scalar(0.5) * vec{ n[0] + 1, n[1] + 1, n[2] + 1 };
    }
    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 });
}

pub fn hit_sphere(center: vec, radius: f32, r: ray) ?f32 {
    const oc = r.origin - center;
    const a = dot(r.direction, r.direction);
    const b = 2 * dot(oc, r.direction);
    const c = dot(oc, oc) - radius * radius;
    const discriminant = b * b - 4 * a * c;
    if (discriminant < 0) {
        return null;
    } else {
        return (-b - @sqrt(discriminant)) / (2 * a);
    }
}

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

pub fn dot(x: vec, y: vec) f32 {
    return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
}

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();
}