import {
	type EmbeddingProvider,
	InMemoryProjectStore,
	InMemoryStore,
	type Memory,
	type SearchResult,
} from "@imemio/sdk";
import { beforeEach, describe, expect, it, vi } from "vitest";

function createMockEmbeddingProvider(): EmbeddingProvider {
	return {
		generate: vi.fn().mockResolvedValue(new Array(1536).fill(0.1)),
		generateBatch: vi
			.fn()
			.mockResolvedValue([
				new Array(1536).fill(0.1),
				new Array(1536).fill(0.2),
			]),
		dimensions: 1536,
	};
}

describe("MCP Server Tool Handlers", () => {
	let memoryStore: InMemoryStore;
	let projectStore: InMemoryProjectStore;

	beforeEach(() => {
		memoryStore = new InMemoryStore();
		projectStore = new InMemoryProjectStore();
	});
	describe("create_memory", () => {
		it("creates a memory and returns it", async () => {
			const createdMemory = await memoryStore.create({
				content: "Test memory content",
				projectId: "project-123",
			});

			expect(createdMemory.id).toBeDefined();
			expect(createdMemory.content).toBe("Test memory content");
			expect(createdMemory.projectId).toBe("project-123");
		});
		it("creates a memory with optional fields", async () => {
			const tags = [{ id: "tag-1", name: "important" }];
			const metadata = { source: "test" };
			const createdMemory = await memoryStore.create({
				content: "Test memory content",
				projectId: "project-123",
				folderId: "folder-123",
				tags,
				metadata,
			});

			expect(createdMemory.folderId).toBe("folder-123");
			expect(createdMemory.tags).toEqual(tags);
			expect(createdMemory.metadata).toEqual(metadata);
		});
	});
	describe("get_memory", () => {
		it("returns a memory when it exists", async () => {
			const createdMemory = await memoryStore.create({
				content: "Test memory content",
				projectId: "project-123",
			});
			const readResult = await memoryStore.read(createdMemory.id);

			expect(readResult.success).toBe(true);

			if (readResult.success) {
				expect(readResult.value.content).toBe("Test memory content");
			}
		});
		it("returns failure when memory does not exist", async () => {
			const readResult = await memoryStore.read("non-existent-id");

			expect(readResult.success).toBe(false);

			if (!readResult.success) {
				expect(readResult.error.type).toBe("MEMORY_NOT_FOUND");
				expect(readResult.error.memoryId).toBe("non-existent-id");
			}
		});
	});
	describe("update_memory", () => {
		it("updates a memory when it exists", async () => {
			const createdMemory = await memoryStore.create({
				content: "Original content",
				projectId: "project-123",
			});
			const updateResult = await memoryStore.update(createdMemory.id, {
				content: "Updated content",
			});

			expect(updateResult.success).toBe(true);

			if (updateResult.success) {
				expect(updateResult.value.content).toBe("Updated content");
			}
		});
		it("returns failure when memory does not exist", async () => {
			const updateResult = await memoryStore.update("non-existent-id", {
				content: "Updated content",
			});

			expect(updateResult.success).toBe(false);

			if (!updateResult.success) {
				expect(updateResult.error.type).toBe("MEMORY_NOT_FOUND");
			}
		});
		it("allows setting folderId to null", async () => {
			const createdMemory = await memoryStore.create({
				content: "Test content",
				projectId: "project-123",
				folderId: "folder-123",
			});
			const updateResult = await memoryStore.update(createdMemory.id, {
				folderId: null,
			});

			expect(updateResult.success).toBe(true);

			if (updateResult.success) {
				expect(updateResult.value.folderId).toBeNull();
			}
		});
	});
	describe("delete_memory", () => {
		it("deletes a memory when it exists", async () => {
			const createdMemory = await memoryStore.create({
				content: "Test content",
				projectId: "project-123",
			});
			const deleteResult = await memoryStore.delete(createdMemory.id);

			expect(deleteResult.success).toBe(true);

			const readResult = await memoryStore.read(createdMemory.id);

			expect(readResult.success).toBe(false);
		});
		it("returns failure when memory does not exist", async () => {
			const deleteResult = await memoryStore.delete("non-existent-id");

			expect(deleteResult.success).toBe(false);

			if (!deleteResult.success) {
				expect(deleteResult.error.type).toBe("MEMORY_NOT_FOUND");
			}
		});
	});
	describe("list_memories", () => {
		it("returns empty array when no memories exist", async () => {
			const memories = await memoryStore.list();

			expect(memories).toEqual([]);
		});
		it("returns all memories when no filter is provided", async () => {
			await memoryStore.create({
				content: "Memory 1",
				projectId: "project-1",
			});
			await memoryStore.create({
				content: "Memory 2",
				projectId: "project-2",
			});

			const memories = await memoryStore.list();

			expect(memories).toHaveLength(2);
		});
		it("filters memories by projectId", async () => {
			await memoryStore.create({
				content: "Memory 1",
				projectId: "project-1",
			});
			await memoryStore.create({
				content: "Memory 2",
				projectId: "project-2",
			});

			const memories = await memoryStore.list({ projectId: "project-1" });

			expect(memories).toHaveLength(1);
			expect(memories[0].content).toBe("Memory 1");
		});
		it("filters memories by folderId", async () => {
			await memoryStore.create({
				content: "Memory 1",
				projectId: "project-1",
				folderId: "folder-1",
			});
			await memoryStore.create({
				content: "Memory 2",
				projectId: "project-1",
				folderId: "folder-2",
			});

			const memories = await memoryStore.list({ folderId: "folder-1" });

			expect(memories).toHaveLength(1);
			expect(memories[0].content).toBe("Memory 1");
		});
		it("filters memories by tags", async () => {
			await memoryStore.create({
				content: "Memory 1",
				projectId: "project-1",
				tags: [
					{ id: "tag-1", name: "important" },
					{ id: "tag-2", name: "work" },
				],
			});
			await memoryStore.create({
				content: "Memory 2",
				projectId: "project-1",
				tags: [{ id: "tag-1", name: "important" }],
			});

			const memories = await memoryStore.list({ tags: ["tag-1", "tag-2"] });

			expect(memories).toHaveLength(1);
			expect(memories[0].content).toBe("Memory 1");
		});
	});
	describe("create_project", () => {
		it("creates a project and returns it", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			expect(createResult.success).toBe(true);

			if (createResult.success) {
				expect(createResult.value.name).toBe("Test Project");
				expect(createResult.value.isGlobal).toBe(false);
			}
		});
		it("creates a project with optional fields", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
				description: "A test project",
				isGlobal: true,
			});

			expect(createResult.success).toBe(true);

			if (createResult.success) {
				expect(createResult.value.description).toBe("A test project");
				expect(createResult.value.isGlobal).toBe(true);
			}
		});
	});
	describe("get_project", () => {
		it("returns a project when it exists", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const getResult = await projectStore.get(createResult.value.id);

			expect(getResult.success).toBe(true);

			if (getResult.success) {
				expect(getResult.value.name).toBe("Test Project");
			}
		});
		it("returns failure when project does not exist", async () => {
			const getResult = await projectStore.get("non-existent-id");

			expect(getResult.success).toBe(false);

			if (!getResult.success) {
				expect(getResult.error.type).toBe("PROJECT_NOT_FOUND");
				expect(getResult.error.projectId).toBe("non-existent-id");
			}
		});
	});
	describe("update_project", () => {
		it("updates a project when it exists", async () => {
			const createResult = await projectStore.create({
				name: "Original Name",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const updateResult = await projectStore.update(createResult.value.id, {
				name: "Updated Name",
			});

			expect(updateResult.success).toBe(true);

			if (updateResult.success) {
				expect(updateResult.value.name).toBe("Updated Name");
			}
		});
		it("returns failure when project does not exist", async () => {
			const updateResult = await projectStore.update("non-existent-id", {
				name: "Updated Name",
			});

			expect(updateResult.success).toBe(false);

			if (!updateResult.success) {
				expect(updateResult.error.type).toBe("PROJECT_NOT_FOUND");
			}
		});
		it("allows setting description to null", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
				description: "Original description",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const updateResult = await projectStore.update(createResult.value.id, {
				description: null,
			});

			expect(updateResult.success).toBe(true);

			if (updateResult.success) {
				expect(updateResult.value.description).toBeNull();
			}
		});
	});
	describe("delete_project", () => {
		it("deletes a project when it exists", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const deleteResult = await projectStore.delete(createResult.value.id);

			expect(deleteResult.success).toBe(true);

			const getResult = await projectStore.get(createResult.value.id);

			expect(getResult.success).toBe(false);
		});
		it("returns failure when project does not exist", async () => {
			const deleteResult = await projectStore.delete("non-existent-id");

			expect(deleteResult.success).toBe(false);

			if (!deleteResult.success) {
				expect(deleteResult.error.type).toBe("PROJECT_NOT_FOUND");
			}
		});
	});
	describe("list_projects", () => {
		it("returns empty array when no projects exist", async () => {
			const listResult = await projectStore.list();

			expect(listResult.success).toBe(true);

			if (listResult.success) {
				expect(listResult.value).toEqual([]);
			}
		});
		it("returns all projects", async () => {
			await projectStore.create({ name: "Project 1" });
			await projectStore.create({ name: "Project 2" });

			const listResult = await projectStore.list();

			expect(listResult.success).toBe(true);

			if (listResult.success) {
				expect(listResult.value).toHaveLength(2);
			}
		});
	});
	describe("add_folder", () => {
		it("adds a folder to a project", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const addFolderResult = await projectStore.addFolder(
				createResult.value.id,
				{
					name: "Test Folder",
				},
			);

			expect(addFolderResult.success).toBe(true);

			if (addFolderResult.success) {
				expect(addFolderResult.value.name).toBe("Test Folder");
				expect(addFolderResult.value.projectId).toBe(createResult.value.id);
			}
		});
		it("adds a folder with description", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const addFolderResult = await projectStore.addFolder(
				createResult.value.id,
				{
					name: "Test Folder",
					description: "A test folder",
				},
			);

			expect(addFolderResult.success).toBe(true);

			if (addFolderResult.success) {
				expect(addFolderResult.value.description).toBe("A test folder");
			}
		});
		it("returns failure when project does not exist", async () => {
			const addFolderResult = await projectStore.addFolder("non-existent-id", {
				name: "Test Folder",
			});

			expect(addFolderResult.success).toBe(false);

			if (!addFolderResult.success) {
				expect(addFolderResult.error.type).toBe("PROJECT_NOT_FOUND");
			}
		});
	});
	describe("update_folder", () => {
		it("updates a folder when it exists", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const addFolderResult = await projectStore.addFolder(
				createResult.value.id,
				{
					name: "Original Name",
				},
			);

			if (!addFolderResult.success) {
				throw new Error("Failed to add folder");
			}

			const updateFolderResult = await projectStore.updateFolder(
				createResult.value.id,
				addFolderResult.value.id,
				{
					name: "Updated Name",
				},
			);

			expect(updateFolderResult.success).toBe(true);

			if (updateFolderResult.success) {
				expect(updateFolderResult.value.name).toBe("Updated Name");
			}
		});
		it("returns failure when project does not exist", async () => {
			const updateFolderResult = await projectStore.updateFolder(
				"non-existent-project",
				"folder-id",
				{
					name: "Updated Name",
				},
			);

			expect(updateFolderResult.success).toBe(false);

			if (!updateFolderResult.success) {
				expect(updateFolderResult.error.type).toBe("PROJECT_NOT_FOUND");
			}
		});
		it("returns failure when folder does not exist", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const updateFolderResult = await projectStore.updateFolder(
				createResult.value.id,
				"non-existent-folder",
				{
					name: "Updated Name",
				},
			);

			expect(updateFolderResult.success).toBe(false);

			if (!updateFolderResult.success) {
				expect(updateFolderResult.error.type).toBe("FOLDER_NOT_FOUND");
			}
		});
		it("allows setting description to null", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const addFolderResult = await projectStore.addFolder(
				createResult.value.id,
				{
					name: "Test Folder",
					description: "Original description",
				},
			);

			if (!addFolderResult.success) {
				throw new Error("Failed to add folder");
			}

			const updateFolderResult = await projectStore.updateFolder(
				createResult.value.id,
				addFolderResult.value.id,
				{
					description: null,
				},
			);

			expect(updateFolderResult.success).toBe(true);

			if (updateFolderResult.success) {
				expect(updateFolderResult.value.description).toBeNull();
			}
		});
	});
	describe("remove_folder", () => {
		it("removes a folder when it exists", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const addFolderResult = await projectStore.addFolder(
				createResult.value.id,
				{
					name: "Test Folder",
				},
			);

			if (!addFolderResult.success) {
				throw new Error("Failed to add folder");
			}

			const removeFolderResult = await projectStore.removeFolder(
				createResult.value.id,
				addFolderResult.value.id,
			);

			expect(removeFolderResult.success).toBe(true);

			const listFoldersResult = await projectStore.listFolders(
				createResult.value.id,
			);

			if (listFoldersResult.success) {
				expect(listFoldersResult.value).toHaveLength(0);
			}
		});
		it("returns failure when project does not exist", async () => {
			const removeFolderResult = await projectStore.removeFolder(
				"non-existent-project",
				"folder-id",
			);

			expect(removeFolderResult.success).toBe(false);

			if (!removeFolderResult.success) {
				expect(removeFolderResult.error.type).toBe("PROJECT_NOT_FOUND");
			}
		});
		it("returns failure when folder does not exist", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const removeFolderResult = await projectStore.removeFolder(
				createResult.value.id,
				"non-existent-folder",
			);

			expect(removeFolderResult.success).toBe(false);

			if (!removeFolderResult.success) {
				expect(removeFolderResult.error.type).toBe("FOLDER_NOT_FOUND");
			}
		});
	});
	describe("list_folders", () => {
		it("returns empty array when no folders exist", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			const listFoldersResult = await projectStore.listFolders(
				createResult.value.id,
			);

			expect(listFoldersResult.success).toBe(true);

			if (listFoldersResult.success) {
				expect(listFoldersResult.value).toEqual([]);
			}
		});
		it("returns all folders in a project", async () => {
			const createResult = await projectStore.create({
				name: "Test Project",
			});

			if (!createResult.success) {
				throw new Error("Failed to create project");
			}

			await projectStore.addFolder(createResult.value.id, { name: "Folder 1" });
			await projectStore.addFolder(createResult.value.id, { name: "Folder 2" });

			const listFoldersResult = await projectStore.listFolders(
				createResult.value.id,
			);

			expect(listFoldersResult.success).toBe(true);

			if (listFoldersResult.success) {
				expect(listFoldersResult.value).toHaveLength(2);
			}
		});
		it("returns failure when project does not exist", async () => {
			const listFoldersResult =
				await projectStore.listFolders("non-existent-id");

			expect(listFoldersResult.success).toBe(false);

			if (!listFoldersResult.success) {
				expect(listFoldersResult.error.type).toBe("PROJECT_NOT_FOUND");
			}
		});
	});
	describe("Embedding Service Configuration", () => {
		it("returns null embedding provider when no configuration is set", () => {
			const nullEmbeddingProvider: EmbeddingProvider | null = null;

			expect(nullEmbeddingProvider).toBeNull();
		});
		it("creates embedding provider when OpenAI API key is available", () => {
			const mockEmbeddingProvider = createMockEmbeddingProvider();

			expect(mockEmbeddingProvider).toBeDefined();
			expect(mockEmbeddingProvider.dimensions).toBe(1536);
		});
		it("creates local embedding provider when configured", () => {
			const mockLocalEmbeddingProvider: EmbeddingProvider = {
				generate: vi.fn().mockResolvedValue(new Array(384).fill(0.1)),
				generateBatch: vi.fn().mockResolvedValue([new Array(384).fill(0.1)]),
				dimensions: 384,
			};

			expect(mockLocalEmbeddingProvider.dimensions).toBe(384);
		});
	});
	describe("generate_embedding", () => {
		it("generates embedding when service is configured", async () => {
			const mockEmbeddingProvider = createMockEmbeddingProvider();
			const embedding = await mockEmbeddingProvider.generate("test text");

			expect(embedding).toHaveLength(1536);
			expect(mockEmbeddingProvider.generate).toHaveBeenCalledWith("test text");
		});
		it("returns error when embedding service is not configured", () => {
			const nullEmbeddingProvider: EmbeddingProvider | null = null;

			if (!nullEmbeddingProvider) {
				const errorResponse = {
					content: [
						{
							type: "text" as const,
							text: "Embedding service not configured. Set OPENAI_API_KEY or IMEMIO_EMBEDDING_TYPE=local.",
						},
					],
					isError: true,
				};

				expect(errorResponse.isError).toBe(true);
				expect(errorResponse.content[0].text).toContain(
					"Embedding service not configured",
				);
			}
		});
	});
	describe("create_memory_with_embedding", () => {
		it("creates memory with auto-generated embedding when service is configured", async () => {
			const mockEmbeddingProvider = createMockEmbeddingProvider();
			const embedding = await mockEmbeddingProvider.generate("Test content");
			const createdMemory = await memoryStore.create({
				content: "Test content",
				projectId: "project-123",
				embedding,
			});

			expect(createdMemory.content).toBe("Test content");
			expect(mockEmbeddingProvider.generate).toHaveBeenCalledWith(
				"Test content",
			);
		});
		it("returns error when embedding service is not configured", () => {
			const nullEmbeddingProvider: EmbeddingProvider | null = null;

			if (!nullEmbeddingProvider) {
				const errorResponse = {
					content: [
						{
							type: "text" as const,
							text: "Embedding service not configured. Set OPENAI_API_KEY or IMEMIO_EMBEDDING_TYPE=local.",
						},
					],
					isError: true,
				};

				expect(errorResponse.isError).toBe(true);
				expect(errorResponse.content[0].text).toContain(
					"Embedding service not configured",
				);
			}
		});
		it("creates memory with all optional fields and embedding", async () => {
			const mockEmbeddingProvider = createMockEmbeddingProvider();
			const embedding = await mockEmbeddingProvider.generate("Test content");
			const tags = [{ id: "tag-1", name: "important" }];
			const metadata = { source: "test" };
			const createdMemory = await memoryStore.create({
				content: "Test content",
				projectId: "project-123",
				folderId: "folder-123",
				tags,
				metadata,
				embedding,
			});

			expect(createdMemory.folderId).toBe("folder-123");
			expect(createdMemory.tags).toEqual(tags);
			expect(createdMemory.metadata).toEqual(metadata);
		});
	});
	describe("MCP Tool Response Format", () => {
		it("returns text content with JSON stringified data", () => {
			const sampleMemory: Memory = {
				id: "memory-123",
				content: "Test content",
				projectId: "project-123",
				folderId: null,
				tags: [],
				metadata: {},
				createdAt: new Date("2024-01-01"),
				updatedAt: new Date("2024-01-01"),
			};
			const response = {
				content: [
					{
						type: "text" as const,
						text: JSON.stringify(sampleMemory, null, 2),
					},
				],
			};

			expect(response.content[0].type).toBe("text");

			const parsedData = JSON.parse(response.content[0].text);

			expect(parsedData.id).toBe("memory-123");
			expect(parsedData.content).toBe("Test content");
		});
		it("returns error response with isError flag", () => {
			const errorResponse = {
				content: [
					{
						type: "text" as const,
						text: "Memory not found: non-existent-id",
					},
				],
				isError: true,
			};

			expect(errorResponse.isError).toBe(true);
			expect(errorResponse.content[0].text).toContain("Memory not found");
		});
		it("returns success message for delete operations", () => {
			const deleteResponse = {
				content: [
					{
						type: "text" as const,
						text: "Memory deleted: memory-123",
					},
				],
			};

			expect(deleteResponse.content[0].text).toBe("Memory deleted: memory-123");
		});
	});
	describe("Search Results Format", () => {
		it("formats search results with similarity scores", () => {
			const searchResults: SearchResult[] = [
				{
					id: "memory-1",
					content: "First result",
					projectId: "project-123",
					folderId: null,
					tags: [],
					metadata: {},
					similarity: 0.95,
					createdAt: new Date("2024-01-01"),
					updatedAt: new Date("2024-01-01"),
				},
				{
					id: "memory-2",
					content: "Second result",
					projectId: "project-123",
					folderId: null,
					tags: [],
					metadata: {},
					similarity: 0.85,
					createdAt: new Date("2024-01-01"),
					updatedAt: new Date("2024-01-01"),
				},
			];
			const response = {
				content: [
					{
						type: "text" as const,
						text: JSON.stringify(searchResults, null, 2),
					},
				],
			};
			const parsedResults = JSON.parse(response.content[0].text);

			expect(parsedResults).toHaveLength(2);
			expect(parsedResults[0].similarity).toBe(0.95);
			expect(parsedResults[1].similarity).toBe(0.85);
		});
	});
	describe("Environment Variable Handling", () => {
		it("throws error when required environment variable is missing", () => {
			function getRequiredEnvironmentVariable(name: string): string {
				const environmentVariableValue = undefined;

				if (!environmentVariableValue) {
					throw new Error(`Missing required environment variable: ${name}`);
				}

				return environmentVariableValue;
			}

			expect(() => getRequiredEnvironmentVariable("SUPABASE_URL")).toThrow(
				"Missing required environment variable: SUPABASE_URL",
			);
		});
		it("returns undefined for optional environment variable when not set", () => {
			function getOptionalEnvironmentVariable(
				_name: string,
			): string | undefined {
				return undefined;
			}

			const result = getOptionalEnvironmentVariable("OPTIONAL_VAR");

			expect(result).toBeUndefined();
		});
	});
	describe("API Key Authentication", () => {
		it("validates API key format correctly", () => {
			function isValidApiKeyFormat(apiKey: string): boolean {
				const prefix = "imemio_";

				if (!apiKey.startsWith(prefix)) {
					return false;
				}

				const keyPart = apiKey.slice(prefix.length);

				return keyPart.length === 32 && /^[0-9a-f]+$/i.test(keyPart);
			}

			expect(isValidApiKeyFormat("imemio_0cee07c39ef7ba7d8e23e760929ce7bc")).toBe(
				true,
			);
			expect(isValidApiKeyFormat("invalid_key")).toBe(false);
			expect(isValidApiKeyFormat("imemio_short")).toBe(false);
			expect(isValidApiKeyFormat("sk_0cee07c39ef7ba7d8e23e760929ce7bc")).toBe(
				false,
			);
		});
		it("returns userId from direct environment variable", async () => {
			interface AuthResult {
				userId: string;
				useServiceRole: boolean;
			}

			function resolveAuthFromDirectUserId(
				directUserId: string | undefined,
			): AuthResult | null {
				if (directUserId) {
					return { userId: directUserId, useServiceRole: true };
				}

				return null;
			}

			const result = resolveAuthFromDirectUserId("user-123");

			expect(result).not.toBeNull();
			expect(result?.userId).toBe("user-123");
			expect(result?.useServiceRole).toBe(true);
		});
		it("returns null when no direct userId is provided", () => {
			interface AuthResult {
				userId: string;
				useServiceRole: boolean;
			}

			function resolveAuthFromDirectUserId(
				directUserId: string | undefined,
			): AuthResult | null {
				if (directUserId) {
					return { userId: directUserId, useServiceRole: true };
				}

				return null;
			}

			const result = resolveAuthFromDirectUserId(undefined);

			expect(result).toBeNull();
		});
		it("validates API key and returns userId on success", async () => {
			interface AuthResult {
				userId: string;
				useServiceRole: boolean;
			}
			interface ValidationResult {
				valid: boolean;
				userId?: string;
				error?: string;
			}

			async function resolveAuthFromApiKey(
				apiKey: string,
				validator: { validate: (key: string) => Promise<ValidationResult> },
			): Promise<AuthResult> {
				const result = await validator.validate(apiKey);

				if (!result.valid || !result.userId) {
					throw new Error(`API key validation failed: ${result.error}`);
				}

				return { userId: result.userId, useServiceRole: true };
			}

			const mockValidator = {
				validate: vi.fn().mockResolvedValue({
					valid: true,
					userId: "user-456",
					apiKeyId: "key-789",
				}),
			};
			const result = await resolveAuthFromApiKey(
				"imemio_0cee07c39ef7ba7d8e23e760929ce7bc",
				mockValidator,
			);

			expect(result.userId).toBe("user-456");
			expect(result.useServiceRole).toBe(true);
			expect(mockValidator.validate).toHaveBeenCalledWith(
				"imemio_0cee07c39ef7ba7d8e23e760929ce7bc",
			);
		});
		it("throws error when API key validation fails", async () => {
			interface ValidationResult {
				valid: boolean;
				userId?: string;
				error?: string;
			}

			async function resolveAuthFromApiKey(
				apiKey: string,
				validator: { validate: (key: string) => Promise<ValidationResult> },
			): Promise<{ userId: string; useServiceRole: boolean }> {
				const result = await validator.validate(apiKey);

				if (!result.valid || !result.userId) {
					throw new Error(`API key validation failed: ${result.error}`);
				}

				return { userId: result.userId, useServiceRole: true };
			}

			const mockValidator = {
				validate: vi.fn().mockResolvedValue({
					valid: false,
					error: "Invalid or revoked API key",
				}),
			};

			await expect(
				resolveAuthFromApiKey("imemio_invalid", mockValidator),
			).rejects.toThrow("API key validation failed: Invalid or revoked API key");
		});
		it("throws error for invalid API key format", () => {
			function validateApiKeyFormat(apiKey: string): void {
				const prefix = "imemio_";

				if (!apiKey.startsWith(prefix)) {
					throw new Error(
						"Invalid IMEMIO_API_KEY format. Expected: imemio_<32 hex chars>",
					);
				}

				const keyPart = apiKey.slice(prefix.length);

				if (keyPart.length !== 32 || !/^[0-9a-f]+$/i.test(keyPart)) {
					throw new Error(
						"Invalid IMEMIO_API_KEY format. Expected: imemio_<32 hex chars>",
					);
				}
			}

			expect(() => validateApiKeyFormat("invalid_key")).toThrow(
				"Invalid IMEMIO_API_KEY format",
			);
			expect(() => validateApiKeyFormat("imemio_short")).toThrow(
				"Invalid IMEMIO_API_KEY format",
			);
			expect(() =>
				validateApiKeyFormat("imemio_0cee07c39ef7ba7d8e23e760929ce7bc"),
			).not.toThrow();
		});
		it("uses service role key when authenticated via API key", () => {
			interface AuthResult {
				userId: string;
				useServiceRole: boolean;
			}

			function selectSupabaseKey(
				authResult: AuthResult,
				anonKey: string,
				serviceRoleKey: string,
			): string {
				return authResult.useServiceRole ? serviceRoleKey : anonKey;
			}

			const authResult: AuthResult = {
				userId: "user-123",
				useServiceRole: true,
			};
			const selectedKey = selectSupabaseKey(
				authResult,
				"anon-key",
				"service-role-key",
			);

			expect(selectedKey).toBe("service-role-key");
		});
		it("uses anon key when useServiceRole is false", () => {
			interface AuthResult {
				userId: string;
				useServiceRole: boolean;
			}

			function selectSupabaseKey(
				authResult: AuthResult,
				anonKey: string,
				serviceRoleKey: string,
			): string {
				return authResult.useServiceRole ? serviceRoleKey : anonKey;
			}

			const authResult: AuthResult = {
				userId: "user-123",
				useServiceRole: false,
			};
			const selectedKey = selectSupabaseKey(
				authResult,
				"anon-key",
				"service-role-key",
			);

			expect(selectedKey).toBe("anon-key");
		});
	});
});