// src/server/features/operations/operations.schema.ts
// Zod schemas for operations validation

import { z } from 'zod';

// Enums
export const cleaningStatusEnum = z.enum(['DIRTY', 'CLEAN', 'IN_PROGRESS']);
export type CleaningStatus = z.infer<typeof cleaningStatusEnum>;

export const linenTypeEnum = z.enum(['SHEETS', 'TOWELS', 'PILLOWCASES', 'BLANKETS', 'OTHER']);
export type LinenType = z.infer<typeof linenTypeEnum>;

// Linen Data Item Schema (Snapshot from Inventory)
export const linenDataItemSchema = z.object({
  inventoryId: z.string().uuid(),
  name: z.string(),
  weight: z.number().nonnegative(),
  quantity: z.number().int().min(0),
});

export type LinenDataItem = z.infer<typeof linenDataItemSchema>;

// Daily Check-in Schemas
export const createDailyCheckinSchema = z.object({
  roomId: z.string().max(10), // Room ID (e.g., "A1", "B12")
  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
  isCleaned: z.boolean().default(false),
  cleanerName: z.string().max(255).optional(),
  linenData: z.array(linenDataItemSchema).optional(),
  isDispatched: z.boolean().default(false),
});

export const patchDailyCheckinSchema = z.object({
  isOccupied: z.boolean().optional(),
  isPermanent: z.boolean().optional(),
  bedsCount: z.number().int().optional(),
  isCleaned: z.boolean().optional(),
  cleanerName: z.string().max(255).optional(),
  linenData: z.array(linenDataItemSchema).optional(),
});

export const dailyCheckinResponseSchema = z.object({
  id: z.string().uuid(),
  roomId: z.string(), // Room ID (e.g., "A1", "B12")
  roomType: z.string(), // Snapshot data from rooms table
  date: z.string(), // YYYY-MM-DD format
  isOccupied: z.boolean(),
  isPermanent: z.boolean(),
  bedsCount: z.number().int(),
  isCleaned: z.boolean(),
  cleanerName: z.string().nullable(),
  linenData: z.array(z.any()).nullable().default([]), // Relaxed: Accept any array structure
  isDispatched: z.boolean(),
  createdAt: z.string().datetime(),
  updatedAt: z.string().datetime(),
});

export type DailyCheckinResponse = z.infer<typeof dailyCheckinResponseSchema>;
export type CreateDailyCheckinInput = z.infer<typeof createDailyCheckinSchema>;
export type PatchDailyCheckinInput = z.infer<typeof patchDailyCheckinSchema>;

// Inventory Linen Schemas
export const invLinenResponseSchema = z.object({
  id: z.string().uuid(),
  name: z.string(),
  type: linenTypeEnum,
  weight: z.string(), // decimal as string from database
  unit: z.string(),
  description: z.string().nullable(),
  createdAt: z.string().datetime(),
  updatedAt: z.string().datetime(),
  archivedAt: z.string().datetime().nullable(),
});

export type InvLinenResponse = z.infer<typeof invLinenResponseSchema>;

// Linen Dispatch Log Schemas
export const linenDispatchDetailsSchema = z.object({
  roomId: z.string(), // Room ID (e.g., "A1", "B12")
  items: z.array(linenDataItemSchema),
  totalWeight: z.number().nonnegative(),
});

export const createLinenDispatchLogSchema = z.object({
  dispatchDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
  totalWeight: z.number().nonnegative(),
  details: z.array(linenDispatchDetailsSchema),
});

export const dispatchLaundrySchema = z.object({
  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
});

export const linenDispatchLogResponseSchema = z.object({
  id: z.string().uuid(),
  dispatchDate: z.string(), // YYYY-MM-DD format
  totalWeight: z.number().nonnegative(),
  details: z.array(linenDispatchDetailsSchema),
  dispatchedAt: z.string().datetime(),
  createdAt: z.string().datetime(),
});

export type LinenDispatchLogResponse = z.infer<typeof linenDispatchLogResponseSchema>;
export type CreateLinenDispatchLogInput = z.infer<typeof createLinenDispatchLogSchema>;
export type DispatchLaundryInput = z.infer<typeof dispatchLaundrySchema>;

// Linen Usage Report Schemas
export const linenUsageReportItemSchema = z.object({
  name: z.string(),
  totalQuantity: z.number().int(),
  totalWeight: z.number().nonnegative(),
});

export const linenUsageReportSchema = z.object({
  items: z.array(linenUsageReportItemSchema),
  grandTotalWeight: z.number().nonnegative(),
});

export const getLinenUsageReportSchema = z.object({
  from: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
  to: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
});

export type LinenUsageReportItem = z.infer<typeof linenUsageReportItemSchema>;
export type LinenUsageReport = z.infer<typeof linenUsageReportSchema>;
export type GetLinenUsageReportInput = z.infer<typeof getLinenUsageReportSchema>;

// Global Daily Linen Usage Schemas
export const dailyLinenUsageResponseSchema = z.object({
  id: z.string().nullable().optional(), // Remove .uuid() constraint - can be any string or null
  date: z.string(), // YYYY-MM-DD format
  linenData: z.array(linenDataItemSchema).default([]),
  updatedAt: z.string().datetime().nullable().optional(),
});

export const patchDailyLinenUsageSchema = z.object({
  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
  linenData: z.array(linenDataItemSchema),
});

// Sync Checkins Schema
export const syncCheckinsSchema = z.object({
  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), // YYYY-MM-DD format
});

export const syncCheckinsResponseSchema = z.object({
  added: z.number().int().nonnegative(),
  deleted: z.number().int().nonnegative(),
});

export type SyncCheckinsInput = z.infer<typeof syncCheckinsSchema>;
export type SyncCheckinsResponse = z.infer<typeof syncCheckinsResponseSchema>;

export type DailyLinenUsageResponse = z.infer<typeof dailyLinenUsageResponseSchema>;
export type PatchDailyLinenUsageInput = z.infer<typeof patchDailyLinenUsageSchema>;