//! todo-zig: TodoMVC for the CARLOS bakeoff.
//!
//!   app --socket <path> --db <path>             (on Carloku)
//!   app --listen 127.0.0.1:<port> --db <path>   (locally)
//!
//! Each connection runs as its own task on `std.Io`'s threaded backend.
//! SIGTERM shuts the listening socket down, which ends the accept loop;
//! open connections are cancelled and the database is closed before exit.

const std = @import("std");
const Io = std.Io;
const net = Io.net;
const db = @import("db.zig");
const app_mod = @import("app.zig");

const usage = "usage: app (--socket <path> | --listen 127.0.0.1:<port>) --db <path>\n";

pub fn main(init: std.process.Init) !void {
    const io = init.io;
    const gpa = init.gpa;
    const arena = init.arena.allocator();

    var socket_path: ?[]const u8 = null;
    var listen_addr: ?[]const u8 = null;
    var db_path: ?[:0]const u8 = null;
    var args = init.minimal.args.iterate();
    _ = args.skip();
    while (args.next()) |arg| {
        if (std.mem.eql(u8, arg, "--socket")) {
            socket_path = args.next() orelse return fail(usage);
        } else if (std.mem.eql(u8, arg, "--listen")) {
            listen_addr = args.next() orelse return fail(usage);
        } else if (std.mem.eql(u8, arg, "--db")) {
            db_path = args.next() orelse return fail(usage);
        } else return fail(usage);
    }
    const db_file = db_path orelse return fail(usage);
    if ((socket_path == null) == (listen_addr == null)) return fail(usage);

    var store = db.Store.open(io, db_file) catch return fail("cannot open the database\n");
    defer store.close();

    // A POST's Origin must be this app's own: https://$CARLOS_HOST on the
    // platform, http://<listen address> locally.
    var origins: std.ArrayList([]const u8) = .empty;
    if (init.environ_map.get("CARLOS_HOST")) |host| {
        if (host.len > 0) try origins.append(arena, try std.fmt.allocPrint(arena, "https://{s}", .{host}));
    }
    if (listen_addr) |addr| try origins.append(arena, try std.fmt.allocPrint(arena, "http://{s}", .{addr}));

    const app: app_mod.App = .{
        .store = &store,
        .io = io,
        .origins = origins.items,
        .https = socket_path != null,
    };

    var server = if (socket_path) |path| unix: {
        Io.Dir.cwd().deleteFile(io, path) catch |err| switch (err) {
            error.FileNotFound => {},
            else => return err,
        };
        const ua = try net.UnixAddress.init(path);
        break :unix try ua.listen(io, .{});
    } else tcp: {
        const ip = net.IpAddress.parseLiteral(listen_addr.?) catch return fail("--listen wants 127.0.0.1:<port>\n");
        if (ip != .ip4 or !std.mem.eql(u8, &ip.ip4.bytes, &.{ 127, 0, 0, 1 })) {
            return fail("--listen binds 127.0.0.1 only\n");
        }
        break :tcp try ip.listen(io, .{ .reuse_address = true });
    };
    defer {
        server.deinit(io);
        if (socket_path) |path| Io.Dir.cwd().deleteFile(io, path) catch {};
    }

    listen_fd.store(server.socket.handle, .release);
    const on_stop: std.posix.Sigaction = .{
        .handler = .{ .handler = stop },
        .mask = std.posix.sigemptyset(),
        .flags = 0,
    };
    std.posix.sigaction(.TERM, &on_stop, null);
    std.posix.sigaction(.INT, &on_stop, null);

    std.log.info("todo-zig {s} listening on {s}", .{
        @import("build_options").version,
        socket_path orelse listen_addr.?,
    });

    var connections: Io.Group = .init;
    defer connections.cancel(io);
    while (true) {
        const stream = server.accept(io) catch |err| switch (err) {
            error.SocketNotListening => break,
            error.ConnectionAborted => continue,
            else => {
                std.log.err("accept: {t}", .{err});
                continue;
            },
        };
        connections.concurrent(io, serve, .{ &app, gpa, stream }) catch {
            // No thread to spare: serve it here rather than drop it.
            serve(&app, gpa, stream);
        };
    }
    std.log.info("shutting down", .{});
}

/// Answers requests on one connection until the client or server closes it.
fn serve(app: *const app_mod.App, gpa: std.mem.Allocator, stream: net.Stream) void {
    const io = app.io;
    defer stream.close(io);
    var read_buf: [16 * 1024]u8 = undefined;
    var write_buf: [16 * 1024]u8 = undefined;
    var reader = stream.reader(io, &read_buf);
    var writer = stream.writer(io, &write_buf);
    var http: std.http.Server = .init(&reader.interface, &writer.interface);
    var arena: std.heap.ArenaAllocator = .init(gpa);
    defer arena.deinit();

    while (true) {
        var req = http.receiveHead() catch return;
        const keep_alive = req.head.keep_alive;
        app_mod.handle(app, &req, arena.allocator()) catch |err| {
            std.log.err("{s}: {t}", .{ @tagName(req.head.method), err });
            req.respond("internal error\n", .{ .status = .internal_server_error, .keep_alive = false }) catch {};
            return;
        };
        _ = arena.reset(.retain_capacity);
        if (!keep_alive or http.reader.state != .ready) return;
    }
}

var listen_fd: std.atomic.Value(std.posix.fd_t) = .init(-1);

/// Signal handler: shutting the listening socket down wakes `accept` with
/// `error.SocketNotListening`. shutdown(2) is async-signal-safe.
fn stop(_: std.posix.SIG) callconv(.c) void {
    const fd = listen_fd.load(.acquire);
    if (fd >= 0) _ = std.c.shutdown(fd, std.posix.SHUT.RDWR);
}

fn fail(msg: []const u8) error{InvalidArguments} {
    std.debug.print("{s}", .{msg});
    return error.InvalidArguments;
}

test {
    _ = @import("app.zig");
    _ = @import("view.zig");
    _ = @import("db.zig");
    _ = @import("db_test.zig");
}