const std = @import("std");
const types = @import("../shared/types.zig");

pub const HookKind = enum {
    pre_tool_use,
    stop,
    post_turn_end,
    attention_required,

    pub fn definition(self: HookKind) HookDefinition {
        return switch (self) {
            .pre_tool_use => pre_tool_use,
            .stop => stop,
            .post_turn_end => post_turn_end,
            .attention_required => attention_required,
        };
    }
};

pub const HookDefinition = struct {
    kind: HookKind,
    lifecycle_event: []const u8,
    agent_loop_point: []const u8,
    purpose: []const u8,
};

pub const pre_tool_use = HookDefinition{
    .kind = .pre_tool_use,
    .lifecycle_event = "PreToolUse",
    .agent_loop_point = "before local tool validation, permissions, and execution",
    .purpose = "lets handlers keep a call unchanged, rewrite its arguments, or block it",
};

pub const stop = HookDefinition{
    .kind = .stop,
    .lifecycle_event = "Stop",
    .agent_loop_point = "after a terminal assistant candidate before turn finalization",
    .purpose = "lets handlers allow completion or request one synthetic continuation",
};

pub const post_turn_end = HookDefinition{
    .kind = .post_turn_end,
    .lifecycle_event = "PostTurnEnd",
    .agent_loop_point = "after a terminal turn outcome is accepted",
    .purpose = "lets handlers observe terminal turns and run side effects without changing the turn outcome",
};

pub const attention_required = HookDefinition{
    .kind = .attention_required,
    .lifecycle_event = "AttentionRequired",
    .agent_loop_point = "after a user decision prompt becomes active",
    .purpose = "lets handlers observe when a foreground turn is waiting for user attention",
};

pub const all_hooks = [_]HookDefinition{
    pre_tool_use,
    stop,
    post_turn_end,
    attention_required,
};

pub const ScopeKind = enum {
    interactive,
    ask,
    acp,
    subagent,
};

pub const Scope = struct {
    kind: ScopeKind,
    workspace_root: []const u8,
    session_id: ?[]const u8 = null,
    subagent_id: ?u64 = null,
};

pub const Invocation = struct {
    scope: Scope,
    turn_id: ?u64 = null,
};

pub const Limits = struct {
    pub const handler_name_bytes = 128;
    pub const reason_bytes = 4 * 1024;
    pub const context_bytes = 64 * 1024;
    pub const arguments_json_bytes = 1024 * 1024;
};

pub const RegistrationError = error{
    EmptyHandlerName,
    HandlerNameTooLong,
    InvalidHandlerName,
    DuplicateHandlerName,
    RuntimeFrozen,
};

pub const ViewError = error{
    RuntimeNotFrozen,
};

pub const HandlerError = error{
    Failed,
    Cancelled,
};

pub const MutationDispatchError = error{
    OutOfMemory,
    HandlerFailed,
    Cancelled,
    InvalidHandlerOutput,
    HandlerOutputTooLarge,
};

pub const PreToolUseInput = struct {
    invocation: Invocation,
    step_index: usize,
    call_id: []const u8,
    tool_name: []const u8,
    arguments_json: []const u8,
};

pub const PreToolUseAction = union(enum) {
    continue_,
    rewrite_arguments: []const u8,
    block: []const u8,
};

pub const PreToolUseOutcome = union(enum) {
    unchanged,
    rewritten: []u8,
    blocked: []u8,

    pub fn deinit(self: *PreToolUseOutcome, alloc: std.mem.Allocator) void {
        switch (self.*) {
            .rewritten => |arguments_json| alloc.free(arguments_json),
            .blocked => |reason| alloc.free(reason),
            .unchanged => {},
        }
        self.* = .unchanged;
    }
};

pub const PreToolUseHandler = struct {
    name: []const u8,
    ctx: *anyopaque,
    run: *const fn (
        ctx: *anyopaque,
        input: PreToolUseInput,
    ) HandlerError!PreToolUseAction,
};

pub const StopInput = struct {
    invocation: Invocation,
    step_index: usize,
    assistant_text: []const u8,
    provider_disposition: types.ProviderCompletionDisposition,
    can_continue: bool,
};

pub const StopAction = union(enum) {
    allow,
    continue_once: []const u8,
};

pub const StopOutcome = union(enum) {
    allow,
    continue_once: []u8,

    pub fn deinit(self: *StopOutcome, alloc: std.mem.Allocator) void {
        switch (self.*) {
            .continue_once => |context| alloc.free(context),
            .allow => {},
        }
        self.* = .allow;
    }
};

pub const StopHandler = struct {
    name: []const u8,
    ctx: *anyopaque,
    run: *const fn (
        ctx: *anyopaque,
        input: StopInput,
    ) HandlerError!StopAction,
};

pub const PostTurnEndInput = struct {
    invocation: Invocation,
    outcome: types.TurnPresentationOutcome,
    provider_disposition: ?types.ProviderCompletionDisposition = null,
};

pub const PostTurnEndHandler = struct {
    name: []const u8,
    ctx: *anyopaque,
    run: *const fn (
        ctx: *anyopaque,
        input: PostTurnEndInput,
    ) HandlerError!void,
};

pub const AttentionKind = enum {
    permission,
    question,
    route_recovery,
};

pub const AttentionRequiredInput = struct {
    invocation: Invocation,
    kind: AttentionKind,
};

pub const AttentionRequiredHandler = struct {
    name: []const u8,
    ctx: *anyopaque,
    run: *const fn (
        ctx: *anyopaque,
        input: AttentionRequiredInput,
    ) HandlerError!void,
};

test "hook definitions enumerate current hook surfaces" {
    try std.testing.expectEqual(@as(usize, 4), all_hooks.len);
    try std.testing.expectEqual(HookKind.pre_tool_use, all_hooks[0].kind);
    try std.testing.expectEqual(HookKind.stop, all_hooks[1].kind);
    try std.testing.expectEqual(HookKind.post_turn_end, all_hooks[2].kind);
    try std.testing.expectEqual(HookKind.attention_required, all_hooks[3].kind);
    try std.testing.expectEqualStrings("PreToolUse", pre_tool_use.lifecycle_event);
    try std.testing.expectEqualStrings("Stop", stop.lifecycle_event);
    try std.testing.expectEqualStrings("PostTurnEnd", post_turn_end.lifecycle_event);
    try std.testing.expectEqualStrings("AttentionRequired", attention_required.lifecycle_event);
    try std.testing.expectEqual(HookKind.pre_tool_use, HookKind.pre_tool_use.definition().kind);
    try std.testing.expectEqual(HookKind.stop, HookKind.stop.definition().kind);
    try std.testing.expectEqual(HookKind.post_turn_end, HookKind.post_turn_end.definition().kind);
    try std.testing.expectEqual(HookKind.attention_required, HookKind.attention_required.definition().kind);
    try std.testing.expectEqualStrings("PreToolUse", HookKind.pre_tool_use.definition().lifecycle_event);
    try std.testing.expectEqualStrings("Stop", HookKind.stop.definition().lifecycle_event);
    try std.testing.expectEqualStrings("PostTurnEnd", HookKind.post_turn_end.definition().lifecycle_event);
    try std.testing.expectEqualStrings("AttentionRequired", HookKind.attention_required.definition().lifecycle_event);
    try std.testing.expect(pre_tool_use.agent_loop_point.len > 0);
    try std.testing.expect(pre_tool_use.purpose.len > 0);
    try std.testing.expect(stop.agent_loop_point.len > 0);
    try std.testing.expect(stop.purpose.len > 0);
    try std.testing.expect(post_turn_end.agent_loop_point.len > 0);
    try std.testing.expect(post_turn_end.purpose.len > 0);
    try std.testing.expect(attention_required.agent_loop_point.len > 0);
    try std.testing.expect(attention_required.purpose.len > 0);
}

test "Hooks v1.0 scope kinds remain limited to the current surfaces" {
    try std.testing.expectEqual(@as(usize, 4), @typeInfo(ScopeKind).@"enum".fields.len);
}