import {
  createAssistantMessageEventStream,
  type AssistantMessage,
  type Model,
} from "openclaw/plugin-sdk/llm";
import { afterEach, beforeEach, vi } from "vitest";
import { createResourceLoader } from "./agent-session-loop-resource-loader.test-support.js";
import { AgentSession } from "./agent-session.js";
import { AuthStorage } from "./auth-storage.js";
import type { ToolDefinition } from "./extensions/types.js";
import { ModelRegistry } from "./model-registry.js";
import type { ResourceLoader } from "./resource-loader.js";
import { createAgentSession, createAgentSessionForEmbeddedRunner } from "./sdk.js";
import { SessionManager } from "./session-manager.js";
import { SettingsManager } from "./settings-manager.js";

const hoistedStreamMocks = vi.hoisted(() => ({
  streamSimple: vi.fn(),
}));

export const streamMocks = hoistedStreamMocks;

export const testModel: Model = {
  id: "test-model",
  name: "Test Model",
  api: "openai-responses",
  provider: "test-provider",
  baseUrl: "https://example.test",
  reasoning: false,
  input: ["text"],
  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
  contextWindow: 32_768,
  maxTokens: 8_192,
};

const sessions: AgentSession[] = [];

function createUsage(contextTokens: number) {
  return {
    input: contextTokens,
    output: 1,
    cacheRead: 0,
    cacheWrite: 0,
    totalTokens: contextTokens + 1,
    contextUsage: {
      state: "available" as const,
      promptTokens: contextTokens,
      totalTokens: contextTokens + 1,
    },
    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
  };
}

export function createAssistant(
  activeModel: Model,
  content: AssistantMessage["content"],
  stopReason: AssistantMessage["stopReason"] = "stop",
  contextTokens = 1,
): AssistantMessage {
  return {
    role: "assistant",
    content,
    api: activeModel.api,
    provider: activeModel.provider,
    model: activeModel.id,
    usage: createUsage(contextTokens),
    stopReason,
    timestamp: Date.now(),
  };
}

export function createAssistantResultStream(message: AssistantMessage) {
  const stream = createAssistantMessageEventStream();
  queueMicrotask(() => {
    if (message.stopReason === "error" || message.stopReason === "aborted") {
      stream.push({ type: "error", reason: message.stopReason, error: message });
    } else {
      stream.push({ type: "done", reason: message.stopReason, message });
    }
    stream.end();
  });
  return stream;
}

export function createOverflowAssistant(activeModel: Model) {
  const contextWindow = activeModel.contextWindow;
  if (typeof contextWindow !== "number" || !Number.isFinite(contextWindow) || contextWindow <= 0) {
    throw new Error("Overflow fixture requires a finite positive model context window");
  }
  return {
    ...createAssistant(
      activeModel,
      [{ type: "text", text: "truncated answer" }],
      "length",
      contextWindow,
    ),
    usage: { ...createUsage(contextWindow), output: 0 },
  };
}

export const createAutoCompactionSettings = () =>
  SettingsManager.inMemory({
    compaction: { enabled: true, reserveTokens: 0, keepRecentTokens: 1 },
    retry: { enabled: false },
  });

export function mockInvalidThenTextSummary(recoveredText: string) {
  let requests = 0;
  streamMocks.streamSimple.mockImplementation((activeModel: Model) => {
    return createAssistantResultStream(
      createAssistant(
        activeModel,
        ++requests === 1
          ? [{ type: "thinking", thinking: "internal summary reasoning" }]
          : [{ type: "text", text: recoveredText }],
      ),
    );
  });
  return () => requests;
}

export async function createTestSession(
  options: {
    model?: Model;
    settingsManager?: SettingsManager;
    sessionManager?: SessionManager;
    resourceLoader?: ResourceLoader;
    customTools?: ToolDefinition[];
    contextOverflowRecoveryOwner?: "session" | "caller";
    withSessionWriteSettlement?: NonNullable<
      Parameters<typeof createAgentSession>[0]
    >["withSessionWriteSettlement"];
  } = {},
) {
  const model = options.model ?? testModel;
  const authStorage = AuthStorage.inMemory();
  authStorage.setRuntimeApiKey(model.provider, "test-api-key");
  const settingsManager =
    options.settingsManager ??
    SettingsManager.inMemory({
      compaction: { enabled: false },
      retry: { enabled: false },
    });
  const sessionManager = options.sessionManager ?? SessionManager.inMemory();
  const modelRegistry = ModelRegistry.inMemory(authStorage);
  modelRegistry.registerProvider(model.provider, {
    api: model.api,
    streamSimple: streamMocks.streamSimple,
  });
  const sessionOptions = {
    model,
    authStorage,
    noTools: "builtin" as const,
    customTools: options.customTools,
    resourceLoader: options.resourceLoader ?? createResourceLoader(),
    sessionManager,
    settingsManager,
    modelRegistry,
    withSessionWriteSettlement: options.withSessionWriteSettlement,
  };
  const result = options.contextOverflowRecoveryOwner
    ? await createAgentSessionForEmbeddedRunner(sessionOptions, {
        contextOverflowRecoveryOwner: options.contextOverflowRecoveryOwner,
      })
    : await createAgentSession(sessionOptions);
  sessions.push(result.session);
  return { ...result, modelRegistry, settingsManager, sessionManager };
}

export function appendHistory(sessionManager: SessionManager, assistant: AssistantMessage): void {
  sessionManager.appendMessage({ role: "user", content: "old prompt", timestamp: Date.now() - 2 });
  sessionManager.appendMessage({ ...assistant, timestamp: Date.now() - 1 });
}

export function registerAgentSessionLoopTestLifecycle(): void {
  beforeEach(() => {
    streamMocks.streamSimple.mockReset();
  });

  afterEach(() => {
    for (const session of sessions.splice(0)) {
      session.dispose();
    }
  });
}