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
let CategoryService: typeof import("@/services/category.service").CategoryService

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

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

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

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 () => {
    expect(await createCategoryUseCase({ name: "Hardware" })).toEqual({
      success: true,
    })

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

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

    expect(await prisma.category.count()).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" })

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

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

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

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

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

  it("soft deletes empty categories and keeps deleted records out of active lists", async () => {
    const categoryWithItems = await createTestCategory(prisma, {
      name: "Computers",
    })
    await createTestItem(prisma, { categoryId: categoryWithItems.id })

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

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

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

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

    const deletedCategory = await prisma.category.findUnique({
      where: { id: emptyCategory.id },
    })
    expect(deletedCategory).not.toBeNull()
    expect(deletedCategory?.deletedAt).toBeInstanceOf(Date)

    const activeCategories = await CategoryService.findAll()
    expect(activeCategories).toHaveLength(1)
    expect(activeCategories[0].id).toBe(categoryWithItems.id)
  })
})