const std = @import("std");

const debug_trace = @import("../core/shared/debug_trace.zig");
const devbox_executor = @import("../core/execution/devbox_executor.zig");
const io_mod = @import("../core/shared/io.zig");

const Allocator = std.mem.Allocator;
const CommandResult = devbox_executor.CommandResult;
const Control = devbox_executor.Control;
const VercelOutcome = devbox_executor.VercelOutcome;

const vercel_http_timeout_sec: i64 = 30;

pub const provider = devbox_executor.Provider{ .execute_fn = executeProvider };

fn executeProvider(
    _: ?*anyopaque,
    alloc: Allocator,
    command: []const u8,
    cwd: []const u8,
    control: Control,
) devbox_executor.ProviderError!VercelOutcome {
    return executeVercel(alloc, command, cwd, control) catch |err| switch (err) {
        error.OutOfMemory => error.OutOfMemory,
        error.Cancelled => error.Cancelled,
        error.TimeoutExpired => error.TimeoutExpired,
    };
}

pub fn executeVercel(
    alloc: Allocator,
    command: []const u8,
    cwd: []const u8,
    control: Control,
) !VercelOutcome {
    try control.check();

    const token = getVercelAuthToken() orelse return .unavailable;
    if (try executeVercelControlled(alloc, command, cwd, token, control)) |result| {
        return .{ .success = result };
    }
    return .request_failed;
}

fn setVercelHttpTimeout(conn: *std.http.Client.Connection) void {
    const sock = conn.stream_writer.stream.socket.handle;
    const timeout = std.posix.timeval{ .sec = vercel_http_timeout_sec, .usec = 0 };
    std.posix.setsockopt(sock, std.posix.SOL.SOCKET, std.posix.SO.RCVTIMEO, std.mem.asBytes(&timeout)) catch |err| {
        debug_trace.logf("core", "vercel sandbox receive timeout setup failed err={s}", .{@errorName(err)});
    };
    std.posix.setsockopt(sock, std.posix.SOL.SOCKET, std.posix.SO.SNDTIMEO, std.mem.asBytes(&timeout)) catch |err| {
        debug_trace.logf("core", "vercel sandbox send timeout setup failed err={s}", .{@errorName(err)});
    };
}

fn executeVercelHttp(alloc: Allocator, scratch: Allocator, token: []const u8, command: []const u8, cwd: []const u8) !CommandResult {
    const started_ms = io_mod.milliTimestamp();
    var body_writer: std.Io.Writer.Allocating = .init(scratch);
    defer body_writer.deinit();
    try body_writer.writer.writeAll("{\"command\":\"sh\",\"args\":[\"-lc\",");
    try std.json.Stringify.value(command, .{}, &body_writer.writer);
    try body_writer.writer.writeAll("],\"cwd\":");
    try std.json.Stringify.value(cwd, .{}, &body_writer.writer);
    try body_writer.writer.writeAll(",\"wait\":true}");
    const request_body = try body_writer.toOwnedSlice();
    defer scratch.free(request_body);

    const auth_header = try std.fmt.allocPrint(scratch, "Bearer {s}", .{token});
    defer scratch.free(auth_header);
    var response_buf: std.Io.Writer.Allocating = .init(scratch);
    defer response_buf.deinit();

    var client: std.http.Client = .{ .allocator = scratch, .io = io_mod.getIo() };
    defer client.deinit();

    const uri = try std.Uri.parse("https://api.vercel.com/v1/sandboxes/cmd");
    var req = try client.request(.POST, uri, .{
        .headers = .{
            .authorization = .{ .override = auth_header },
            .content_type = .{ .override = "application/json" },
        },
        .keep_alive = false,
        .redirect_behavior = .unhandled,
    });
    defer req.deinit();

    if (req.connection) |conn| setVercelHttpTimeout(conn);
    req.transfer_encoding = .{ .content_length = request_body.len };
    var send_buf: [8192]u8 = undefined;
    var request_writer = try req.sendBodyUnflushed(&send_buf);
    try request_writer.writer.writeAll(request_body);
    try request_writer.end();
    try req.connection.?.flush();

    var response = try req.receiveHead(&.{});
    if (response.head.status != .ok) {
        if (req.connection) |conn| conn.closing = true;
        return error.VercelResponseFailure;
    }

    const decompress_buffer: []u8 = switch (response.head.content_encoding) {
        .identity => &.{},
        .zstd => try scratch.alloc(u8, std.compress.zstd.default_window_len),
        .deflate, .gzip => try scratch.alloc(u8, std.compress.flate.max_window_len),
        .compress => return error.UnsupportedCompressionMethod,
    };
    defer if (decompress_buffer.len > 0) scratch.free(decompress_buffer);

    var transfer_buf: [64]u8 = undefined;
    var decompress: std.http.Decompress = undefined;
    const response_reader = response.readerDecompressing(&transfer_buf, &decompress, decompress_buffer);
    _ = response_reader.streamRemaining(&response_buf.writer) catch |err| switch (err) {
        error.ReadFailed => {
            if (response.bodyErr()) |body_err| return body_err;
            return err;
        },
        else => |e| return e,
    };

    const response_body = try response_buf.toOwnedSlice();
    defer scratch.free(response_body);
    return parseVercelResponse(alloc, scratch, response_body, elapsedMs(started_ms, io_mod.milliTimestamp()));
}

const VercelHttpResultTag = enum {
    success,
    fallback,
    oom,
};

const VercelHttpRequest = struct {
    command: []u8,
    cwd: []u8,
    token: []u8,

    fn create(command: []const u8, cwd: []const u8, token: []const u8) !*VercelHttpRequest {
        const alloc = std.heap.c_allocator;
        const self = try alloc.create(VercelHttpRequest);
        errdefer alloc.destroy(self);
        self.* = .{
            .command = try alloc.dupe(u8, command),
            .cwd = &.{},
            .token = &.{},
        };
        errdefer alloc.free(self.command);
        self.cwd = try alloc.dupe(u8, cwd);
        errdefer alloc.free(self.cwd);
        self.token = try alloc.dupe(u8, token);
        return self;
    }

    fn deinit(self: *VercelHttpRequest) void {
        const alloc = std.heap.c_allocator;
        alloc.free(self.command);
        alloc.free(self.cwd);
        alloc.free(self.token);
        alloc.destroy(self);
    }
};

fn executeVercelControlled(alloc: Allocator, command: []const u8, cwd: []const u8, token: []const u8, control: Control) !?CommandResult {
    const request = try VercelHttpRequest.create(command, cwd, token);
    defer request.deinit();

    if (!control.canInterrupt()) {
        const result = runVercelRequest(request) catch |err| switch (err) {
            error.OutOfMemory => return error.OutOfMemory,
            error.Canceled => return error.Cancelled,
            else => {
                debug_trace.logf("core", "vercel sandbox request failed err={s}", .{@errorName(err)});
                return null;
            },
        };
        return finishVercelResult(alloc, result);
    }

    const zio = io_mod.getIo();
    var queue_buf: [2]VercelRaceEvent = undefined;
    var queue = VercelRaceQueue.init(&queue_buf);
    var request_future = zio.concurrent(runVercelRequestQueued, .{ &queue, request }) catch |err| {
        debug_trace.logf("core", "vercel sandbox request concurrency unavailable err={s}", .{@errorName(err)});
        return null;
    };
    var control_future = zio.async(runVercelControlQueued, .{ &queue, control });

    const event = queue.getOne(zio) catch |err| {
        request_future.cancel(zio);
        _ = control_future.cancel(zio) catch {};
        debug_trace.logf("core", "vercel sandbox request race failed err={s}", .{@errorName(err)});
        return null;
    };

    switch (event) {
        .request => |result| {
            _ = control_future.cancel(zio) catch {};
            request_future.await(zio);
            return finishVercelResult(alloc, result);
        },
        .cancelled => {
            request_future.cancel(zio);
            _ = control_future.await(zio) catch {};
            discardQueuedVercelEvents(&queue);
            return error.Cancelled;
        },
        .timed_out => {
            request_future.cancel(zio);
            _ = control_future.await(zio) catch {};
            discardQueuedVercelEvents(&queue);
            return error.TimeoutExpired;
        },
    }
}

fn finishVercelResult(alloc: Allocator, result: VercelHttpResult) !?CommandResult {
    return switch (result) {
        .success => |output| blk: {
            var owned = output;
            defer owned.deinit(std.heap.c_allocator);
            break :blk try owned.clone(alloc);
        },
        .fallback => null,
        .oom => error.OutOfMemory,
    };
}

fn runVercelRequest(request: *VercelHttpRequest) anyerror!VercelHttpResult {
    var scratch_state = std.heap.ArenaAllocator.init(std.heap.c_allocator);
    defer scratch_state.deinit();

    const result = try executeVercelHttp(std.heap.c_allocator, scratch_state.allocator(), request.token, request.command, request.cwd);
    return .{ .success = result };
}

const VercelHttpResult = union(VercelHttpResultTag) {
    success: CommandResult,
    fallback,
    oom,
};

const VercelRaceEvent = union(enum) {
    request: VercelHttpResult,
    cancelled,
    timed_out,
};

const VercelRaceQueue = std.Io.Queue(VercelRaceEvent);

fn runVercelRequestQueued(queue: *VercelRaceQueue, request: *VercelHttpRequest) void {
    const result = runVercelRequest(request) catch |err| switch (err) {
        error.Canceled => return,
        error.OutOfMemory => VercelHttpResult.oom,
        else => blk: {
            debug_trace.logf("core", "vercel sandbox request failed err={s}", .{@errorName(err)});
            break :blk VercelHttpResult.fallback;
        },
    };
    queue.putOneUncancelable(io_mod.getIo(), .{ .request = result }) catch {
        freeVercelResult(result);
    };
}

fn runVercelControlQueued(queue: *VercelRaceQueue, control: Control) std.Io.Cancelable!void {
    while (true) {
        control.check() catch |err| switch (err) {
            error.Cancelled => {
                queue.putOneUncancelable(io_mod.getIo(), .cancelled) catch {};
                return;
            },
            error.TimeoutExpired => {
                queue.putOneUncancelable(io_mod.getIo(), .timed_out) catch {};
                return;
            },
            else => return,
        };
        try std.Io.Timeout.sleep(.{ .duration = .{ .raw = .{ .nanoseconds = 100 * std.time.ns_per_ms }, .clock = .awake } }, io_mod.getIo());
    }
}

fn discardQueuedVercelEvents(queue: *VercelRaceQueue) void {
    var events: [2]VercelRaceEvent = undefined;
    const count = queue.get(io_mod.getIo(), &events, 0) catch 0;
    for (events[0..count]) |event| {
        switch (event) {
            .request => |result| freeVercelResult(result),
            .cancelled, .timed_out => {},
        }
    }
}

fn freeVercelResult(result: VercelHttpResult) void {
    switch (result) {
        .success => |output| {
            var owned = output;
            owned.deinit(std.heap.c_allocator);
        },
        .fallback, .oom => {},
    }
}

fn parseVercelResponse(alloc: Allocator, scratch: Allocator, body: []const u8, duration_ms: ?u64) !CommandResult {
    var parsed = std.json.parseFromSlice(std.json.Value, scratch, body, .{}) catch return error.VercelParseError;
    defer parsed.deinit();
    if (parsed.value != .object) return error.VercelParseError;

    const exit_code_val = parsed.value.object.get("exitCode") orelse return error.VercelParseError;
    const stdout_val = parsed.value.object.get("stdout") orelse return error.VercelParseError;
    const stderr_val = parsed.value.object.get("stderr") orelse return error.VercelParseError;
    if (exit_code_val != .integer or stdout_val != .string or stderr_val != .string) return error.VercelParseError;

    const stdout = try alloc.dupe(u8, stdout_val.string);
    errdefer alloc.free(stdout);
    const stderr = try alloc.dupe(u8, stderr_val.string);
    errdefer alloc.free(stderr);
    return .{
        .exit_code = exit_code_val.integer,
        .stdout = stdout,
        .stderr = stderr,
        .duration_ms = duration_ms,
    };
}

fn elapsedMs(started_ms: i64, finished_ms: i64) u64 {
    return if (finished_ms > started_ms) @intCast(finished_ms - started_ms) else 0;
}

fn getVercelAuthToken() ?[]const u8 {
    return getVercelAuthTokenForProbe(.{
        .oidc_token = io_mod.getenv("VERCEL_OIDC_TOKEN"),
        .token = io_mod.getenv("VERCEL_TOKEN"),
    });
}

const VercelCredentialProbe = struct {
    oidc_token: ?[]const u8 = null,
    token: ?[]const u8 = null,
};

fn getVercelAuthTokenForProbe(probe: VercelCredentialProbe) ?[]const u8 {
    if (probe.oidc_token) |token| return token;
    return probe.token;
}

test "devbox vercel control checks cancellation and timeout before remote work" {
    var cancel = std.atomic.Value(bool).init(true);
    try std.testing.expectError(error.Cancelled, executeVercel(
        std.testing.allocator,
        "printf no",
        "/tmp",
        .{
            .cancel_flag = &cancel,
            .timeout_ms = 1000,
            .started_ms = io_mod.milliTimestamp(),
        },
    ));

    try std.testing.expectError(error.TimeoutExpired, executeVercel(
        std.testing.allocator,
        "printf no",
        "/tmp",
        .{
            .timeout_ms = 0,
            .started_ms = io_mod.milliTimestamp(),
        },
    ));
}

test "devbox vercel auth token prefers oidc and falls back to token" {
    try std.testing.expectEqualStrings("oidc", getVercelAuthTokenForProbe(.{
        .oidc_token = "oidc",
        .token = "token",
    }).?);
    try std.testing.expectEqualStrings("token", getVercelAuthTokenForProbe(.{ .token = "token" }).?);
    try std.testing.expect(getVercelAuthTokenForProbe(.{}) == null);
}

test "devbox vercel json parser handles success and parse failure" {
    var result = try parseVercelResponse(
        std.testing.allocator,
        std.testing.allocator,
        "{\"exitCode\":0,\"stdout\":\"ok\",\"stderr\":\"\"}",
        7,
    );
    defer result.deinit(std.testing.allocator);
    try std.testing.expectEqual(@as(i64, 0), result.exit_code);
    try std.testing.expectEqualStrings("ok", result.stdout);
    try std.testing.expectEqualStrings("", result.stderr);
    try std.testing.expectEqual(@as(?u64, 7), result.duration_ms);
    try std.testing.expectError(
        error.VercelParseError,
        parseVercelResponse(std.testing.allocator, std.testing.allocator, "{}", null),
    );
}