export const UserRole = {
  SYSTEM_ADMIN: 'system_admin',
  COMPLIANCE_MANAGER: 'compliance_manager',
  FOOD_SAFETY_MANAGER: 'food_safety_manager',
  QUALITY_MANAGER: 'quality_manager',
  DEPARTMENT_MANAGER: 'department_manager',
  AUDITOR: 'auditor',
  EMPLOYEE: 'employee',
  EXTERNAL_AUDITOR: 'external_auditor',
  CUSTOMER_PORTAL: 'customer_portal',
  SUPPLIER_PORTAL: 'supplier_portal',
} as const;

export type UserRole = (typeof UserRole)[keyof typeof UserRole];

export const USER_ROLE_LABELS: Record<UserRole, string> = {
  [UserRole.SYSTEM_ADMIN]: 'Admin',
  [UserRole.COMPLIANCE_MANAGER]: 'Compliance Manager',
  [UserRole.FOOD_SAFETY_MANAGER]: 'Food Safety Manager',
  [UserRole.QUALITY_MANAGER]: 'QA Manager',
  [UserRole.DEPARTMENT_MANAGER]: 'Supervisor',
  [UserRole.AUDITOR]: 'Auditor',
  [UserRole.EMPLOYEE]: 'Employee',
  [UserRole.EXTERNAL_AUDITOR]: 'External Auditor',
  [UserRole.CUSTOMER_PORTAL]: 'Customer Portal',
  [UserRole.SUPPLIER_PORTAL]: 'Supplier Portal',
};

export const AuditType = {
  INTERNAL: 'internal',
  EXTERNAL: 'external',
  FSSC: 'fssc',
  BRC: 'brc',
  CUSTOMER: 'customer',
  SUPPLIER: 'supplier',
  GMP: 'gmp',
} as const;

export type AuditType = (typeof AuditType)[keyof typeof AuditType];

export const AUDIT_TYPE_LABELS: Record<AuditType, string> = {
  [AuditType.INTERNAL]: 'Internal Audit',
  [AuditType.EXTERNAL]: 'External Audit',
  [AuditType.FSSC]: 'FSSC Audit',
  [AuditType.BRC]: 'BRC Audit',
  [AuditType.CUSTOMER]: 'Customer Audit',
  [AuditType.SUPPLIER]: 'Supplier Audit',
  [AuditType.GMP]: 'GMP Audit',
};

export const AuditTemplateCategory = {
  FSSC_INTERNAL: 'fssc_internal',
  GMP_HYGIENE: 'gmp_hygiene',
  BRC: 'brc',
  ISO_22000: 'iso_22000',
  CUSTOM: 'custom',
} as const;

export type AuditTemplateCategory = (typeof AuditTemplateCategory)[keyof typeof AuditTemplateCategory];

export const AUDIT_TEMPLATE_CATEGORY_LABELS: Record<AuditTemplateCategory, string> = {
  [AuditTemplateCategory.FSSC_INTERNAL]: 'FSSC internal',
  [AuditTemplateCategory.GMP_HYGIENE]: 'GMP hygiene',
  [AuditTemplateCategory.BRC]: 'BRC',
  [AuditTemplateCategory.ISO_22000]: 'ISO 22000',
  [AuditTemplateCategory.CUSTOM]: 'Custom',
};

export const AuditStatus = {
  SCHEDULED: 'scheduled',
  IN_PROGRESS: 'in_progress',
  COMPLETED: 'completed',
  SIGNED_OFF: 'signed_off',
} as const;

export type AuditStatus = (typeof AuditStatus)[keyof typeof AuditStatus];

export const NcrStatus = {
  OPEN: 'open',
  INVESTIGATION: 'investigation',
  ACTION_REQUIRED: 'action_required',
  VERIFICATION: 'verification',
  CLOSED: 'closed',
} as const;

export type NcrStatus = (typeof NcrStatus)[keyof typeof NcrStatus];

export const CapaStatus = {
  OPEN: 'open',
  IN_PROGRESS: 'in_progress',
  VERIFICATION: 'verification',
  EFFECTIVENESS_REVIEW: 'effectiveness_review',
  CLOSED: 'closed',
} as const;

export type CapaStatus = (typeof CapaStatus)[keyof typeof CapaStatus];

export const CAPA_TYPE_LABELS = {
  corrective: 'Corrective',
  preventive: 'Preventive',
  both: 'Corrective & Preventive',
} as const;

export const ActionStatus = {
  OPEN: 'open',
  IN_PROGRESS: 'in_progress',
  OVERDUE: 'overdue',
  PENDING_VERIFICATION: 'pending_verification',
  CLOSED: 'closed',
} as const;

export type ActionStatus = (typeof ActionStatus)[keyof typeof ActionStatus];

export const ACTION_PRIORITY_LABELS = {
  low: 'Low',
  medium: 'Medium',
  high: 'High',
  critical: 'Critical',
} as const;

export const ACTION_SOURCE_LABELS = {
  manual: 'Manual',
  audit: 'Audit',
  ncr: 'NCR',
  capa: 'CAPA',
  risk: 'Risk',
  complaint: 'Complaint',
  incident: 'Incident',
  training: 'Training',
  maintenance: 'Maintenance',
  daily_operations: 'Daily Operations',
  document: 'Document',
  supplier: 'Supplier',
  monitoring: 'Monitoring',
  equipment: 'Equipment',
} as const;

export const Severity = {
  MINOR: 'minor',
  MAJOR: 'major',
  CRITICAL: 'critical',
} as const;

export type Severity = (typeof Severity)[keyof typeof Severity];

export const SEVERITY_LABELS: Record<Severity, string> = {
  [Severity.MINOR]: 'Minor',
  [Severity.MAJOR]: 'Major',
  [Severity.CRITICAL]: 'Critical',
};

export const NCR_CLASSIFICATION_LABELS = {
  food_safety: 'Food Safety',
  quality: 'Quality',
  operational: 'Operational',
  legal: 'Legal',
} as const;

export const RefType = {
  AUDIT: 'audit',
  NCR: 'ncr',
  CAPA: 'capa',
  ACTION: 'action',
  RISK: 'risk',
  DOCUMENT: 'document',
  TRAINING: 'training',
  COMPLAINT: 'complaint',
  INCIDENT: 'incident',
  EQUIPMENT: 'equipment',
  MAINTENANCE: 'maintenance',
} as const;

export type RefType = (typeof RefType)[keyof typeof RefType];

export const RiskCategory = {
  FOOD_SAFETY: 'food_safety',
  QUALITY: 'quality',
  LEGAL: 'legal',
  OPERATIONAL: 'operational',
  FINANCIAL: 'financial',
  SUPPLIER: 'supplier',
  CUSTOMER: 'customer',
  EQUIPMENT: 'equipment',
  HYGIENE: 'hygiene',
} as const;

export type RiskCategory = (typeof RiskCategory)[keyof typeof RiskCategory];

export const RISK_CATEGORY_LABELS: Record<RiskCategory, string> = {
  [RiskCategory.FOOD_SAFETY]: 'Food Safety',
  [RiskCategory.QUALITY]: 'Quality',
  [RiskCategory.LEGAL]: 'Legal',
  [RiskCategory.OPERATIONAL]: 'Operational',
  [RiskCategory.FINANCIAL]: 'Financial',
  [RiskCategory.SUPPLIER]: 'Supplier',
  [RiskCategory.CUSTOMER]: 'Customer',
  [RiskCategory.EQUIPMENT]: 'Equipment',
  [RiskCategory.HYGIENE]: 'Hygiene',
};

export const RiskStatus = {
  IDENTIFIED: 'identified',
  ASSESSED: 'assessed',
  MITIGATED: 'mitigated',
  MONITORING: 'monitoring',
  CLOSED: 'closed',
} as const;

export type RiskStatus = (typeof RiskStatus)[keyof typeof RiskStatus];

export const RISK_RATING_LABELS: Record<number, string> = {
  1: '1 — Rare / Negligible',
  2: '2 — Unlikely / Minor',
  3: '3 — Possible / Moderate',
  4: '4 — Likely / Major',
  5: '5 — Almost Certain / Severe',
};

export const SupplierStatus = {
  PENDING: 'pending',
  APPROVED: 'approved',
  CONDITIONAL: 'conditional',
  SUSPENDED: 'suspended',
  NOT_APPROVED: 'not_approved',
} as const;

export type SupplierStatus = (typeof SupplierStatus)[keyof typeof SupplierStatus];

export const SUPPLIER_STATUS_LABELS: Record<SupplierStatus, string> = {
  [SupplierStatus.PENDING]: 'Pending Approval',
  [SupplierStatus.APPROVED]: 'Approved',
  [SupplierStatus.CONDITIONAL]: 'Conditional',
  [SupplierStatus.SUSPENDED]: 'Suspended',
  [SupplierStatus.NOT_APPROVED]: 'Not Approved',
};

export const DocumentType = {
  POLICY: 'policy',
  PROCEDURE: 'procedure',
  SOP: 'sop',
  FORM: 'form',
  WORK_INSTRUCTION: 'work_instruction',
  REGISTER: 'register',
  PLAN: 'plan',
  ASSESSMENT: 'assessment',
  MANUAL: 'manual',
} as const;

export type DocumentType = (typeof DocumentType)[keyof typeof DocumentType];

export const DOCUMENT_TYPE_LABELS: Record<DocumentType, string> = {
  [DocumentType.POLICY]: 'Policy',
  [DocumentType.PROCEDURE]: 'Procedure',
  [DocumentType.SOP]: 'SOP',
  [DocumentType.FORM]: 'Form',
  [DocumentType.WORK_INSTRUCTION]: 'Work Instruction',
  [DocumentType.REGISTER]: 'Register',
  [DocumentType.PLAN]: 'Plan',
  [DocumentType.ASSESSMENT]: 'Assessment',
  [DocumentType.MANUAL]: 'Manual',
};

export const DocumentStatus = {
  DRAFT: 'draft',
  PENDING_APPROVAL: 'pending_approval',
  APPROVED: 'approved',
  DUE_FOR_REVIEW: 'due_for_review',
  ARCHIVED: 'archived',
} as const;

export type DocumentStatus = (typeof DocumentStatus)[keyof typeof DocumentStatus];

export const TrainingStatus = {
  NOT_STARTED: 'not_started',
  SCHEDULED: 'scheduled',
  COMPLETED: 'completed',
  DUE_SOON: 'due_soon',
  EXPIRED: 'expired',
  OVERDUE: 'overdue',
} as const;

export type TrainingStatus = (typeof TrainingStatus)[keyof typeof TrainingStatus];

export function calculateRiskScore(likelihood: number, severity: number): number {
  return likelihood * severity;
}

export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';

export function getRiskLevel(score: number): RiskLevel {
  if (score <= 5) return 'low';
  if (score <= 10) return 'medium';
  if (score <= 15) return 'high';
  return 'critical';
}

export const ComplaintStatus = {
  LOGGED: 'logged',
  INVESTIGATION: 'investigation',
  ROOT_CAUSE: 'root_cause',
  CORRECTIVE_ACTION: 'corrective_action',
  VERIFICATION: 'verification',
  CLOSED: 'closed',
} as const;

export type ComplaintStatus = (typeof ComplaintStatus)[keyof typeof ComplaintStatus];

export const COMPLAINT_STATUS_LABELS: Record<ComplaintStatus, string> = {
  [ComplaintStatus.LOGGED]: 'Logged',
  [ComplaintStatus.INVESTIGATION]: 'Under investigation',
  [ComplaintStatus.ROOT_CAUSE]: 'Root cause analysis',
  [ComplaintStatus.CORRECTIVE_ACTION]: 'Corrective action',
  [ComplaintStatus.VERIFICATION]: 'Verification',
  [ComplaintStatus.CLOSED]: 'Closed',
};

export const IncidentType = {
  RECALL: 'recall',
  WITHDRAWAL: 'withdrawal',
  CONTAMINATION: 'contamination',
  CUSTOMER_INCIDENT: 'customer_incident',
  NEAR_MISS: 'near_miss',
} as const;

export type IncidentType = (typeof IncidentType)[keyof typeof IncidentType];

export const INCIDENT_TYPE_LABELS: Record<IncidentType, string> = {
  [IncidentType.RECALL]: 'Product Recall',
  [IncidentType.WITHDRAWAL]: 'Product Withdrawal',
  [IncidentType.CONTAMINATION]: 'Contamination Event',
  [IncidentType.CUSTOMER_INCIDENT]: 'Customer Incident',
  [IncidentType.NEAR_MISS]: 'Near Miss',
};

export const IncidentStatus = {
  REPORTED: 'reported',
  INVESTIGATION: 'investigation',
  CONTAINMENT: 'containment',
  RESOLVED: 'resolved',
  CLOSED: 'closed',
} as const;

export type IncidentStatus = (typeof IncidentStatus)[keyof typeof IncidentStatus];

export const MaintenanceType = {
  CALIBRATION: 'calibration',
  VERIFICATION: 'verification',
  MAINTENANCE: 'maintenance',
  BREAKDOWN: 'breakdown',
} as const;

export type MaintenanceType = (typeof MaintenanceType)[keyof typeof MaintenanceType];

export const MAINTENANCE_TYPE_LABELS: Record<MaintenanceType, string> = {
  [MaintenanceType.CALIBRATION]: 'Calibration',
  [MaintenanceType.VERIFICATION]: 'Verification',
  [MaintenanceType.MAINTENANCE]: 'Maintenance',
  [MaintenanceType.BREAKDOWN]: 'Breakdown',
};

export const MaintenanceStatus = {
  SCHEDULED: 'scheduled',
  IN_PROGRESS: 'in_progress',
  COMPLETED: 'completed',
  OVERDUE: 'overdue',
} as const;

export type MaintenanceStatus = (typeof MaintenanceStatus)[keyof typeof MaintenanceStatus];

export const DailyOperationSubType = {
  GMP_CHECK: 'gmp_check',
  CCP_MONITORING: 'ccp_monitoring',
  OPRP_MONITORING: 'oprp_monitoring',
  TEMPERATURE_CHECK: 'temperature_check',
  CLEANING_VERIFICATION: 'cleaning_verification',
  INCIDENT: 'incident',
} as const;

export type DailyOperationSubType = (typeof DailyOperationSubType)[keyof typeof DailyOperationSubType];

export const DAILY_OPERATION_SUBTYPE_LABELS: Record<DailyOperationSubType, string> = {
  [DailyOperationSubType.GMP_CHECK]: 'GMP Check',
  [DailyOperationSubType.CCP_MONITORING]: 'CCP Monitoring',
  [DailyOperationSubType.OPRP_MONITORING]: 'OPRP Monitoring',
  [DailyOperationSubType.TEMPERATURE_CHECK]: 'Temperature Check',
  [DailyOperationSubType.CLEANING_VERIFICATION]: 'Cleaning Verification',
  [DailyOperationSubType.INCIDENT]: 'Incident',
};

export const DailyOperationStatus = {
  DRAFT: 'draft',
  IN_PROGRESS: 'in_progress',
  COMPLETED: 'completed',
  FAILED: 'failed',
  ESCALATED: 'escalated',
} as const;

export type DailyOperationStatus = (typeof DailyOperationStatus)[keyof typeof DailyOperationStatus];

export const CheckResult = {
  PASS: 'pass',
  FAIL: 'fail',
  NA: 'na',
} as const;

export type CheckResult = (typeof CheckResult)[keyof typeof CheckResult];

export const ManagementReviewStatus = {
  DRAFT: 'draft',
  IN_REVIEW: 'in_review',
  APPROVED: 'approved',
} as const;

export type ManagementReviewStatus = (typeof ManagementReviewStatus)[keyof typeof ManagementReviewStatus];

export const AuditFindingStatus = {
  OPEN: 'open',
  LINKED_NCR: 'linked_ncr',
  LINKED_CAPA: 'linked_capa',
  CLOSED: 'closed',
} as const;

export type AuditFindingStatus = (typeof AuditFindingStatus)[keyof typeof AuditFindingStatus];

export const BatchStatus = {
  IN_PRODUCTION: 'in_production',
  RELEASED: 'released',
  QUARANTINE: 'quarantine',
  RECALLED: 'recalled',
  DISPOSED: 'disposed',
} as const;

export type BatchStatus = (typeof BatchStatus)[keyof typeof BatchStatus];

export const BATCH_STATUS_LABELS: Record<BatchStatus, string> = {
  [BatchStatus.IN_PRODUCTION]: 'In production',
  [BatchStatus.RELEASED]: 'Released',
  [BatchStatus.QUARANTINE]: 'Quarantine',
  [BatchStatus.RECALLED]: 'Recalled',
  [BatchStatus.DISPOSED]: 'Disposed',
};

export const MaterialLotStatus = {
  RECEIVED: 'received',
  QUARANTINE: 'quarantine',
  RELEASED: 'released',
  CONSUMED: 'consumed',
  DISPOSED: 'disposed',
} as const;

export type MaterialLotStatus = (typeof MaterialLotStatus)[keyof typeof MaterialLotStatus];

export const MATERIAL_LOT_STATUS_LABELS: Record<MaterialLotStatus, string> = {
  [MaterialLotStatus.RECEIVED]: 'Received',
  [MaterialLotStatus.QUARANTINE]: 'Quarantine',
  [MaterialLotStatus.RELEASED]: 'Released',
  [MaterialLotStatus.CONSUMED]: 'Consumed',
  [MaterialLotStatus.DISPOSED]: 'Disposed',
};

export const RecallDrillStatus = {
  IN_PROGRESS: 'in_progress',
  COMPLETED: 'completed',
  CANCELLED: 'cancelled',
} as const;

export type RecallDrillStatus = (typeof RecallDrillStatus)[keyof typeof RecallDrillStatus];

export const RECALL_DRILL_STATUS_LABELS: Record<RecallDrillStatus, string> = {
  [RecallDrillStatus.IN_PROGRESS]: 'In progress',
  [RecallDrillStatus.COMPLETED]: 'Completed',
  [RecallDrillStatus.CANCELLED]: 'Cancelled',
};

export const RECALL_DRILL_STEPS = [
  { id: 'locate_lot', label: 'Locate affected lot', description: 'Confirm the scenario lot exists in the system' },
  { id: 'backward_trace', label: 'Trace one step back', description: 'Identify suppliers or input lots/batches' },
  { id: 'forward_trace', label: 'Trace one step forward', description: 'Identify dispatches or downstream batches' },
  { id: 'affected_customers', label: 'List affected customers', description: 'Record customers from forward trace' },
  { id: 'document_findings', label: 'Document findings', description: 'Summarise gaps, actions, and lessons learned' },
] as const;

export type RecallDrillStepId = (typeof RECALL_DRILL_STEPS)[number]['id'];

export const RecallStatus = {
  DRAFT: 'draft',
  ACTIVE: 'active',
  CONTAINMENT: 'containment',
  COMPLETED: 'completed',
  CLOSED: 'closed',
} as const;

export type RecallStatus = (typeof RecallStatus)[keyof typeof RecallStatus];

export const RECALL_STATUS_LABELS: Record<RecallStatus, string> = {
  [RecallStatus.DRAFT]: 'Draft',
  [RecallStatus.ACTIVE]: 'Active',
  [RecallStatus.CONTAINMENT]: 'Containment',
  [RecallStatus.COMPLETED]: 'Completed',
  [RecallStatus.CLOSED]: 'Closed',
};

export const RecallNotificationStatus = {
  PENDING: 'pending',
  NOTIFIED: 'notified',
  CONFIRMED: 'confirmed',
  RETURNED: 'returned',
} as const;

export type RecallNotificationStatus =
  (typeof RecallNotificationStatus)[keyof typeof RecallNotificationStatus];

export const RECALL_NOTIFICATION_STATUS_LABELS: Record<RecallNotificationStatus, string> = {
  [RecallNotificationStatus.PENDING]: 'Pending',
  [RecallNotificationStatus.NOTIFIED]: 'Notified',
  [RecallNotificationStatus.CONFIRMED]: 'Confirmed',
  [RecallNotificationStatus.RETURNED]: 'Returned',
};

export const MonitoringFieldType = {
  PASS_FAIL: 'pass_fail',
  TEMPERATURE: 'temperature',
  TEXT: 'text',
  NUMBER: 'number',
} as const;

export type MonitoringFieldType = (typeof MonitoringFieldType)[keyof typeof MonitoringFieldType];

export const MONITORING_FIELD_TYPE_LABELS: Record<MonitoringFieldType, string> = {
  [MonitoringFieldType.PASS_FAIL]: 'Pass / Fail',
  [MonitoringFieldType.TEMPERATURE]: 'Temperature',
  [MonitoringFieldType.TEXT]: 'Text',
  [MonitoringFieldType.NUMBER]: 'Number',
};

export const MonitoringFrequency = {
  DAILY: 'daily',
} as const;

export type MonitoringFrequency = (typeof MonitoringFrequency)[keyof typeof MonitoringFrequency];

export const MONITORING_FREQUENCY_LABELS: Record<MonitoringFrequency, string> = {
  [MonitoringFrequency.DAILY]: 'Daily',
};

export const MonitoringTaskStatus = {
  PENDING: 'pending',
  COMPLETED: 'completed',
  PENDING_VERIFICATION: 'pending_verification',
  OVERDUE: 'overdue',
  VERIFIED: 'verified',
} as const;

export type MonitoringTaskStatus = (typeof MonitoringTaskStatus)[keyof typeof MonitoringTaskStatus];

export const MONITORING_TASK_STATUS_LABELS: Record<MonitoringTaskStatus, string> = {
  [MonitoringTaskStatus.PENDING]: 'Pending',
  [MonitoringTaskStatus.COMPLETED]: 'Completed',
  [MonitoringTaskStatus.PENDING_VERIFICATION]: 'Awaiting verification',
  [MonitoringTaskStatus.OVERDUE]: 'Overdue',
  [MonitoringTaskStatus.VERIFIED]: 'Verified',
};

export const EquipmentReadingSource = {
  WEBHOOK: 'webhook',
  CSV: 'csv',
  MANUAL: 'manual',
} as const;

export type EquipmentReadingSource = (typeof EquipmentReadingSource)[keyof typeof EquipmentReadingSource];

export const EQUIPMENT_READING_SOURCE_LABELS: Record<EquipmentReadingSource, string> = {
  [EquipmentReadingSource.WEBHOOK]: 'Webhook',
  [EquipmentReadingSource.CSV]: 'CSV import',
  [EquipmentReadingSource.MANUAL]: 'Manual',
};

export const ComplianceCalendarEventType = {
  AUDIT: 'audit',
  MANAGEMENT_REVIEW: 'management_review',
  CERT_EXPIRY: 'cert_expiry',
  TRAINING_EXPIRY: 'training_expiry',
  RECALL_DRILL: 'recall_drill',
  DOCUMENT_REVIEW: 'document_review',
  CALIBRATION: 'calibration',
} as const;

export type ComplianceCalendarEventType = (typeof ComplianceCalendarEventType)[keyof typeof ComplianceCalendarEventType];

export const COMPLIANCE_CALENDAR_EVENT_LABELS: Record<ComplianceCalendarEventType, string> = {
  [ComplianceCalendarEventType.AUDIT]: 'Audit',
  [ComplianceCalendarEventType.MANAGEMENT_REVIEW]: 'Management review',
  [ComplianceCalendarEventType.CERT_EXPIRY]: 'Cert expiry',
  [ComplianceCalendarEventType.TRAINING_EXPIRY]: 'Training expiry',
  [ComplianceCalendarEventType.RECALL_DRILL]: 'Recall drill',
  [ComplianceCalendarEventType.DOCUMENT_REVIEW]: 'Document review',
  [ComplianceCalendarEventType.CALIBRATION]: 'Calibration',
};