import type { Person, Prisma } from "@/generated/prisma/client"
import { paginate } from "@/lib/paginate"
import prisma from "@/lib/prisma"

const personWithUserSelect = {
  include: {
    user: {
      select: {
        id: true,
        name: true,
        email: true,
        role: true,
        status: true,
        createdAt: true,
        updatedAt: true,
      },
    },
  },
} as const

export type PersonWithUser = Prisma.PersonGetPayload<
  typeof personWithUserSelect
>

export const PersonService = {
  findAll: async (): Promise<Person[]> => {
    return prisma.person.findMany({
      orderBy: {
        firstName: "asc",
      },
    })
  },
  findAllPaginated: async ({
    page = 0,
    pageSize,
    search,
  }: {
    page?: number
    pageSize?: number
    search?: string
  }) => {
    return paginate<PersonWithUser>({
      model: prisma.person,
      page,
      pageSize,
      include: personWithUserSelect.include,
      where: {
        ...(search
          ? {
              OR: [
                { email: { contains: search, mode: "insensitive" } },
                { firstName: { contains: search, mode: "insensitive" } },
                { lastName: { contains: search, mode: "insensitive" } },
              ],
            }
          : {}),
      },
    })
  },
  findAllPeopleCount: async (): Promise<number> => {
    return prisma.person.count()
  },

  findById: async (
    id: string,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<Person | null> => {
    return db.person.findUnique({ where: { id } })
  },

  findByIdWithUser: async (
    id: string,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<PersonWithUser | null> => {
    return db.person.findUnique({
      where: { id },
      include: personWithUserSelect.include,
    })
  },

  findByEmail: async (
    email: string,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<Person | null> => {
    return db.person.findFirst({ where: { email } })
  },

  create: async (
    data: Prisma.PersonCreateInput,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<Person> => {
    return db.person.create({ data })
  },

  update: async (
    id: string,
    data: Prisma.PersonUpdateInput,
    db: Prisma.TransactionClient | typeof prisma = prisma,
  ): Promise<Person> => {
    return db.person.update({ where: { id }, data })
  },
}