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

pub fn ray_color(r: ray) vec.vec {
    if (hit_sphere(vec.init(0, 0, -1), 0.5, r)) |t| {
        const n = vec.unit_vector(r.origin + vec.scalar(t) * r.direction - vec.init(0, 0, -1));
        return vec.scalar(0.5) * vec.init(n[0] + 1, n[1] + 1, n[2] + 1);
    }
    const direction = vec.unit_vector(r.direction);
    const t = 0.5 * (direction[1] + 1.0);
    return vec.scalar(1.0 - t) * vec.init(1.0, 1.0, 1.0) + vec.scalar(t) * vec.init(0.5, 0.7, 1.0);
}

pub fn write_color(stdout: anytype, v: vec.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.vec, radius: f32, r: ray) ?f32 {
    const oc = r.origin - center;
    const a = vec.length_squared(r.direction);
    const half_b = vec.dot(oc, r.direction);
    const c = vec.length_squared(oc) - radius * radius;
    const discriminant = half_b * half_b - a * c;
    if (discriminant < 0) {
        return null;
    } else {
        return (-half_b - @sqrt(discriminant)) / a;
    }
}

const ray = struct { origin: vec.vec, direction: vec.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.init(0, 0, 0);
    const horizontal = vec.init(viewport_width, 0, 0);
    const vertical = vec.init(0, viewport_height, 0);
    const lower_left_corner = origin - (horizontal / vec.scalar(2.0)) - (vertical / vec.scalar(2.0)) - vec.init(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 = vec.scalar(@intToFloat(f32, i) / @intToFloat(f32, width - 1));
            var v = vec.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();
}