/**
 * Tests for engineHooks — env provider and prompt enhancer registries
 */

import { describe, it, expect, beforeEach, vi } from "vitest";

vi.mock("electron-log", () => ({
  default: {
    info: vi.fn(),
    warn: vi.fn(),
    error: vi.fn(),
  },
}));

// engineHooks uses module-level arrays, so we need to re-import for isolation
// Since we can't easily reset module state, we test behavior additively

import {
  registerEnvProvider,
  collectEnvFromProviders,
  registerPromptEnhancer,
  enhanceSystemPrompt,
} from "./engineHooks";

describe("engineHooks", () => {
  // Note: providers accumulate across tests within this module since they're module-level singletons.
  // Tests are designed to be additive and order-independent where possible.

  describe("env providers", () => {
    it("collectEnvFromProviders returns empty object when no providers return env", () => {
      // Register a provider that returns undefined
      registerEnvProvider(() => undefined);
      // collectEnvFromProviders should still return an object (may have env from prior tests)
      const result = collectEnvFromProviders();
      expect(typeof result).toBe("object");
    });

    it("collects env vars from providers", () => {
      registerEnvProvider(() => ({ TEST_KEY: "test_value" }));
      const result = collectEnvFromProviders();
      expect(result.TEST_KEY).toBe("test_value");
    });

    it("merges env from multiple providers", () => {
      registerEnvProvider(() => ({ KEY_A: "a" }));
      registerEnvProvider(() => ({ KEY_B: "b" }));
      const result = collectEnvFromProviders();
      expect(result.KEY_A).toBe("a");
      expect(result.KEY_B).toBe("b");
    });

    it("later providers override earlier ones for same key", () => {
      registerEnvProvider(() => ({ OVERRIDE_KEY: "first" }));
      registerEnvProvider(() => ({ OVERRIDE_KEY: "second" }));
      const result = collectEnvFromProviders();
      expect(result.OVERRIDE_KEY).toBe("second");
    });

    it("handles provider errors gracefully", () => {
      registerEnvProvider(() => {
        throw new Error("provider error");
      });
      // Should not throw, just skip the erroring provider
      const result = collectEnvFromProviders();
      expect(typeof result).toBe("object");
    });

    it("skips providers that return undefined", () => {
      registerEnvProvider(() => undefined);
      registerEnvProvider(() => ({ VALID_KEY: "valid" }));
      const result = collectEnvFromProviders();
      expect(result.VALID_KEY).toBe("valid");
    });
  });

  describe("prompt enhancers", () => {
    it("returns base prompt when no enhancers modify it", () => {
      registerPromptEnhancer((base) => base);
      const result = enhanceSystemPrompt("hello");
      expect(result).toBe("hello");
    });

    it("returns undefined for undefined base with pass-through enhancer", () => {
      registerPromptEnhancer((base) => base);
      // The enhancer just passes through, so undefined stays undefined
      // (but previous enhancers from other tests may have been registered)
      // We test the function contract directly
      const result = enhanceSystemPrompt(undefined);
      // Could be undefined or enhanced — depends on previously registered enhancers
      expect(result === undefined || typeof result === "string").toBe(true);
    });

    it("enhancer can append to base prompt", () => {
      registerPromptEnhancer((base) =>
        base ? `${base}\n\nAPPENDED` : "APPENDED",
      );
      const result = enhanceSystemPrompt("original");
      expect(result).toContain("original");
      expect(result).toContain("APPENDED");
    });

    it("chains multiple enhancers in order", () => {
      registerPromptEnhancer((base) => `${base || ""}-A`);
      registerPromptEnhancer((base) => `${base || ""}-B`);
      const result = enhanceSystemPrompt("start");
      // Both A and B should be present, and B appended after A
      expect(result).toContain("-A");
      expect(result).toContain("-B");
    });

    it("handles enhancer errors gracefully", () => {
      registerPromptEnhancer(() => {
        throw new Error("enhancer error");
      });
      // Should not throw
      const result = enhanceSystemPrompt("test");
      expect(typeof result === "string" || result === undefined).toBe(true);
    });
  });
});