import { describe, it, expect, vi } from "vitest";
import { resolveModel, buildResourceLoader } from "../runner.js";

// ---------------------------------------------------------------------------
// resolveModel
// ---------------------------------------------------------------------------

describe("resolveModel", () => {
    const mockModel = { id: "claude-sonnet-4-5", provider: "anthropic" };

    const makeRegistry = (found: any = undefined, hasAuth = true) => ({
        find: vi.fn().mockReturnValue(found),
        hasConfiguredAuth: vi.fn().mockReturnValue(hasAuth),
    });

    it("returns error string for malformed name (no slash)", () => {
        const registry = makeRegistry();
        const result = resolveModel(registry as any, "claude-sonnet-4-5");
        expect(result).toBe('malformed model "claude-sonnet-4-5", expected <provider>/<id>');
    });

    it("resolves well-formed provider/id via registry", () => {
        const registry = makeRegistry(mockModel);
        const result = resolveModel(registry as any, "anthropic/claude-sonnet-4-5");
        expect(registry.find).toHaveBeenCalledWith("anthropic", "claude-sonnet-4-5");
        expect(result).toBe(mockModel);
    });

    it("returns error string for unknown model", () => {
        const registry = makeRegistry(undefined);
        const result = resolveModel(registry as any, "unknown/model-x");
        expect(result).toBe('model "unknown/model-x" not found');
    });

    it("returns error string when no auth is configured", () => {
        const registry = makeRegistry(mockModel, false);
        const result = resolveModel(registry as any, "anthropic/claude-sonnet-4-5");
        expect(result).toBe('no auth configured for provider "anthropic"');
    });

    it("returns model when auth is configured", () => {
        const registry = makeRegistry(mockModel, true);
        const result = resolveModel(registry as any, "anthropic/claude-sonnet-4-5");
        expect(result).toBe(mockModel);
    });
});

// ---------------------------------------------------------------------------
// buildResourceLoader
// ---------------------------------------------------------------------------

describe("buildResourceLoader", () => {
    const baseAgent = {
        name: "test-agent",
        description: "test",
        systemPrompt: "You are a helper.",
        source: "user" as const,
        filePath: "/agents/test.md",
    };

    it("always sets noExtensions=true even when extensions are listed", () => {
        // Without extensions
        const loader1 = buildResourceLoader(baseAgent, "/tmp");
        expect(loader1).toBeDefined();

        // With extensions — noExtensions should still be true
        const loader2 = buildResourceLoader(
            { ...baseAgent, extensions: ["./ext-a"] },
            "/tmp",
        );
        expect(loader2).toBeDefined();
    });

    it("sets noSkills=true when no skills", () => {
        const loader = buildResourceLoader(baseAgent, "/tmp");
        expect(loader).toBeDefined();
    });

    it("sets appendSystemPrompt when systemPrompt is non-empty", () => {
        const loader = buildResourceLoader(baseAgent, "/tmp");
        expect(loader).toBeDefined();
    });

    it("does not set appendSystemPrompt when systemPrompt is empty", () => {
        const agent = { ...baseAgent, systemPrompt: "" };
        const loader = buildResourceLoader(agent, "/tmp");
        expect(loader).toBeDefined();
    });

    it("passes extensions as additionalExtensionPaths", () => {
        const agent = { ...baseAgent, extensions: ["./ext-a", "./ext-b"] };
        const loader = buildResourceLoader(agent, "/tmp");
        expect(loader).toBeDefined();
    });

    it("filters skills by name", () => {
        const agent = { ...baseAgent, skills: ["grep", "find"] };
        const loader = buildResourceLoader(agent, "/tmp");
        expect(loader).toBeDefined();
    });

    it("handles both extensions and skills", () => {
        const agent = {
            ...baseAgent,
            extensions: ["./ext-a"],
            skills: ["grep"],
        };
        const loader = buildResourceLoader(agent, "/tmp");
        expect(loader).toBeDefined();
    });
});