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

const Allocator = std.mem.Allocator;

/// Opaque provider-owned identity borrowed for the policy and runtime lifetime.
pub const SearchBackendId = struct {
    value: []const u8,

    pub fn eql(self: SearchBackendId, other: SearchBackendId) bool {
        return std.mem.eql(u8, self.value, other.value);
    }
};

pub const BackendFeatureMode = enum {
    unsupported,
    best_effort,
    pass_through,
    post_filter,
};

pub const BackendCapabilities = struct {
    max_uses: BackendFeatureMode = .unsupported,
    allowed_domains: BackendFeatureMode = .unsupported,
    blocked_domains: BackendFeatureMode = .unsupported,
    ordered_sources: bool = false,
    usage: bool = false,
    terminal_incomplete: bool = false,
    timeout: bool = false,
    cancellation: bool = false,
    result_bounds: BackendFeatureMode = .unsupported,
};

pub const Request = struct {
    query: []const u8,
    allowed_domains: ?[]const []const u8 = null,
    blocked_domains: ?[]const []const u8 = null,
};

pub const ProviderRequest = struct {
    backend: SearchBackendId,
    query: []const u8,
    allowed_domains: ?[]const []const u8 = null,
    blocked_domains: ?[]const []const u8 = null,
    max_uses: u8 = 8,
    max_results: u8 = 10,
    max_output_tokens: u32 = 4096,
    max_output_chars: usize = 100_000,
    timeout_ms: u32 = 30_000,
    cancel_flag: *const std.atomic.Value(bool),
};

pub const Progress = union(enum) {
    query_update: []const u8,
    results_received: struct {
        query: []const u8,
        result_count: usize,
    },
};

pub const ProgressFn = *const fn (*anyopaque, Progress) void;

pub const Source = struct {
    title: []const u8,
    url: []const u8,

    pub fn deinit(self: Source, alloc: Allocator) void {
        alloc.free(self.title);
        alloc.free(self.url);
    }
};

pub const SearchBlock = struct {
    tool_use_id: []const u8,
    content: []const Source,

    pub fn deinit(self: SearchBlock, alloc: Allocator) void {
        alloc.free(self.tool_use_id);
        for (self.content) |source| source.deinit(alloc);
        alloc.free(self.content);
    }
};

pub const TerminalIncomplete = struct {
    stop_reason: []const u8,
    message: []const u8,

    pub fn deinit(self: TerminalIncomplete, alloc: Allocator) void {
        alloc.free(self.stop_reason);
        alloc.free(self.message);
    }
};

pub const ResultItem = union(enum) {
    commentary: []const u8,
    search: SearchBlock,
    error_text: []const u8,
    terminal_incomplete: TerminalIncomplete,

    pub fn deinit(self: ResultItem, alloc: Allocator) void {
        switch (self) {
            .commentary => |text| alloc.free(text),
            .search => |search| search.deinit(alloc),
            .error_text => |text| alloc.free(text),
            .terminal_incomplete => |incomplete| incomplete.deinit(alloc),
        }
    }
};

/// Provider output whose content and stop reason are owned by the caller.
pub const ProviderResponse = struct {
    content: []const ResultItem = &.{},
    stop_reason: ?[]const u8 = null,
    usage: ?types.ToolUsage = null,

    pub fn takeContent(self: *ProviderResponse) []const ResultItem {
        const content = self.content;
        self.content = &.{};
        return content;
    }

    pub fn deinit(self: *ProviderResponse, alloc: Allocator) void {
        deinitItems(alloc, self.content);
        if (self.stop_reason) |reason| alloc.free(reason);
        self.* = .{};
    }
};

/// Search output with a borrowed query and owned result allocations. The
/// caller must call `deinit` with the allocator that received the output.
pub const Output = struct {
    query: []const u8,
    results: []const ResultItem,
    incomplete: bool = false,
    duration_ms: u64,
    web_search_requests: u32,

    pub fn deinit(self: *Output, alloc: Allocator) void {
        deinitItems(alloc, self.results);
        self.results = &.{};
    }
};

/// Executor output whose result allocations are owned by the caller.
pub const ExecutionOutput = struct {
    output: Output,
    inner_usage: ?types.ToolUsage = null,

    pub fn deinit(self: *ExecutionOutput, alloc: Allocator) void {
        self.output.deinit(alloc);
        self.* = undefined;
    }
};

fn deinitItems(alloc: Allocator, items: []const ResultItem) void {
    for (items) |item| item.deinit(alloc);
    if (items.len > 0) alloc.free(items);
}

test "backend identity compares provider-owned values" {
    const copied = [_]u8{ 'p', 'r', 'o', 'v', 'i', 'd', 'e', 'r', '.', 'o', 'n', 'e' };
    const expected = SearchBackendId{ .value = "provider.one" };

    try std.testing.expect(expected.eql(.{ .value = &copied }));
    try std.testing.expect(!expected.eql(.{ .value = "provider.two" }));
}

test "provider response transfers ordered results to output" {
    const content = [_]ResultItem{
        .{ .commentary = "researching" },
        .{ .error_text = "bounded failure" },
    };
    var response = ProviderResponse{
        .content = &content,
    };
    const output = Output{
        .query = "zig",
        .results = response.takeContent(),
        .duration_ms = 1,
        .web_search_requests = 0,
    };

    try std.testing.expectEqual(@as(usize, 0), response.content.len);
    try std.testing.expectEqualStrings("researching", output.results[0].commentary);
    try std.testing.expectEqualStrings("bounded failure", output.results[1].error_text);
}