const std = @import("std");

const config_mod = @import("config.zig");
const conversation = @import("conversation.zig");
const tool_registry_mod = @import("tool_registry.zig");
pub const ToolRegistry = tool_registry_mod.ToolRegistry;

pub const ContentBlockType = enum {
    Text,
    Thinking,
    ToolUse,
    ToolResult,
};

/// Vtable for receiving streaming events from a Provider.
///
/// The lifecycle callbacks (`onMessageStart` ... `onMessageComplete`) return
/// `anyerror!void`. Returning an error aborts the in-flight turn: the Provider
/// stops streaming, calls `onError(err)`, and propagates `err` out of
/// `streamStep`. No partial assistant message is appended to the conversation.
///
/// Tool-use identity (`id`, `name`) is delivered via `onToolDetails`, fired
/// once per ToolUse block at the earliest moment both fields are known. For
/// Anthropic this is immediately after `onBlockStart`, before any deltas. For
/// OpenAI Chat Completions this may be partway through the arg-deltas, since
/// the wire protocol can split `id` and `name` across multiple streaming
/// chunks. The only guarantees are: it fires strictly after the block's
/// `onBlockStart`, strictly before its `onBlockComplete`, and at most once
/// per ToolUse block. It never fires for non-ToolUse blocks. If a tool_use
/// block is dropped because identity never fully arrived, `onToolDetails`
/// (and `onBlockComplete`) never fire for it.
///
/// `onError` is the receiver's cleanup hook. It fires exactly once per failed
/// turn, whether the error originated in the receiver itself (a write failure)
/// or in the Provider (HTTP/parse/stream failure). It is the last callback the
/// receiver will see for that turn. `onError` itself cannot fail; receivers
/// must swallow secondary failures during cleanup.
pub const ReceiverVTable = struct {
    onMessageStart: *const fn (*anyopaque, conversation.MessageRole) anyerror!void,
    onBlockStart: *const fn (*anyopaque, ContentBlockType, usize) anyerror!void,
    onToolDetails: *const fn (*anyopaque, usize, []const u8, []const u8) anyerror!void,
    onContentDelta: *const fn (*anyopaque, usize, []const u8) anyerror!void,
    onBlockComplete: *const fn (*anyopaque, usize, conversation.ContentBlock) anyerror!void,
    onMessageComplete: *const fn (*anyopaque, conversation.Message) anyerror!void,
    onError: *const fn (*anyopaque, anyerror) void,
};

pub const Receiver = struct {
    ptr: *anyopaque,
    vtable: *const ReceiverVTable,

    pub fn onMessageStart(self: Receiver, role: conversation.MessageRole) !void {
        try self.vtable.onMessageStart(self.ptr, role);
    }

    pub fn onBlockStart(self: Receiver, block_type: ContentBlockType, index: usize) !void {
        try self.vtable.onBlockStart(self.ptr, block_type, index);
    }

    pub fn onToolDetails(self: Receiver, block_index: usize, id: []const u8, name: []const u8) !void {
        try self.vtable.onToolDetails(self.ptr, block_index, id, name);
    }

    pub fn onContentDelta(self: Receiver, block_index: usize, delta: []const u8) !void {
        try self.vtable.onContentDelta(self.ptr, block_index, delta);
    }

    pub fn onBlockComplete(self: Receiver, block_index: usize, block: conversation.ContentBlock) !void {
        try self.vtable.onBlockComplete(self.ptr, block_index, block);
    }

    pub fn onMessageComplete(self: Receiver, message: conversation.Message) !void {
        try self.vtable.onMessageComplete(self.ptr, message);
    }

    pub fn onError(self: Receiver, err: anyerror) void {
        self.vtable.onError(self.ptr, err);
    }
};

pub const ProviderVTable = struct {
    streamStep: *const fn (
        *anyopaque,
        *conversation.Conversation,
        *const ToolRegistry,
        *Receiver,
    ) anyerror!void,
    deinit: *const fn (*anyopaque) void,
};

pub const Provider = struct {
    ptr: *anyopaque,
    vtable: *const ProviderVTable,

    /// Construct the concrete provider implementation that matches `cfg`'s
    /// API style, heap-allocate it, and return a `Provider` interface bound
    /// to it. `deinit` tears down the impl and frees the allocation.
    ///
    /// The concrete provider types (`OpenAIChatProvider`, etc.) are
    /// implementation details; callers interact only with this interface.
    pub fn init(
        allocator: std.mem.Allocator,
        io: std.Io,
        cfg: config_mod.Config,
    ) !Provider {
        // Imported lazily to break the circular module graph:
        // provider.zig <- provider_openai_chat.zig <- provider.zig.
        const provider_openai_chat = @import("provider_openai_chat.zig");
        const provider_anthropic_messages = @import("provider_anthropic_messages.zig");
        switch (cfg) {
            .openai_chat => |c| {
                const impl = try allocator.create(provider_openai_chat.OpenAIChatProvider);
                impl.* = provider_openai_chat.OpenAIChatProvider.init(allocator, io, c);
                return impl.provider();
            },
            .anthropic_messages => |c| {
                const impl = try allocator.create(provider_anthropic_messages.AnthropicMessagesProvider);
                impl.* = provider_anthropic_messages.AnthropicMessagesProvider.init(allocator, io, c);
                return impl.provider();
            },
        }
    }

    pub fn streamStep(
        self: Provider,
        conv: *conversation.Conversation,
        tools: *const ToolRegistry,
        receiver: *Receiver,
    ) anyerror!void {
        return self.vtable.streamStep(self.ptr, conv, tools, receiver);
    }

    pub fn deinit(self: Provider) void {
        self.vtable.deinit(self.ptr);
    }
};