import { prisma } from "@/lib/prisma";
import type {
  TypeAbsenceCreateInput,
  TypeAbsenceUpdateInput,
  TypeAvenantCreateInput,
  TypeAvenantUpdateInput,
  TypeContratCreateInput,
  TypeContratUpdateInput,
  TypeCsCreateInput,
  TypeCsUpdateInput,
  TypeDiplomeCreateInput,
  TypeDiplomeUpdateInput,
  classificationCreateInput,
  classificationUpdateInput,
  posteCreateInput,
  posteUpdateInput,
  etablissementCreateInput,
  etablissementUpdateInput,
  secteurUpdateInput,
  secteurCreateInput,
  cpamCreateInput,
  motifsMCreateInput,
} from "../validators/reference-lookups";

export async function listTypesAbsence(limit: number, offset: number) {
  return prisma.types_absence.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getTypeAbsenceById(id: number) {
  return prisma.types_absence.findUnique({
    where: { id },
  });
}

export async function createTypesAbsenceFeed(data: TypeAbsenceCreateInput) {
  return prisma.types_absence.create({
    data,
  });
}

export async function updateTypesAbsenceFeed(
  id: number,
  data: TypeAbsenceUpdateInput,
) {
  return prisma.types_absence.update({
    where: { id },
    data,
  });
}

export async function deleteTypesAbsenceFeed(id: number) {
  return prisma.types_absence.delete({
    where: { id },
  });
}

export async function listTypesDiplome(limit: number, offset: number) {
  return prisma.types_diplome.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getTypeDiplomeById(id: number) {
  return prisma.types_diplome.findUnique({
    where: { id },
  });
}

export async function createTypesDiplome(data: TypeDiplomeCreateInput) {
  return prisma.types_diplome.create({
    data,
  });
}

export async function updateTypesDiplome(
  id: number,
  data: TypeDiplomeUpdateInput,
) {
  return prisma.types_diplome.update({
    where: { id },
    data,
  });
}

export async function deleteTypesDiplome(id: number) {
  return prisma.types_diplome.delete({
    where: { id },
  });
}

export async function listTypesContrat(limit: number, offset: number) {
  return prisma.types_contrat_salarie.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getTypeContratById(id: number) {
  return prisma.types_contrat_salarie.findUnique({
    where: { id },
  });
}

export async function createTypesContrat(data: TypeContratCreateInput) {
  return prisma.types_contrat_salarie.create({
    data,
  });
}

export async function updateTypesContrat(
  id: number,
  data: TypeContratUpdateInput,
) {
  return prisma.types_contrat_salarie.update({
    where: { id },
    data,
  });
}

export async function deleteTypesContrat(id: number) {
  return prisma.types_contrat_salarie.delete({
    where: { id },
  });
}

export async function listTypesCs(limit: number, offset: number) {
  return prisma.types_cs.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getTypeCsById(id: number) {
  return prisma.types_cs.findUnique({
    where: { id },
  });
}

export async function createTypesCs(data: TypeCsCreateInput) {
  return prisma.types_cs.create({
    data,
  });
}

export async function updateTypesCs(id: number, data: TypeCsUpdateInput) {
  return prisma.types_cs.update({
    where: { id },
    data,
  });
}

export async function deleteTypesCs(id: number) {
  return prisma.types_cs.delete({
    where: { id },
  });
}

export async function listTypesAvenants(limit: number, offset: number) {
  return prisma.types_avenants.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getTypeAvenantById(id: number) {
  return prisma.types_avenants.findUnique({
    where: { id },
  });
}

export async function createTypesAvenant(data: TypeAvenantCreateInput) {
  return prisma.types_avenants.create({
    data,
  });
}

export async function updateTypesAvenant(
  id: number,
  data: TypeAvenantUpdateInput,
) {
  return prisma.types_avenants.update({
    where: { id },
    data,
  });
}

export async function deleteTypesAvenant(id: number) {
  return prisma.types_avenants.delete({
    where: { id },
  });
}

export async function listClassifications(limit: number, offset: number) {
  return prisma.classifications.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getClassificationById(id: number) {
  return prisma.classifications.findUnique({
    where: { id },
  });
}

export async function createClassification(data: classificationCreateInput) {
  return prisma.classifications.create({
    data: data as any,
  });
}

export async function updateClassification(
  id: number,
  data: classificationUpdateInput,
) {
  return prisma.classifications.update({
    where: { id },
    data: data as any,
  });
}

export async function deleteClassification(id: number) {
  return prisma.classifications.delete({
    where: { id },
  });
}

export async function listPostes(limit: number, offset: number) {
  return prisma.postes.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getPosteById(id: number) {
  return prisma.postes.findUnique({
    where: { id },
  });
}

export async function createPoste(data: posteCreateInput) {
  return prisma.postes.create({
    data,
  });
}

export async function updatePoste(id: number, data: posteUpdateInput) {
  return prisma.postes.update({
    where: { id },
    data,
  });
}

export async function deletePoste(id: number) {
  return prisma.postes.delete({
    where: { id },
  });
}

export async function listEtablissements(limit: number, offset: number) {
  return prisma.etablissement.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getEtablissementById(id: number) {
  return prisma.etablissement.findUnique({
    where: { id },
  });
}

export async function createEtablissement(data: etablissementCreateInput) {
  return prisma.etablissement.create({
    data,
  });
}

export async function updateEtablissement(
  id: number,
  data: etablissementUpdateInput,
) {
  return prisma.etablissement.update({
    where: { id },
    data,
  });
}

export async function deleteEtablissement(id: number) {
  return prisma.etablissement.delete({
    where: { id },
  });
}

export async function listSecteurs(limit: number, offset: number) {
  return prisma.secteurs.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function getSecteurById(id: number) {
  return prisma.secteurs.findUnique({
    where: { id },
  });
}

export async function createSecteur(data: secteurCreateInput) {
  return prisma.secteurs.create({
    data,
  });
}

export async function updateSecteur(id: number, data: secteurUpdateInput) {
  return prisma.secteurs.update({
    where: { id },
    data,
  });
}

export async function deleteSecteur(id: number) {
  return prisma.secteurs.delete({
    where: { id },
  });
}

export async function listCpam(limit: number, offset: number) {
  return prisma.cpam.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function createCpam(data: cpamCreateInput) {
  return prisma.cpam.create({
    data,
  });
}

export async function listMotifsM(limit: number, offset: number) {
  return prisma.motifs_derogation_mutuelle.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function createMotifsM(data: motifsMCreateInput) {
  return prisma.motifs_derogation_mutuelle.create({
    data,
  });
}

export async function listArh(limit: number, offset: number) {
  return prisma.arh.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listSecteursTravail(limit: number, offset: number) {
  return prisma.secteurs_travail.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listCanTypeContr(limit: number, offset: number) {
  return prisma.can_typcontr.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listCanConvinser(limit: number, offset: number) {
  return prisma.can_convinser.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listCanRuptBudg(limit: number, offset: number) {
  return prisma.can_ruptbudg.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listCanMetiers(limit: number, offset: number) {
  return prisma.can_metiers.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listMotifsSortie(limit: number, offset: number) {
  return prisma.motifs_sortie.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}

export async function listClassifSalairesBase(limit: number, offset: number) {
  return prisma.classif_salairesbase.findMany({
    where: { actif: true },
    orderBy: [{ id: "asc" }],
    take: limit,
    skip: offset,
  });
}