import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest"
import type { PrismaClient } from "@/generated/prisma/client"
import { createTestCategory, createTestItem } from "../helpers/factories"
import {
  resetIntegrationTestDatabase,
  startIntegrationTestDatabase,
  stopIntegrationTestDatabase,
} from "../helpers/test-db"

let prisma: PrismaClient
let createCategoryUseCase: typeof import("@/use-cases/category.use-cases").createCategoryUseCase
let updateCategoryUseCase: typeof import("@/use-cases/category.use-cases").updateCategoryUseCase
let deleteCategoryUseCase: typeof import("@/use-cases/category.use-cases").deleteCategoryUseCase

beforeAll(async () => {
  await startIntegrationTestDatabase()

  const prismaModule = await import("@/lib/prisma")
  const categoryUseCases = await import("@/use-cases/category.use-cases")

  prisma = prismaModule.prisma
  createCategoryUseCase = categoryUseCases.createCategoryUseCase
  updateCategoryUseCase = categoryUseCases.updateCategoryUseCase
  deleteCategoryUseCase = categoryUseCases.deleteCategoryUseCase
})

beforeEach(async () => {
  await resetIntegrationTestDatabase(prisma)
})

afterAll(async () => {
  await prisma?.$disconnect()
  await stopIntegrationTestDatabase()
})

describe("category use-cases", () => {
  it("creates a category and rejects duplicate names", async () => {
    await expect(createCategoryUseCase({ name: "Hardware" })).resolves.toEqual({
      success: true,
    })

    await expect(
      prisma.category.findUniqueOrThrow({ where: { name: "Hardware" } }),
    ).resolves.toMatchObject({ name: "Hardware" })

    await expect(createCategoryUseCase({ name: "Hardware" })).resolves.toEqual({
      success: false,
      errors: { name: ["Category already exists"] },
    })

    await expect(prisma.category.count()).resolves.toBe(1)
  })

  it("updates a category and rejects unchanged or duplicate names", async () => {
    const category = await createTestCategory(prisma, { name: "Peripherals" })
    const other = await createTestCategory(prisma, { name: "Networking" })

    await expect(
      updateCategoryUseCase({ id: category.id, name: "Accessories" }),
    ).resolves.toEqual({ success: true })

    await expect(
      prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
    ).resolves.toMatchObject({ name: "Accessories" })

    await expect(
      updateCategoryUseCase({ id: category.id, name: "Accessories" }),
    ).resolves.toEqual({
      success: false,
      errors: { name: ["Category name is the same as the old one"] },
    })

    await expect(
      updateCategoryUseCase({ id: category.id, name: other.name }),
    ).resolves.toEqual({
      success: false,
      errors: { name: ["Category already exists"] },
    })

    await expect(
      prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
    ).resolves.toMatchObject({ name: "Accessories" })
  })

  it("deletes empty categories and blocks deleting categories with items", async () => {
    const categoryWithItems = await createTestCategory(prisma, {
      name: "Computers",
    })
    await createTestItem(prisma, { categoryId: categoryWithItems.id })

    await expect(deleteCategoryUseCase(categoryWithItems.id)).resolves.toEqual({
      success: false,
      errors: { id: ["Category has items"] },
    })

    await expect(
      prisma.category.findUnique({ where: { id: categoryWithItems.id } }),
    ).resolves.not.toBeNull()
    await expect(prisma.item.count()).resolves.toBe(1)

    const emptyCategory = await createTestCategory(prisma, { name: "Cables" })

    await expect(deleteCategoryUseCase(emptyCategory.id)).resolves.toEqual({
      success: true,
    })

    await expect(
      prisma.category.findUnique({ where: { id: emptyCategory.id } }),
    ).resolves.toBeNull()
  })
})