const vigil = b.dependency("vigil", .{
    .target = target,
    .optimize = optimize,
});
exe.root_module.addImport("vigil", vigil.module("vigil"));

const std = @import("std");
const vigil = @import("vigil");

fn worker() void {
    std.debug.print("Worker running\n", .{});
    vigil.compat.sleep(100 * std.time.ns_per_ms);
}

pub fn main() !void {
    var gpa: std.heap.DebugAllocator(.{}) = .init;
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var app = try vigil.app(allocator);
    defer app.shutdown();
    _ = try app.worker("task1", worker);
    _ = try app.workerPool("pool", worker, 4);
    try app.start();
}

var rt = try vigil.runtime(allocator, .{});
defer rt.deinit();

var inbox = try rt.inbox(.{ .capacity = 128 });
defer inbox.close();

try inbox.send("hello from the runtime");

var snapshot = try rt.snapshot(allocator);
defer snapshot.deinit();

const health = try rt.health(allocator);
if (!health.ready) {
    // Surface degraded runtime state in your service health endpoint.
}

var inbox = try vigil.inbox(allocator);
defer inbox.close();

try inbox.send("hello");

if (try inbox.recvTimeout(1000)) |msg| {
    defer msg.deinit();
    std.debug.print("Received: {s}\n", .{msg.payload.?});
}

var jobs = try rt.inbox(.{
    .capacity = 1,
    .dead_letter_capacity = 32,
    .max_delivery_attempts = 3,
});
defer jobs.close();

try jobs.send("active");
try jobs.send("retained while full");

var dead_letters = try jobs.deadLetters(allocator);
defer dead_letters.deinit();
const retained_id = dead_letters.entries[0].id;

var active = try jobs.recv();
active.deinit();
_ = try jobs.replayDeadLetter(retained_id);

var breaker = try vigil.CircuitBreaker.init(allocator, "api", .{
    .failure_threshold = 5,
    .reset_timeout_ms = 30000,
});
defer breaker.deinit();

if (breaker.getState() == .open) {
    // Service unavailable, fail fast
}

const Result = enum { ok, fallback };

const Client = struct {
    attempts: u32 = 0,

    fn call(self: *@This()) anyerror!Result {
        self.attempts += 1;
        if (self.attempts < 3) return error.TemporaryFailure;
        return .ok;
    }

    fn fallback(_: *@This(), _: vigil.PolicyFailure) anyerror!Result {
        return .fallback;
    }
};

var client = Client{};
const result = vigil.executePolicy(Client, Result, &client, Client.call, .{
    .retry = .{
        .max_attempts = 3,
        .backoff = .{ .exponential = .{ .initial_ms = 10, .max_ms = 100 } },
    },
    .timeout_ms = 500,
    .fallback = Client.fallback,
});

switch (result) {
    .success => |success| std.debug.print("result={s}\n", .{@tagName(success.value)}),
    .fallback => |fallback| std.debug.print("fallback={s} from={s}\n", .{
        @tagName(fallback.value),
        @tagName(fallback.report.fallback_from.?),
    }),
    .timeout => |failure| std.debug.print("timeout after {d} attempt(s)\n", .{failure.attempts}),
    .circuit_open => |failure| std.debug.print("circuit open after {d} attempt(s)\n", .{failure.attempts}),
    .permanent_failure => |failure| std.debug.print("failed outcome={s}\n", .{@tagName(failure.outcome)}),
}

var limiter = vigil.RateLimiter.init(100); // 100 ops/sec

if (limiter.allow()) {
    // Process request
} else {
    // Rate limited
}

var group = try vigil.ProcessGroup.init(allocator, "workers");
defer group.deinit();

try group.add("worker1", inbox1);
try group.add("worker2", inbox2);

try group.broadcast("message");  // Send to all
try group.roundRobin("message"); // Load balance

// Production: conservative restarts, monitoring enabled
var app = try vigil.appWithPreset(allocator, .production);

// Development: verbose logging, quick restarts
var app = try vigil.appWithPreset(allocator, .development);

// High availability: intensive health checks
var app = try vigil.appWithPreset(allocator, .high_availability);

// Testing: minimal restarts, fast health checks
var app = try vigil.appWithPreset(allocator, .testing);