const std = @import("std");
const http = @import("apple_pie");

const images_dir_path = "./images";

pub fn main() anyerror!void {
    std.log.info("All your codebase are belong to us.", .{});

    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    const bind_addr = try std.net.Address.parseIp("0.0.0.0", 8080);
    std.log.info("serving on {}", .{bind_addr});

    // TODO: configurable path via env var
    try std.fs.cwd().makePath(images_dir_path);

    try http.listenAndServe(
        &gpa.allocator,
        bind_addr,
        comptime http.router.router(&[_]http.router.Route{
            http.router.get("/", index),
            http.router.post("/api/upload", uploadFile),
            http.router.get("/i/:filename", fetchFile),
        }),
    );
}

fn index(response: *http.Response, request: http.Request) !void {
    try response.writer().writeAll("Hello Zig!");
}

fn generateImageId(buffer: []u8) []const u8 {
    var i: usize = 0;

    const seed = @truncate(u64, @bitCast(u128, std.time.nanoTimestamp()));
    var r = std.rand.DefaultPrng.init(seed);

    while (i < 16) : (i += 1) {
        // random ascii lowercase char
        var idx = @intCast(u8, r.random.uintLessThan(u5, 24));
        var letter = @as(u8, 97) + idx;
        buffer[i] = letter;
    }

    return buffer[0..i];
}

const Part = struct {};

const Multipart = struct {
    body: []const u8,
    boundary: []const u8,
    cursor: usize = 0,

    const Self = @This();

    pub fn init(body: []const u8, content_type: []const u8) !Multipart {
        // parse content_type into what we want (the boundary)
        var it = std.mem.split(content_type, ";");
        const should_be_multipart = it.next() orelse return error.MissingContentType;
        if (!std.mem.eql(u8, should_be_multipart, "multipart/form-data"))
            return error.InvalidContentType;

        const should_be_boundary = it.next() orelse return error.MissingBoundary;
        if (!std.mem.startsWith(u8, should_be_boundary, " boundary="))
            return error.InvalidBoundary;

        var boundary_it = std.mem.split(should_be_boundary, "=");
        _ = boundary_it.next();
        const boundary_value = boundary_it.next() orelse return error.InvalidBoundary;

        return Self{ .body = body, .boundary = boundary_value };
    }

    pub fn next(self: *Self) !?Part {
        return null;
    }
};

fn uploadFile(response: *http.Response, request: http.Request) !void {
    std.log.info("upload! got {d} bytes", .{request.body.len});

    // find content-type header
    var it = request.iterator();
    var content_type: ?[]const u8 = null;
    while (it.next()) |header| {
        if (std.mem.eql(u8, header.key, "Content-Type")) {
            content_type = header.value;
        }
    }

    if (content_type == null) return error.InvalidContentType;

    // parse multipart data
    var multipart = try Multipart.init(request.body, content_type.?);

    while (try multipart.next()) |part| {
        std.log.info("part: {}", .{part});
    }

    var image_id_buffer: [256]u8 = undefined;
    const image_id = generateImageId(&image_id_buffer);

    var image_path_buffer: [512]u8 = undefined;
    const image_path = try std.fmt.bufPrint(
        &image_path_buffer,
        "{s}/{s}.jpg",
        .{ images_dir_path, image_id },
    );

    const image_file = try std.fs.cwd().createFile(image_path, .{});
    try image_file.writer().writeAll(request.body);

    try response.writer().writeAll(image_path);
}

fn fetchFile(response: *http.Response, request: http.Request, filename: []const u8) !void {
    std.log.info("got name: {s}", .{filename});
    var image_path_buffer: [512]u8 = undefined;

    const images_dir = try std.fs.cwd().openDir(images_dir_path, .{});
    const image_path = try std.fmt.bufPrint(
        &image_path_buffer,
        "{s}/{s}",
        .{ images_dir_path, filename },
    );

    // TODO return 404 on error
    const image_file = try std.fs.cwd().openFile(image_path, .{ .read = false });
    while (true) {
        var file_write_buffer: [1024]u8 = undefined;
        const bytes_read = try image_file.read(&file_write_buffer);
        if (bytes_read == 0) return;
        try response.writer().writeAll(&file_write_buffer);
    }
}