import {
  cancelImportBatch,
  commitImportBatch,
  commitImportBatchInputSchema,
  getImportBatch,
  importBatchIdInputSchema,
  listImportBatches,
  listImportBatchesInputSchema,
  listStagedAssignments,
  listStagedAssignmentsInputSchema,
  listStagedProjects,
  listStagedProjectsInputSchema,
  listStagedResources,
  listStagedResourcesInputSchema,
  listStagedUnresolvedRecords,
  listStagedUnresolvedRecordsInputSchema,
  listStagedVacations,
  listStagedVacationsInputSchema,
  resolveStagedRecord,
  resolveStagedRecordInputSchema,
  stageImportBatch,
  stageImportBatchInputSchema,
  validateImportBatch,
  validateImportBatchInputSchema,
} from "./dispo-procedure-support.js";
import { adminProcedure, createTRPCRouter } from "../trpc.js";

export const dispoRouter = createTRPCRouter({
  stageImportBatch: adminProcedure
    .input(stageImportBatchInputSchema)
    .mutation(({ ctx, input }) => stageImportBatch(ctx, input)),

  validateImportBatch: adminProcedure
    .input(validateImportBatchInputSchema)
    .query(({ input }) => validateImportBatch(input)),

  listImportBatches: adminProcedure
    .input(listImportBatchesInputSchema)
    .query(({ ctx, input }) => listImportBatches(ctx, input)),

  getImportBatch: adminProcedure
    .input(importBatchIdInputSchema)
    .query(({ ctx, input }) => getImportBatch(ctx, input)),

  cancelImportBatch: adminProcedure
    .input(importBatchIdInputSchema)
    .mutation(({ ctx, input }) => cancelImportBatch(ctx, input)),

  listStagedResources: adminProcedure
    .input(listStagedResourcesInputSchema)
    .query(({ ctx, input }) => listStagedResources(ctx, input)),

  listStagedProjects: adminProcedure
    .input(listStagedProjectsInputSchema)
    .query(({ ctx, input }) => listStagedProjects(ctx, input)),

  listStagedAssignments: adminProcedure
    .input(listStagedAssignmentsInputSchema)
    .query(({ ctx, input }) => listStagedAssignments(ctx, input)),

  listStagedVacations: adminProcedure
    .input(listStagedVacationsInputSchema)
    .query(({ ctx, input }) => listStagedVacations(ctx, input)),

  listStagedUnresolvedRecords: adminProcedure
    .input(listStagedUnresolvedRecordsInputSchema)
    .query(({ ctx, input }) => listStagedUnresolvedRecords(ctx, input)),

  resolveStagedRecord: adminProcedure
    .input(resolveStagedRecordInputSchema)
    .mutation(({ ctx, input }) => resolveStagedRecord(ctx, input)),

  commitImportBatch: adminProcedure
    .input(commitImportBatchInputSchema)
    .mutation(({ ctx, input }) => commitImportBatch(ctx, input)),
});