import type { PrismaClient } from "@capakraken/db";
import {
  AllocationStatus,
  PermissionKey,
  UpdateAllocationHoursSchema,
} from "@capakraken/shared";
import { z } from "zod";
import { emitAllocationUpdated } from "../sse/event-bus.js";
import { managerProcedure, requirePermission } from "../trpc.js";
import {
  createTimelineBatchQuickAssignments,
  createTimelineQuickAssignment,
  shiftTimelineAllocations,
} from "./timeline-allocation-procedure-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(
      z.object({
        resourceId: z.string(),
        projectId: z.string(),
        startDate: z.coerce.date(),
        endDate: z.coerce.date(),
        hoursPerDay: z.number().min(0.5).max(24).default(8),
        role: z.string().min(1).max(200).default("Team Member"),
        roleId: z.string().optional(),
        status: z.nativeEnum(AllocationStatus).default(AllocationStatus.PROPOSED),
      }),
    )
    .mutation(async ({ ctx, input }) => {
      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
      return createTimelineQuickAssignment(ctx.db as PrismaClient, {
        ...input,
        source: "quickAssign",
      });
    }),

  batchQuickAssign: managerProcedure
    .input(
      z.object({
        assignments: z
          .array(
            z.object({
              resourceId: z.string(),
              projectId: z.string(),
              startDate: z.coerce.date(),
              endDate: z.coerce.date(),
              hoursPerDay: z.number().min(0.5).max(24).default(8),
              role: z.string().min(1).max(200).default("Team Member"),
              status: z
                .nativeEnum(AllocationStatus)
                .default(AllocationStatus.PROPOSED),
            }),
          )
          .min(1)
          .max(50),
      }),
    )
    .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(
      z.object({
        allocationIds: z.array(z.string()).min(1).max(100),
        daysDelta: z.number().int().min(-3650).max(3650),
        mode: z.enum(["move", "resize-start", "resize-end"]).default("move"),
      }),
    )
    .mutation(async ({ ctx, input }) => {
      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
      return shiftTimelineAllocations(ctx.db as PrismaClient, {
        allocationIds: input.allocationIds,
        daysDelta: input.daysDelta,
        mode: input.mode,
      });
    }),
};