import { z } from 'zod';
import {
  ActionStatus,
  AuditStatus,
  AuditTemplateCategory,
  AuditType,
  CapaStatus,
  DocumentType,
  IncidentType,
  MaintenanceType,
  NcrStatus,
  RiskCategory,
  Severity,
  UserRole,
  BatchStatus,
  MaterialLotStatus,
  RecallDrillStatus,
  RecallStatus,
  RecallNotificationStatus,
  MonitoringFieldType,
  MonitoringFrequency,
  DailyOperationSubType,
} from '../enums/index.js';
import { FoodChainCategory, PrpStandard, SchemeVersion } from '../fssc/enums.js';

export const userRoleSchema = z.enum([
  UserRole.SYSTEM_ADMIN,
  UserRole.COMPLIANCE_MANAGER,
  UserRole.FOOD_SAFETY_MANAGER,
  UserRole.QUALITY_MANAGER,
  UserRole.DEPARTMENT_MANAGER,
  UserRole.AUDITOR,
  UserRole.EMPLOYEE,
  UserRole.EXTERNAL_AUDITOR,
  UserRole.CUSTOMER_PORTAL,
  UserRole.SUPPLIER_PORTAL,
]);

export const createOrganisationSchema = z.object({
  name: z.string().min(2, 'Organisation name is required'),
  industry: z.string().optional(),
  siteName: z.string().min(1, 'Site name is required'),
  siteCode: z
    .string()
    .min(2, 'Site code is required')
    .max(10, 'Site code must be 10 characters or fewer')
    .regex(/^[A-Za-z0-9-]+$/, 'Site code can only contain letters, numbers, and hyphens'),
});

export const inviteUserSchema = z.object({
  email: z.string().email('Valid email required'),
  role: userRoleSchema,
  siteIds: z.array(z.string()).default([]),
  linkedSupplierId: z.string().optional(),
  customerName: z.string().optional(),
}).superRefine((data, ctx) => {
  if (data.role === UserRole.CUSTOMER_PORTAL && !data.customerName?.trim()) {
    ctx.addIssue({
      code: 'custom',
      message: 'Customer name is required for customer portal invites',
      path: ['customerName'],
    });
  }
  if (data.role === UserRole.SUPPLIER_PORTAL && !data.linkedSupplierId) {
    ctx.addIssue({
      code: 'custom',
      message: 'Supplier is required for supplier portal invites',
      path: ['linkedSupplierId'],
    });
  }
});

export const createSiteSchema = z.object({
  name: z.string().min(2, 'Site name is required'),
  code: z
    .string()
    .min(2, 'Site code is required')
    .max(12, 'Site code must be 12 characters or fewer')
    .regex(/^[A-Za-z0-9-]+$/, 'Use letters, numbers, and hyphens only'),
});

export const updateSiteSchema = z.object({
  name: z.string().min(2).optional(),
  code: z
    .string()
    .min(2)
    .max(12)
    .regex(/^[A-Za-z0-9-]+$/)
    .optional(),
  active: z.boolean().optional(),
});

export const updateMemberSchema = z.object({
  userId: z.string().min(1),
  role: userRoleSchema.optional(),
  status: z.enum(['active', 'deactivated']).optional(),
  siteIds: z.array(z.string()).optional(),
});

export const acceptInviteSchema = z.object({
  inviteId: z.string().min(1),
});

export const createAuditSchema = z.object({
  type: z.enum([
    AuditType.INTERNAL,
    AuditType.EXTERNAL,
    AuditType.FSSC,
    AuditType.BRC,
    AuditType.CUSTOMER,
    AuditType.SUPPLIER,
    AuditType.GMP,
  ]),
  title: z.string().min(3, 'Title is required'),
  scheduledDate: z.string().min(1, 'Scheduled date is required'),
  auditorIds: z.array(z.string()).min(1, 'At least one auditor required'),
  department: z.string().optional(),
  area: z.string().optional(),
  siteId: z.string().optional(),
  templateId: z.string().optional(),
});

const auditTemplateItemSchema = z.object({
  id: z.string().min(1),
  requirement: z.string().min(1, 'Requirement is required'),
  clauseRef: z.string().optional(),
  guidance: z.string().optional(),
  scoringWeight: z.number().min(0).max(10).optional(),
  referenceAttachmentUrl: z.string().url().optional().or(z.literal('')),
});

const auditTemplateSectionSchema = z.object({
  id: z.string().min(1),
  title: z.string().min(1, 'Section title is required'),
  items: z.array(auditTemplateItemSchema).min(1, 'Add at least one checklist item'),
});

export const createAuditTemplateSchema = z.object({
  name: z.string().min(2, 'Name is required'),
  description: z.string().optional(),
  category: z.enum([
    AuditTemplateCategory.FSSC_INTERNAL,
    AuditTemplateCategory.GMP_HYGIENE,
    AuditTemplateCategory.BRC,
    AuditTemplateCategory.ISO_22000,
    AuditTemplateCategory.CUSTOM,
  ]),
  auditType: z.enum([
    AuditType.INTERNAL,
    AuditType.EXTERNAL,
    AuditType.FSSC,
    AuditType.BRC,
    AuditType.CUSTOMER,
    AuditType.SUPPLIER,
    AuditType.GMP,
  ]),
  sections: z.array(auditTemplateSectionSchema).min(1, 'Add at least one section'),
});

const auditChecklistItemSchema = z.object({
  id: z.string(),
  requirement: z.string().min(1),
  clauseRef: z.string().optional(),
  result: z.enum(['pass', 'fail', 'na']).optional(),
  findingId: z.string().optional(),
});

export const updateAuditChecklistSchema = z.object({
  checklist: z.array(auditChecklistItemSchema),
  score: z.coerce.number().min(0).max(100).optional(),
});

export const createAuditFindingSchema = z.object({
  auditId: z.string().min(1),
  description: z.string().min(5, 'Description is required'),
  severity: z.enum([Severity.MINOR, Severity.MAJOR, Severity.CRITICAL]),
  clauseRef: z.string().optional(),
  assignedTo: z.string().optional(),
  dueDate: z.string().optional(),
});

export const createNcrSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().min(10, 'Description is required'),
  severity: z.enum([Severity.MINOR, Severity.MAJOR, Severity.CRITICAL]),
  classification: z.enum(['food_safety', 'quality', 'operational', 'legal']),
  sourceType: z.enum(['manual', 'audit', 'complaint', 'incident', 'daily_operations', 'monitoring', 'equipment']).default('manual'),
  sourceId: z.string().optional(),
  siteId: z.string().optional(),
});

export const createCapaSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().min(10, 'Description is required'),
  linkedNcrId: z.string().optional(),
  type: z.enum(['corrective', 'preventive', 'both']),
  siteId: z.string().optional(),
});

export const createActionSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().min(5, 'Description is required'),
  sourceType: z.enum(['manual', 'audit', 'ncr', 'capa', 'risk', 'complaint', 'incident', 'training', 'maintenance', 'daily_operations', 'document', 'supplier', 'monitoring', 'equipment']),
  sourceId: z.string().optional(),
  assignedTo: z.string().min(1, 'Assignee is required'),
  dueDate: z.string().min(1, 'Due date is required'),
  priority: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
  siteId: z.string().optional(),
});

const riskRatingSchema = z.coerce.number().int().min(1).max(5);

export const createRiskSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().min(10, 'Description is required'),
  category: z.enum([
    RiskCategory.FOOD_SAFETY,
    RiskCategory.QUALITY,
    RiskCategory.LEGAL,
    RiskCategory.OPERATIONAL,
    RiskCategory.FINANCIAL,
    RiskCategory.SUPPLIER,
    RiskCategory.CUSTOMER,
    RiskCategory.EQUIPMENT,
    RiskCategory.HYGIENE,
  ]),
  likelihood: riskRatingSchema,
  severity: riskRatingSchema,
  controls: z.string().min(5, 'Controls are required'),
  siteId: z.string().optional(),
});

export const updateRiskResidualSchema = z.object({
  residualLikelihood: riskRatingSchema,
  residualSeverity: riskRatingSchema,
});

export const createSupplierSchema = z.object({
  name: z.string().min(2, 'Supplier name is required'),
  code: z.string().min(2, 'Supplier code is required').max(20),
  contactName: z.string().optional(),
  email: z.string().email('Valid email required').optional().or(z.literal('')),
  phone: z.string().optional(),
  address: z.string().optional(),
  riskRating: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
});

export const certificationProfileSchema = z.object({
  foodChainCategory: z.enum([
    FoodChainCategory.BIII,
    FoodChainCategory.C,
    FoodChainCategory.D,
    FoodChainCategory.E,
    FoodChainCategory.F,
    FoodChainCategory.G,
    FoodChainCategory.I,
    FoodChainCategory.K,
    FoodChainCategory.FII,
  ]),
  schemeVersion: z.enum([SchemeVersion.V6, SchemeVersion.V7]),
  prpStandard: z.enum([
    PrpStandard.ISO_22002_1,
    PrpStandard.ISO_22002_2,
    PrpStandard.ISO_22002_4,
    PrpStandard.ISO_22002_5,
    PrpStandard.ISO_22002_6,
    PrpStandard.ISO_22002_7,
    PrpStandard.ISO_22002_100,
  ]),
  scopeStatement: z.string().optional(),
  targetMarkets: z.array(z.string()).optional(),
});

export const documentSectionSchema = z.object({
  id: z.string(),
  title: z.string(),
  description: z.string().optional(),
  helpText: z.string().optional(),
  required: z.boolean(),
  fieldType: z.enum(['text', 'textarea', 'process_flow']),
  content: z.string(),
});

export const createDocumentSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().optional(),
  type: z.enum([
    DocumentType.POLICY,
    DocumentType.PROCEDURE,
    DocumentType.SOP,
    DocumentType.FORM,
    DocumentType.WORK_INSTRUCTION,
    DocumentType.REGISTER,
    DocumentType.PLAN,
    DocumentType.ASSESSMENT,
    DocumentType.MANUAL,
  ]),
  reviewDate: z.string().optional(),
  siteId: z.string().optional(),
});

export const createDocumentFromTemplateSchema = z.object({
  templateId: z.string().min(1, 'Template is required'),
  reviewDate: z.string().optional(),
  siteId: z.string().optional(),
});

export const updateDocumentSectionsSchema = z.object({
  sections: z.array(documentSectionSchema),
  reviewDate: z.string().optional(),
});

export const createTrainingSchema = z.object({
  traineeId: z.string().min(1, 'Trainee is required'),
  courseName: z.string().min(2, 'Course name is required'),
  courseId: z.string().optional(),
  completedDate: z.string().optional(),
  expiryDate: z.string().optional(),
  siteId: z.string().optional(),
});

const quizQuestionSchema = z.object({
  id: z.string(),
  prompt: z.string().min(3),
  options: z.array(z.string().min(1)).min(2),
  correctIndex: z.number().int().min(0),
});

const trainingModuleSchema = z.object({
  id: z.string(),
  title: z.string().min(1),
  content: z.string().min(1),
  order: z.number().int().min(0),
  mediaUrl: z.string().url().optional().or(z.literal('')),
  mediaType: z.enum(['image', 'video', 'pdf']).optional(),
});

export const createTrainingCourseSchema = z.object({
  title: z.string().min(2, 'Title is required'),
  description: z.string().optional(),
  passScorePercent: z.coerce.number().int().min(50).max(100).default(80),
  validityDays: z.coerce.number().int().positive().optional(),
  modules: z.array(trainingModuleSchema).optional(),
  quizQuestions: z.array(quizQuestionSchema).min(1, 'Add at least one quiz question'),
  siteId: z.string().optional(),
});

export const createTrainingCurriculumSchema = z.object({
  title: z.string().min(2, 'Title is required'),
  description: z.string().optional(),
  courseIds: z.array(z.string()).min(1, 'Select at least one course'),
  assigneeRoles: z.array(userRoleSchema).min(1, 'Select at least one role'),
  siteId: z.string().optional(),
});

export const assignTrainingCurriculumSchema = z.object({
  curriculumId: z.string().min(1),
  dueDate: z.string().optional(),
});

export const submitTrainingQuizSchema = z.object({
  courseId: z.string().min(1),
  answers: z.record(z.string(), z.number().int().min(0)),
});

export const createPestZoneSchema = z.object({
  name: z.string().min(2, 'Zone name is required'),
  location: z.string().min(2, 'Location is required'),
  zoneType: z.enum(['production', 'storage', 'exterior', 'waste', 'other']),
  trapCount: z.coerce.number().int().min(0).default(0),
  siteId: z.string().optional(),
});

export const createPestInspectionSchema = z.object({
  zoneId: z.string().min(1),
  inspectionType: z.enum(['routine', 'contractor', 'complaint_response']),
  inspectionDate: z.string().min(1),
  inspectorName: z.string().min(2),
  finding: z.enum(['none', 'activity', 'dead', 'bait_taken', 'trap_damaged']),
  pestSpecies: z.string().optional(),
  correctiveAction: z.string().optional(),
  contractorName: z.string().optional(),
  notes: z.string().optional(),
  siteId: z.string().optional(),
});

export const createComplaintSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().min(10, 'Description is required'),
  customerName: z.string().min(2, 'Customer name is required'),
  productName: z.string().optional(),
  productId: z.string().optional(),
  batchId: z.string().optional(),
  batchLotCode: z.string().optional(),
  severity: z.enum([Severity.MINOR, Severity.MAJOR, Severity.CRITICAL]),
  complaintType: z.enum(['general', 'allergen_incident']).optional(),
  siteId: z.string().optional(),
});

export const createIncidentSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  description: z.string().min(10, 'Description is required'),
  type: z.enum([
    IncidentType.RECALL,
    IncidentType.WITHDRAWAL,
    IncidentType.CONTAMINATION,
    IncidentType.CUSTOMER_INCIDENT,
    IncidentType.NEAR_MISS,
  ]),
  severity: z.enum([Severity.MINOR, Severity.MAJOR, Severity.CRITICAL]),
  reportedDate: z.string().min(1, 'Reported date is required'),
  siteId: z.string().optional(),
});

export const createEquipmentSchema = z.object({
  name: z.string().min(2, 'Equipment name is required'),
  code: z.string().min(2, 'Equipment code is required').max(20),
  location: z.string().optional(),
  calibrationIntervalDays: z.coerce.number().int().positive().optional(),
  siteId: z.string().optional(),
  sensorEnabled: z.boolean().optional(),
  readingMin: z.coerce.number().optional(),
  readingMax: z.coerce.number().optional(),
  readingUnit: z.string().optional(),
  escalateToNcrOnExcursion: z.boolean().optional(),
});

export const updateEquipmentSensorSchema = z.object({
  sensorEnabled: z.boolean(),
  readingMin: z.coerce.number().optional(),
  readingMax: z.coerce.number().optional(),
  readingUnit: z.string().optional(),
  escalateToNcrOnExcursion: z.boolean().optional(),
});

export const sensorWebhookPayloadSchema = z.object({
  token: z.string().min(8),
  value: z.coerce.number(),
  unit: z.string().optional(),
  recordedAt: z.string().optional(),
});

export const importEquipmentReadingsSchema = z.object({
  equipmentId: z.string().min(1),
  rows: z.array(z.object({
    value: z.coerce.number(),
    recordedAt: z.string().min(1),
    unit: z.string().optional(),
  })).min(1),
});

export const submitSupplierCertificationSchema = z.object({
  type: z.string().min(2, 'Certification type is required'),
  name: z.string().min(2, 'Certification name is required'),
  expiryDate: z.string().optional(),
});

export const createMaintenanceSchema = z.object({
  equipmentId: z.string().min(1, 'Equipment is required'),
  type: z.enum([
    MaintenanceType.CALIBRATION,
    MaintenanceType.VERIFICATION,
    MaintenanceType.MAINTENANCE,
    MaintenanceType.BREAKDOWN,
  ]),
  scheduledDate: z.string().min(1, 'Scheduled date is required'),
  notes: z.string().optional(),
  siteId: z.string().optional(),
});

export const loginSchema = z.object({
  email: z.string().email('Valid email required'),
  password: z.string().min(6, 'Password must be at least 6 characters'),
});

export const registerSchema = loginSchema.extend({
  displayName: z.string().min(2, 'Name is required'),
  confirmPassword: z.string(),
}).refine((data) => data.password === data.confirmPassword, {
  message: 'Passwords do not match',
  path: ['confirmPassword'],
});

export const subscriptionPlanIdSchema = z.enum(['starter', 'professional', 'enterprise']);

export const billingCycleSchema = z.enum(['monthly', 'annual']);

export const createDailyOperationSchema = z.object({
  subType: z.enum([
    'gmp_check',
    'ccp_monitoring',
    'oprp_monitoring',
    'temperature_check',
    'cleaning_verification',
    'incident',
  ]),
  title: z.string().min(2, 'Title is required'),
  assignedTo: z.string().optional(),
  dueDate: z.string().optional(),
  result: z.enum(['pass', 'fail', 'na']).optional(),
  data: z.record(z.unknown()).default({}),
  siteId: z.string().optional(),
});

export const updateManagementReviewSchema = z.object({
  comments: z.string().optional(),
  decisions: z.string().optional(),
  status: z.enum(['draft', 'in_review', 'approved']).optional(),
});

export const initiateSubscriptionSchema = z.object({
  organisationId: z.string().min(1),
  planId: subscriptionPlanIdSchema,
  billingCycle: billingCycleSchema.default('monthly'),
});

export type InitiateSubscriptionInput = z.infer<typeof initiateSubscriptionSchema>;

export type CreateOrganisationInput = z.infer<typeof createOrganisationSchema>;
export type CreateSiteInput = z.infer<typeof createSiteSchema>;
export type UpdateSiteInput = z.infer<typeof updateSiteSchema>;
export type InviteUserInput = z.infer<typeof inviteUserSchema>;
export type UpdateMemberInput = z.infer<typeof updateMemberSchema>;
export type AcceptInviteInput = z.infer<typeof acceptInviteSchema>;
export type CreateAuditInput = z.infer<typeof createAuditSchema>;
export type CreateAuditTemplateInput = z.infer<typeof createAuditTemplateSchema>;
export type UpdateAuditChecklistInput = z.infer<typeof updateAuditChecklistSchema>;
export type CreateAuditFindingInput = z.infer<typeof createAuditFindingSchema>;
export type CreateNcrInput = z.infer<typeof createNcrSchema>;
export type CreateCapaInput = z.infer<typeof createCapaSchema>;
export type CreateActionInput = z.infer<typeof createActionSchema>;
export type CreateRiskInput = z.infer<typeof createRiskSchema>;
export type UpdateRiskResidualInput = z.infer<typeof updateRiskResidualSchema>;
export type CreateSupplierInput = z.infer<typeof createSupplierSchema>;
export type CreateDocumentInput = z.infer<typeof createDocumentSchema>;
export type CreateDocumentFromTemplateInput = z.infer<typeof createDocumentFromTemplateSchema>;
export type UpdateDocumentSectionsInput = z.infer<typeof updateDocumentSectionsSchema>;
export type CertificationProfileInput = z.infer<typeof certificationProfileSchema>;
export type CreateTrainingInput = z.infer<typeof createTrainingSchema>;
export type CreateTrainingCourseInput = z.infer<typeof createTrainingCourseSchema>;
export type CreateTrainingCurriculumInput = z.infer<typeof createTrainingCurriculumSchema>;
export type AssignTrainingCurriculumInput = z.infer<typeof assignTrainingCurriculumSchema>;
export type SubmitTrainingQuizInput = z.infer<typeof submitTrainingQuizSchema>;
export type CreatePestZoneInput = z.infer<typeof createPestZoneSchema>;
export type CreatePestInspectionInput = z.infer<typeof createPestInspectionSchema>;
export type CreateComplaintInput = z.infer<typeof createComplaintSchema>;
export type CreateIncidentInput = z.infer<typeof createIncidentSchema>;

export const createProductSchema = z.object({
  sku: z.string().min(1, 'SKU is required'),
  name: z.string().min(2, 'Product name is required'),
  allergens: z.string().optional(),
  shelfLifeDays: z.coerce.number().int().positive().optional(),
  labelMarket: z.enum(['eu', 'uk', 'us']).optional(),
  siteId: z.string().optional(),
});

const allergenMatrixEntrySchema = z.object({
  allergen: z.enum([
    'celery', 'cereals_gluten', 'crustaceans', 'eggs', 'fish', 'lupin',
    'milk', 'molluscs', 'mustard', 'nuts', 'peanuts', 'sesame', 'soybeans', 'sulphites',
  ]),
  present: z.boolean(),
  mayContain: z.boolean(),
  crossContactRisk: z.enum(['low', 'medium', 'high']).optional(),
});

const recipeLineSchema = z.object({
  id: z.string(),
  ingredientName: z.string().min(1),
  materialLotId: z.string().optional(),
  inputBatchId: z.string().optional(),
  qty: z.coerce.number().positive().optional(),
  unit: z.string().optional(),
});

export const updateProductAllergenSchema = z.object({
  allergenMatrix: z.array(allergenMatrixEntrySchema),
  labelMarket: z.enum(['eu', 'uk', 'us']).optional(),
});

export const updateProductRecipeSchema = z.object({
  recipeLines: z.array(recipeLineSchema),
});

export const labelSignOffSchema = z.object({
  market: z.enum(['eu', 'uk', 'us']),
  items: z.array(z.object({
    itemId: z.string(),
    checked: z.boolean(),
  })),
});

export const createBatchSchema = z.object({
  productId: z.string().min(1, 'Product is required'),
  lotCode: z.string().min(2, 'Lot code is required'),
  productionDate: z.string().min(1, 'Production date is required'),
  bestBefore: z.string().optional(),
  quantity: z.coerce.number().positive('Quantity is required'),
  unit: z.string().min(1, 'Unit is required').default('units'),
  status: z.enum([
    BatchStatus.IN_PRODUCTION,
    BatchStatus.RELEASED,
    BatchStatus.QUARANTINE,
    BatchStatus.RECALLED,
    BatchStatus.DISPOSED,
  ]).default(BatchStatus.RELEASED),
  siteId: z.string().optional(),
});

export const createMaterialLotSchema = z.object({
  supplierId: z.string().min(1, 'Supplier is required'),
  lotCode: z.string().min(2, 'Supplier lot code is required'),
  materialName: z.string().min(2, 'Material name is required'),
  quantity: z.coerce.number().positive('Quantity is required'),
  unit: z.string().min(1, 'Unit is required').default('kg'),
  receivedAt: z.string().min(1, 'Received date is required'),
  status: z.enum([
    MaterialLotStatus.RECEIVED,
    MaterialLotStatus.QUARANTINE,
    MaterialLotStatus.RELEASED,
    MaterialLotStatus.CONSUMED,
    MaterialLotStatus.DISPOSED,
  ]).default(MaterialLotStatus.RECEIVED),
  siteId: z.string().optional(),
});

export const createBatchGenealogySchema = z.object({
  outputBatchId: z.string().min(1),
  inputMaterialLotId: z.string().optional(),
  inputBatchId: z.string().optional(),
  qtyUsed: z.coerce.number().positive('Quantity used is required'),
  unit: z.string().min(1).default('kg'),
}).refine((data) => Boolean(data.inputMaterialLotId || data.inputBatchId), {
  message: 'Select a material lot or input batch',
  path: ['inputMaterialLotId'],
});

export const createBatchDispatchSchema = z.object({
  batchId: z.string().min(1),
  customerName: z.string().min(2, 'Customer name is required'),
  quantity: z.coerce.number().positive('Quantity is required'),
  shippedAt: z.string().min(1, 'Ship date is required'),
});

export const createRecallSchema = z.object({
  title: z.string().min(3, 'Title is required'),
  reason: z.string().min(10, 'Reason is required'),
  affectedBatchIds: z.array(z.string()).min(1, 'Select at least one batch'),
  siteId: z.string().optional(),
});

export const createRecallDrillSchema = z.object({
  scenarioLotCode: z.string().min(2, 'Lot code is required'),
  timeLimitMinutes: z.coerce.number().int().positive().default(240),
});

export const updateRecallDrillStepSchema = z.object({
  stepId: z.string().min(1),
  completed: z.boolean(),
  notes: z.string().optional(),
});

export const completeRecallDrillSchema = z.object({
  summary: z.string().min(10, 'Provide a drill summary'),
});

export const linkRecallDrillReviewSchema = z.object({
  managementReviewId: z.string().min(1, 'Select a management review'),
});

export const createRecallNotificationSchema = z.object({
  customerName: z.string().min(2, 'Customer name is required'),
  quantityAffected: z.coerce.number().positive().optional(),
  notes: z.string().optional(),
});

export type CreateProductInput = z.infer<typeof createProductSchema>;
export type UpdateProductAllergenInput = z.infer<typeof updateProductAllergenSchema>;
export type UpdateProductRecipeInput = z.infer<typeof updateProductRecipeSchema>;
export type LabelSignOffInput = z.infer<typeof labelSignOffSchema>;
export type CreateBatchInput = z.infer<typeof createBatchSchema>;
export type CreateMaterialLotInput = z.infer<typeof createMaterialLotSchema>;
export type CreateBatchGenealogyInput = z.infer<typeof createBatchGenealogySchema>;
export type CreateBatchDispatchInput = z.infer<typeof createBatchDispatchSchema>;
export type CreateRecallInput = z.infer<typeof createRecallSchema>;
export type CreateRecallDrillInput = z.infer<typeof createRecallDrillSchema>;
export type UpdateRecallDrillStepInput = z.infer<typeof updateRecallDrillStepSchema>;
export type CompleteRecallDrillInput = z.infer<typeof completeRecallDrillSchema>;
export type LinkRecallDrillReviewInput = z.infer<typeof linkRecallDrillReviewSchema>;
export type CreateRecallNotificationInput = z.infer<typeof createRecallNotificationSchema>;

const monitoringFieldDefinitionSchema = z.object({
  id: z.string(),
  label: z.string().min(1),
  type: z.enum([
    MonitoringFieldType.PASS_FAIL,
    MonitoringFieldType.TEMPERATURE,
    MonitoringFieldType.TEXT,
    MonitoringFieldType.NUMBER,
  ]),
  required: z.boolean().optional(),
  min: z.number().optional(),
  max: z.number().optional(),
  unit: z.string().optional(),
  instructionText: z.string().optional(),
  instructionMediaUrl: z.string().optional(),
  instructionMediaType: z.enum(['image', 'video', 'gif']).optional(),
});

export const createMonitoringTemplateSchema = z.object({
  name: z.string().min(2, 'Name is required'),
  description: z.string().optional(),
  frequency: z.enum([MonitoringFrequency.DAILY]).default(MonitoringFrequency.DAILY),
  assigneeRole: userRoleSchema,
  siteId: z.string().optional(),
  category: z.enum([
    DailyOperationSubType.GMP_CHECK,
    DailyOperationSubType.CCP_MONITORING,
    DailyOperationSubType.OPRP_MONITORING,
    DailyOperationSubType.TEMPERATURE_CHECK,
    DailyOperationSubType.CLEANING_VERIFICATION,
  ]).optional(),
  fields: z.array(monitoringFieldDefinitionSchema).min(1, 'Add at least one field'),
  requiresVerification: z.boolean().default(false),
  escalateToNcrOnFail: z.boolean().default(false),
  dueTime: z.string().regex(/^\d{2}:\d{2}$/, 'Use HH:mm format').optional(),
});

export const completeMonitoringTaskSchema = z.object({
  fieldData: z.record(z.union([z.string(), z.number(), z.boolean()])),
  notes: z.string().optional(),
});

export const verifyMonitoringTaskSchema = z.object({
  notes: z.string().optional(),
});

export type CreateMonitoringTemplateInput = z.infer<typeof createMonitoringTemplateSchema>;
export type CompleteMonitoringTaskInput = z.infer<typeof completeMonitoringTaskSchema>;
export type VerifyMonitoringTaskInput = z.infer<typeof verifyMonitoringTaskSchema>;

export type CreateEquipmentInput = z.infer<typeof createEquipmentSchema>;
export type UpdateEquipmentSensorInput = z.infer<typeof updateEquipmentSensorSchema>;
export type ImportEquipmentReadingsInput = z.infer<typeof importEquipmentReadingsSchema>;
export type CreateMaintenanceInput = z.infer<typeof createMaintenanceSchema>;
export type SubmitSupplierCertificationInput = z.infer<typeof submitSupplierCertificationSchema>;
export type CreateDailyOperationInput = z.infer<typeof createDailyOperationSchema>;
export type UpdateManagementReviewInput = z.infer<typeof updateManagementReviewSchema>;
export type LoginInput = z.infer<typeof loginSchema>;
export type RegisterInput = z.infer<typeof registerSchema>;