import type { PrismaClient } from "@capakraken/db";
import { PermissionKey } from "@capakraken/shared";
import { emitAllocationUpdated } from "../sse/event-bus.js";
import { managerProcedure, requirePermission } from "../trpc.js";
import {
  createTimelineBatchQuickAssignments,
  createTimelineQuickAssignment,
} from "./timeline-allocation-assignment-procedure-support.js";
import { shiftTimelineAllocations } from "./timeline-allocation-procedure-support.js";
import {
  UpdateAllocationHoursSchema,
  timelineBatchQuickAssignInputSchema,
  timelineBatchShiftAllocationsInputSchema,
  timelineQuickAssignInputSchema,
} from "./timeline-allocation-mutation-schema-support.js";
import { applyTimelineInlineAllocationUpdate } from "./timeline-allocation-inline-support.js";

export const timelineAllocationMutationProcedures = {
  updateAllocationInline: managerProcedure
    .input(UpdateAllocationHoursSchema)
    .mutation(async ({ ctx, input }) => {
      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
      const updated = await applyTimelineInlineAllocationUpdate({
        db: ctx.db as PrismaClient,
        allocationId: input.allocationId,
        hoursPerDay: input.hoursPerDay,
        startDate: input.startDate,
        endDate: input.endDate,
        includeSaturday: input.includeSaturday,
        role: input.role,
      });

      emitAllocationUpdated({
        id: updated.id,
        projectId: updated.projectId,
        resourceId: updated.resourceId,
      });

      return updated;
    }),

  quickAssign: managerProcedure
    .input(timelineQuickAssignInputSchema)
    .mutation(async ({ ctx, input }) => {
      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
      return createTimelineQuickAssignment(ctx.db as PrismaClient, {
        ...input,
        source: "quickAssign",
      });
    }),

  batchQuickAssign: managerProcedure
    .input(timelineBatchQuickAssignInputSchema)
    .mutation(async ({ ctx, input }) => {
      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
      return createTimelineBatchQuickAssignments(ctx.db as PrismaClient, {
        assignments: input.assignments.map((assignment) => ({
          ...assignment,
          source: "batchQuickAssign" as const,
        })),
      });
    }),

  batchShiftAllocations: managerProcedure
    .input(timelineBatchShiftAllocationsInputSchema)
    .mutation(async ({ ctx, input }) => {
      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
      return shiftTimelineAllocations(ctx.db as PrismaClient, {
        allocationIds: input.allocationIds,
        daysDelta: input.daysDelta,
        mode: input.mode,
      });
    }),
};