import type { Prisma } from "@/generated/prisma/client"
import { paginate } from "@/lib/paginate"
import prisma from "@/lib/prisma"
import type { CreateAssignmentData } from "@/schemas/assignment.schema"
import type { Assignment, AssignmentWithPersonItemAsset } from "@/types"

export const AssignmentService = {
  findAllWithPerson: async (): Promise<AssignmentWithPersonItemAsset[]> => {
    return prisma.assignment.findMany({
      where: {
        returnDate: {
          equals: null,
        },
      },
      include: {
        person: true,
        item: true,
        asset: true,
      },
      orderBy: {
        createdAt: "desc",
      },
    })
  },
  findAllWithPersonPaginated: async ({
    page,
    pageSize,
    search,
  }: {
    page?: number
    pageSize?: number
    search?: string
  }) => {
    return paginate<AssignmentWithPersonItemAsset>({
      model: prisma.assignment,
      page,
      pageSize,
      where: {
        returnDate: {
          equals: null,
        },
        ...(search
          ? {
              OR: [
                {
                  person: {
                    firstName: { contains: search, mode: "insensitive" },
                  },
                },
                {
                  person: {
                    lastName: { contains: search, mode: "insensitive" },
                  },
                },
              ],
            }
          : {}),
      },
      include: {
        person: true,
        item: true,
        asset: true,
      },
      orderBy: {
        createdAt: "desc",
      },
    })
  },
  findById: async (
    id: string,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<AssignmentWithPersonItemAsset | null> => {
    return db.assignment.findUnique({
      where: { id },
      include: {
        person: true,
        item: true,
        asset: true,
      },
    })
  },
  findAllByPerson: async (
    personId: string,
  ): Promise<AssignmentWithPersonItemAsset[]> => {
    return prisma.assignment.findMany({
      where: { personId: personId },
      include: {
        person: true,
        item: true,
        asset: true,
      },
    })
  },
  create: async (
    data: CreateAssignmentData & { createdBy: string },
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<Assignment> => {
    const { personId, ...rest } = data
    return db.assignment.create({
      data: {
        ...rest,
        personId: personId,
      },
    })
  },
  delete: async (id: string): Promise<Assignment> => {
    return prisma.assignment.update({
      where: { id },
      data: {
        returnDate: new Date(),
        personId: null,
        quantity: null,
        assetId: null,
        itemId: null,
      },
    })
  },
  markReturnedIfActive: async (
    id: string,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<boolean> => {
    const result = await db.assignment.updateMany({
      where: {
        id,
        returnDate: null,
      },
      data: {
        returnDate: new Date(),
        personId: null,
        quantity: null,
        assetId: null,
        itemId: null,
      },
    })

    return result.count === 1
  },
  update: async (
    id: string,
    data: Prisma.AssignmentUpdateInput | Prisma.AssignmentUncheckedUpdateInput,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<Assignment> => {
    return db.assignment.update({
      where: { id },
      data,
    })
  },
}