erp-platform/ui/src/utils/erp.tsx

import {
  FaArchive,
  FaArrowCircleDown,
  FaArrowDown,
  FaArrowUp,
  FaAward,
  FaBan,
  FaBolt,
  FaBox,
  FaBullseye,
  FaCalendar,
  FaCheck,
  FaCheckCircle,
  FaClock,
  FaCog,
  FaComment,
  FaEdit,
  FaEnvelope,
  FaExclamationCircle,
  FaExclamationTriangle,
  FaEye,
  FaFileAlt,
  FaFileInvoiceDollar,
  FaFlask,
  FaIndustry,
  FaLock,
  FaMapMarkerAlt,
  FaMedal,
  FaPause,
  FaPhone,
  FaPlay,
  FaPlus,
  FaStar,
  FaTimesCircle,
  FaTrophy,
  FaTruck,
  FaUser,
  FaUsers,
  FaUserTie,
  FaVideo,
  FaWrench,
} from "react-icons/fa";
import {
  ApprovalStatusEnum,
  MmDeliveryItem,
  MaterialTypeEnum,
  MovementStatusEnum,
  MovementTypeEnum,
  OrderStatusEnum,
  QualityStatusEnum,
  QuotationStatusEnum,
  RequestStatusEnum,
  RequisitionStatusEnum,
  SerialStatusEnum,
  SupplierCardTypeEnum,
  SupplierTypeEnum,
} from "../types/mm";
import {
  BOMTypeEnum,
  OperationCategoryEnum,
  MrpProductionOrder,
  ProductionOrderStatusEnum,
  ProductionOrderTypeEnum,
  RecommendationStatusEnum,
  RequirementSourceTypeEnum,
  RoutingStatusEnum,
  SecurityLevelEnum,
} from "../types/mrp";
import { FaRepeat } from "react-icons/fa6";
import {
  ApprovalLevelEnum,
  DeliveryStatusEnum,
  RequestTypeEnum,
} from "../types/mm";
import {
  ConditionOperatorEnum,
  ConditionTypeEnum,
  CountStatusEnum,
  CountTypeEnum,
  LocationTypeEnum,
  PutawayStrategyEnum,
  StockStatusEnum,
  WarehouseTypeEnum,
  ZoneTypeEnum,
} from "../types/wm";
import {
  BusinessPartyStatusEnum,
  PaymentTerms,
  PriorityEnum,
  TeamRoleEnum,
} from "../types/common";
import {
  AccountTypeEnum,
  BankAccountTypeEnum,
  BankTransactionTypeEnum,
  CashMovementTypeEnum,
  FiDocumentTypeEnum,
  InvoiceStatusEnum,
  InvoiceTypeEnum,
  PaymentMethodEnum,
  PaymentStatusEnum,
  RiskGroupEnum,
  TransactionStatusEnum,
  WaybillStatusEnum,
  WaybillTypeEnum,
} from "../types/fi";
import {
  ActivityStatusEnum,
  CrmActivityTypeEnum,
  CustomerSegmentEnum,
  LostReasonCategoryEnum,
  OpportunityStageEnum,
  SaleOrderItemStatusEnum,
  SaleOrderStatusEnum,
} from "../types/crm";
import {
  AssessorTypeEnum,
  CampaignStatusEnum,
  CostCenterType,
  EmployeeStatusEnum,
  EmploymentTypeEnum,
  JobLevelEnum,
  LeaveStatusEnum,
  LeaveTypeEnum,
  ParticipantStatusEnum,
  PayrollStatusEnum,
} from "../types/hr";
import {
  CriticalityLevelEnum,
  FaultTypeEnum,
  FrequencyUnitEnum,
  MaintenancePlanTypeEnum,
  NotificationStatusEnum,
  WorkCenterStatusEnum,
  WorkOrderStatusEnum,
  WorkOrderTypeEnum,
} from "../types/pm";
import {
  DailyUpdateStatusEnum,
  PhaseStatusEnum,
  ProjectStatusEnum,
  ProjectTypeEnum,
  PsActivityTypeEnum,
  PsDocumentTypeEnum,
  RiskCategoryEnum,
  RiskImpactEnum,
  RiskLevelEnum,
  RiskProbabilityEnum,
  RiskStatusEnum,
  TaskStatusEnum,
  TaskTypeEnum,
  WorkTypeEnum,
} from "../types/ps";

export const getBOMTypeColor = (type: BOMTypeEnum) => {
  switch (type) {
    case BOMTypeEnum.Production:
      return "bg-blue-100 text-blue-800";
    case BOMTypeEnum.Engineering:
      return "bg-green-100 text-green-800";
    case BOMTypeEnum.Planning:
      return "bg-yellow-100 text-yellow-800";
    case BOMTypeEnum.Costing:
      return "bg-purple-100 text-purple-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getBOMTypeName = (type: BOMTypeEnum) => {
  switch (type) {
    case BOMTypeEnum.Production:
      return "Üretim";
    case BOMTypeEnum.Engineering:
      return "Mühendislik";
    case BOMTypeEnum.Planning:
      return "Planlama";
    case BOMTypeEnum.Costing:
      return "Maliyetleme";
    default:
      return "Bilinmiyor";
  }
};

export const getBOMexpeText = (type: BOMTypeEnum) => {
  const types = {
    [BOMTypeEnum.Production]: "Üretim",
    [BOMTypeEnum.Engineering]: "Mühendislik",
    [BOMTypeEnum.Planning]: "Planlama",
    [BOMTypeEnum.Costing]: "Maliyetlendirme",
  };
  return types[type];
};

export const getMovementTypeInfo = (type: MovementTypeEnum) => {
  switch (type) {
    case MovementTypeEnum.GoodsReceipt:
      return {
        label: "Mal Girişi",
        icon: FaArrowUp,
        color: "text-green-600 bg-green-100",
        sign: "+",
      };
    case MovementTypeEnum.GoodsIssue:
      return {
        label: "Mal Çıkışı",
        icon: FaArrowDown,
        color: "text-red-600 bg-red-100",
        sign: "-",
      };
    case MovementTypeEnum.Transfer:
      return {
        label: "Transfer",
        icon: FaRepeat,
        color: "text-blue-600 bg-blue-100",
        sign: "",
      };
    default:
      return {
        label: "Bilinmeyen",
        icon: FaArchive,
        color: "text-gray-600 bg-gray-100",
        sign: "",
      };
  }
};

export const getMaterialTypeDisplay = (code: MaterialTypeEnum) => {
  switch (code) {
    case MaterialTypeEnum.RawMaterial:
      return "HAMMADDE";
    case MaterialTypeEnum.SemiFinished:
      return "YARI_MAMUL";
    case MaterialTypeEnum.Finished:
      return "MAMUL";
    case MaterialTypeEnum.Consumable:
      return "SARF_MALZ";
    case MaterialTypeEnum.Service:
      return "HIZMET";
    case MaterialTypeEnum.Spare:
      return "YEDEK_PARCA";
    default:
      return code;
  }
};

export const getOperationTypeText = (type: OperationCategoryEnum) => {
  const types = {
    [OperationCategoryEnum.Production]: "Üretim",
    [OperationCategoryEnum.Assembly]: "Montaj",
    [OperationCategoryEnum.Inspection]: "Kalite Kontrolü",
    [OperationCategoryEnum.Packaging]: "Paketleme",
    [OperationCategoryEnum.Setup]: "Hazırlık",
    [OperationCategoryEnum.Maintenance]: "Bakım",
    [OperationCategoryEnum.Transport]: "Taşıma",
    [OperationCategoryEnum.Quality]: "Kalite",
  };
  return types[type];
};

export const getOperationTypeColor = (type: OperationCategoryEnum) => {
  const colors = {
    [OperationCategoryEnum.Production]: "bg-blue-100 text-blue-800",
    [OperationCategoryEnum.Assembly]: "bg-green-100 text-green-800",
    [OperationCategoryEnum.Inspection]: "bg-purple-100 text-purple-800",
    [OperationCategoryEnum.Packaging]: "bg-orange-100 text-orange-800",
    [OperationCategoryEnum.Setup]: "bg-yellow-100 text-yellow-800",
    [OperationCategoryEnum.Maintenance]: "bg-red-100 text-red-800",
    [OperationCategoryEnum.Transport]: "bg-indigo-100 text-indigo-800",
    [OperationCategoryEnum.Quality]: "bg-pink-100 text-pink-800",
  };
  return colors[type];
};

export const getOperationCategoryColor = (category: string) => {
  const colors: { [key: string]: string } = {
    Üretim: "bg-blue-100 text-blue-800",
    Montaj: "bg-green-100 text-green-800",
    Kalite: "bg-purple-100 text-purple-800",
    Paketleme: "bg-orange-100 text-orange-800",
    Bakım: "bg-red-100 text-red-800",
  };
  return colors[category] || "bg-gray-100 text-gray-800";
};

export const getSkillLevelText = (level: number) => {
  const levels = ["Başlangıç", "Temel", "Orta", "İleri", "Uzman"];
  return levels[level - 1] || "Belirsiz";
};

export const getWarehouseTypeText = (type: WarehouseTypeEnum) => {
  const types = {
    [WarehouseTypeEnum.RawMaterials]: "Hammadde",
    [WarehouseTypeEnum.FinishedGoods]: "Mamul",
    [WarehouseTypeEnum.WorkInProgress]: "Ara Ürün",
    [WarehouseTypeEnum.Quarantine]: "Karantina",
    [WarehouseTypeEnum.Returns]: "İade",
    [WarehouseTypeEnum.Transit]: "Transit",
    [WarehouseTypeEnum.SpareParts]: "Parçalı",
  };
  return types[type];
};

export const getWarehouseTypeColor = (type: WarehouseTypeEnum) => {
  const colors = {
    [WarehouseTypeEnum.RawMaterials]: "bg-blue-100 text-blue-800",
    [WarehouseTypeEnum.FinishedGoods]: "bg-green-100 text-green-800",
    [WarehouseTypeEnum.WorkInProgress]: "bg-yellow-100 text-yellow-800",
    [WarehouseTypeEnum.SpareParts]: "bg-purple-100 text-purple-800",
    [WarehouseTypeEnum.Quarantine]: "bg-red-100 text-red-800",
    [WarehouseTypeEnum.Returns]: "bg-pink-100 text-pink-800",
    [WarehouseTypeEnum.Transit]: "bg-indigo-100 text-indigo-800",
  };
  return colors[type];
};

export const getSecurityLevelText = (level: SecurityLevelEnum) => {
  const levels = {
    [SecurityLevelEnum.Low]: "Düşük",
    [SecurityLevelEnum.Medium]: "Orta",
    [SecurityLevelEnum.High]: "Yüksek",
    [SecurityLevelEnum.Restricted]: "Kısıtlı",
  };
  return levels[level];
};

export const getSecurityLevelColor = (level: SecurityLevelEnum) => {
  const colors = {
    [SecurityLevelEnum.Low]: "text-green-600",
    [SecurityLevelEnum.Medium]: "text-yellow-600",
    [SecurityLevelEnum.High]: "text-orange-600",
    [SecurityLevelEnum.Restricted]: "text-red-600",
  };
  return colors[level];
};

export const getRoutingStatusText = (status: RoutingStatusEnum) => {
  const statuses = {
    [RoutingStatusEnum.Draft]: "Taslak",
    [RoutingStatusEnum.Active]: "Aktif",
    [RoutingStatusEnum.Inactive]: "Pasif",
    [RoutingStatusEnum.Obsolete]: "Eski Sürüm",
  };
  return statuses[status];
};

export const getRoutingStatusColor = (status: RoutingStatusEnum) => {
  const colors = {
    [RoutingStatusEnum.Draft]: "bg-yellow-100 text-yellow-800",
    [RoutingStatusEnum.Active]: "bg-green-100 text-green-800",
    [RoutingStatusEnum.Inactive]: "bg-gray-100 text-gray-800",
    [RoutingStatusEnum.Obsolete]: "bg-red-100 text-red-800",
  };
  return colors[status];
};

export const getRequestTypeText = (type: RequestTypeEnum) => {
  const types = {
    [RequestTypeEnum.Material]: "Malzeme",
    [RequestTypeEnum.Service]: "Hizmet",
    [RequestTypeEnum.WorkCenter]: "İş Merkezi",
    [RequestTypeEnum.Maintenance]: "Bakım",
  };
  return types[type];
};

export const getRequestTypeColor = (type: RequestTypeEnum) => {
  const colors = {
    [RequestTypeEnum.Material]: "bg-blue-100 text-blue-800",
    [RequestTypeEnum.Service]: "bg-green-100 text-green-800",
    [RequestTypeEnum.WorkCenter]: "bg-purple-100 text-purple-800",
    [RequestTypeEnum.Maintenance]: "bg-orange-100 text-orange-800",
  };
  return colors[type];
};

export const getApprovalLevelText = (level: ApprovalLevelEnum) => {
  const levels = {
    [ApprovalLevelEnum.Supervisor]: "Süpervizör",
    [ApprovalLevelEnum.Manager]: "Yönetici",
    [ApprovalLevelEnum.Director]: "Direktör",
    [ApprovalLevelEnum.GeneralManager]: "Genel Müdür",
    [ApprovalLevelEnum.FinanceManager]: "Mali İşler Müdürü",
    [ApprovalLevelEnum.TechnicalManager]: "Teknik Müdür",
  };
  return levels[level];
};

export const getApprovalLevelColor = (level: ApprovalLevelEnum) => {
  const colors = {
    [ApprovalLevelEnum.Supervisor]: "bg-gray-100 text-gray-800",
    [ApprovalLevelEnum.Manager]: "bg-blue-100 text-blue-800",
    [ApprovalLevelEnum.Director]: "bg-purple-100 text-purple-800",
    [ApprovalLevelEnum.GeneralManager]: "bg-red-100 text-red-800",
    [ApprovalLevelEnum.FinanceManager]: "bg-green-100 text-green-800",
    [ApprovalLevelEnum.TechnicalManager]: "bg-orange-100 text-orange-800",
  };
  return colors[level];
};

export const getDeliveryStatusText = (status: DeliveryStatusEnum) => {
  const statuses = {
    [DeliveryStatusEnum.Preparing]: "Hazırlanıyor",
    [DeliveryStatusEnum.Shipped]: "Kargoya Verildi",
    [DeliveryStatusEnum.InTransit]: "Yolda",
    [DeliveryStatusEnum.OutForDelivery]: "Dağıtımda",
    [DeliveryStatusEnum.Delivered]: "Teslim Edildi",
    [DeliveryStatusEnum.PartiallyDelivered]: "Kısmi Teslim",
    [DeliveryStatusEnum.Delayed]: "Gecikmeli",
    [DeliveryStatusEnum.Returned]: "İade Edildi",
    [DeliveryStatusEnum.Cancelled]: "İptal Edildi",
  };
  return statuses[status];
};

export const getPriorityText = (priority: PriorityEnum) => {
  const priorities = {
    [PriorityEnum.Low]: "Düşük",
    [PriorityEnum.Normal]: "Normal",
    [PriorityEnum.High]: "Yüksek",
    [PriorityEnum.Urgent]: "Acil",
  };
  return priorities[priority];
};

export const getPriorityColor = (priority: PriorityEnum) => {
  const colors = {
    [PriorityEnum.Low]: "bg-emerald-50 text-emerald-700 border-emerald-200",
    [PriorityEnum.Normal]: "bg-blue-50 text-blue-700 border-blue-200",
    [PriorityEnum.High]: "bg-orange-50 text-orange-700 border-orange-200",
    [PriorityEnum.Urgent]: "bg-red-50 text-red-700 border-red-200",
  };
  return colors[priority];
};

export const getWaybillStatusColor = (status: WaybillStatusEnum) => {
  switch (status) {
    case WaybillStatusEnum.Draft:
      return "bg-gray-100 text-gray-800";
    case WaybillStatusEnum.Confirmed:
      return "bg-blue-100 text-blue-800";
    case WaybillStatusEnum.Delivered:
      return "bg-green-100 text-green-800";
    case WaybillStatusEnum.Cancelled:
      return "bg-red-100 text-red-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getWaybillStatusText = (status: WaybillStatusEnum) => {
  switch (status) {
    case WaybillStatusEnum.Draft:
      return "Taslak";
    case WaybillStatusEnum.Confirmed:
      return "Onaylandı";
    case WaybillStatusEnum.Delivered:
      return "Teslim Edildi";
    case WaybillStatusEnum.Cancelled:
      return "İptal";
    default:
      return "Bilinmiyor";
  }
};

export const getWaybillTypeText = (type: WaybillTypeEnum) => {
  switch (type) {
    case WaybillTypeEnum.Outgoing:
      return "Çıkış İrsaliyesi";
    case WaybillTypeEnum.Incoming:
      return "Giriş İrsaliyesi";
    case WaybillTypeEnum.Transfer:
      return "Transfer İrsaliyesi";
    case WaybillTypeEnum.Return:
      return "İade İrsaliyesi";
    default:
      return "Bilinmiyor";
  }
};

export const getBusinessPartyStatusColor = (
  status: BusinessPartyStatusEnum
) => {
  switch (status) {
    case BusinessPartyStatusEnum.Prospect:
      return "bg-blue-100 text-blue-800 border-blue-200";
    case BusinessPartyStatusEnum.Active:
      return "bg-green-100 text-green-800 border-green-200";
    case BusinessPartyStatusEnum.Inactive:
      return "bg-gray-100 text-gray-800 border-gray-200";
    case BusinessPartyStatusEnum.Blocked:
      return "bg-red-100 text-red-800 border-red-200";
    default:
      return "bg-gray-100 text-gray-800 border-gray-200";
  }
};

export const getBusinessPartyStatusName = (status: BusinessPartyStatusEnum) => {
  switch (status) {
    case BusinessPartyStatusEnum.Prospect:
      return "Potansiyel";
    case BusinessPartyStatusEnum.Active:
      return "Aktif";
    case BusinessPartyStatusEnum.Inactive:
      return "Pasif";
    case BusinessPartyStatusEnum.Blocked:
      return "Blokeli";
    default:
      return "Bilinmiyor";
  }
};

export const getCustomerSegmentColor = (segment: CustomerSegmentEnum) => {
  switch (segment) {
    case CustomerSegmentEnum.Enterprise:
      return "text-purple-600";
    case CustomerSegmentEnum.SMB:
      return "text-blue-600";
    case CustomerSegmentEnum.Startup:
      return "text-green-600";
    case CustomerSegmentEnum.Government:
      return "text-orange-600";
    default:
      return "text-gray-600";
  }
};

export const getCustomerSegmentName = (segment: CustomerSegmentEnum) => {
  switch (segment) {
    case CustomerSegmentEnum.Enterprise:
      return "Kurumsal";
    case CustomerSegmentEnum.SMB:
      return "KOBİ";
    case CustomerSegmentEnum.Startup:
      return "Girişim";
    case CustomerSegmentEnum.Government:
      return "Kamu";
    default:
      return "Diğer";
  }
};

export const getLostReasonCategoryText = (category: LostReasonCategoryEnum) => {
  const categoryLabels = {
    [LostReasonCategoryEnum.Price]: "Fiyat",
    [LostReasonCategoryEnum.Product]: "Ürün",
    [LostReasonCategoryEnum.Service]: "Hizmet",
    [LostReasonCategoryEnum.Competitor]: "Rekabet",
    [LostReasonCategoryEnum.Timing]: "Zamanlama",
    [LostReasonCategoryEnum.Budget]: "Bütçe",
  };
  return categoryLabels[category];
};

export const getLostReasonCategoryColor = (
  category: LostReasonCategoryEnum
) => {
  const categoryColors = {
    [LostReasonCategoryEnum.Price]: "bg-red-100 text-red-800",
    [LostReasonCategoryEnum.Product]: "bg-blue-100 text-blue-800",
    [LostReasonCategoryEnum.Service]: "bg-green-100 text-green-800",
    [LostReasonCategoryEnum.Competitor]: "bg-purple-100 text-purple-800",
    [LostReasonCategoryEnum.Timing]: "bg-yellow-100 text-yellow-800",
    [LostReasonCategoryEnum.Budget]: "bg-orange-100 text-orange-800",
  };
  return categoryColors[category];
};

export const getActivityTypeText = (type: CrmActivityTypeEnum) => {
  const typeLabels = {
    [CrmActivityTypeEnum.Call]: "Telefon Görüşmesi",
    [CrmActivityTypeEnum.Email]: "E-posta",
    [CrmActivityTypeEnum.Meeting]: "Toplantı",
    [CrmActivityTypeEnum.Task]: "Görev",
    [CrmActivityTypeEnum.Note]: "Not",
    [CrmActivityTypeEnum.Demo]: "Demo",
    [CrmActivityTypeEnum.Proposal]: "Teklif",
  };
  return typeLabels[type];
};

export const getActivityTypeIcon = (type: CrmActivityTypeEnum) => {
  const typeIcons = {
    [CrmActivityTypeEnum.Call]: FaPhone,
    [CrmActivityTypeEnum.Email]: FaEnvelope,
    [CrmActivityTypeEnum.Meeting]: FaUsers,
    [CrmActivityTypeEnum.Task]: FaClock,
    [CrmActivityTypeEnum.Note]: FaEdit,
    [CrmActivityTypeEnum.Demo]: FaUsers,
    [CrmActivityTypeEnum.Proposal]: FaFileAlt,
  };
  return typeIcons[type];
};

export const getActivityStatusText = (status: ActivityStatusEnum) => {
  const statusLabels = {
    [ActivityStatusEnum.Planned]: "Planlandı",
    [ActivityStatusEnum.InProgress]: "Devam Ediyor",
    [ActivityStatusEnum.Completed]: "Tamamlandı",
    [ActivityStatusEnum.Cancelled]: "İptal Edildi",
  };
  return statusLabels[status];
};

export const getActivityStatusColor = (status: ActivityStatusEnum) => {
  const statusColors = {
    [ActivityStatusEnum.Planned]: "bg-blue-100 text-blue-800 border-blue-200",
    [ActivityStatusEnum.InProgress]:
      "bg-yellow-100 text-yellow-800 border-yellow-200",
    [ActivityStatusEnum.Completed]:
      "bg-green-100 text-green-800 border-green-200",
    [ActivityStatusEnum.Cancelled]: "bg-red-100 text-red-800 border-red-200",
  };
  return statusColors[status];
};

export const getOpportunityStageText = (stage: OpportunityStageEnum) => {
  const stageLabels = {
    [OpportunityStageEnum.Qualification]: "Nitelendirme",
    [OpportunityStageEnum.NeedsAnalysis]: "İhtiyaç Analizi",
    [OpportunityStageEnum.Proposal]: "Teklif",
    [OpportunityStageEnum.Negotiation]: "Müzakere",
    [OpportunityStageEnum.ClosedWon]: "Kazanıldı",
    [OpportunityStageEnum.ClosedLost]: "Kaybedildi",
  };
  return stageLabels[stage];
};

export const getOpportunityStageColor = (stage: OpportunityStageEnum) => {
  const stageColors = {
    [OpportunityStageEnum.Qualification]:
      "bg-gray-100 text-gray-800 border-gray-200",
    [OpportunityStageEnum.NeedsAnalysis]:
      "bg-blue-100 text-blue-800 border-blue-200",
    [OpportunityStageEnum.Proposal]:
      "bg-yellow-100 text-yellow-800 border-yellow-200",
    [OpportunityStageEnum.Negotiation]:
      "bg-orange-100 text-orange-800 border-orange-200",
    [OpportunityStageEnum.ClosedWon]:
      "bg-green-100 text-green-800 border-green-200",
    [OpportunityStageEnum.ClosedLost]: "bg-red-100 text-red-800 border-red-200",
  };
  return stageColors[stage];
};

export const getOpportunityProbabilityColor = (probability: number) => {
  if (probability >= 80) return "text-green-600";
  if (probability >= 60) return "text-yellow-600";
  if (probability >= 40) return "text-orange-600";
  return "text-red-600";
};

export const getOpportunityLeadSourceText = (source: string) => {
  const sourceLabels: Record<string, string> = {
    WEBSITE: "Web Sitesi",
    REFERRAL: "Referans",
    CAMPAIGN: "Kampanya",
    TRADE_SHOW: "Fuar",
    COLD_CALL: "Soğuk Arama",
    SOCIAL_MEDIA: "Sosyal Medya",
    PARTNER: "Partner",
  };
  return sourceLabels[source] || source;
};

export const getSaleOrderStatusText = (status: SaleOrderStatusEnum) => {
  const statusLabels = {
    [SaleOrderStatusEnum.Draft]: "Taslak",
    [SaleOrderStatusEnum.Confirmed]: "Onaylandı",
    [SaleOrderStatusEnum.InProduction]: "Üretimde",
    [SaleOrderStatusEnum.Ready]: "Hazır",
    [SaleOrderStatusEnum.Shipped]: "Kargoda",
    [SaleOrderStatusEnum.Delivered]: "Teslim Edildi",
    [SaleOrderStatusEnum.Cancelled]: "İptal Edildi",
  };
  return statusLabels[status];
};

export const getSaleOrderStatusColor = (status: SaleOrderStatusEnum) => {
  const statusColors = {
    [SaleOrderStatusEnum.Draft]: "bg-gray-100 text-gray-800",
    [SaleOrderStatusEnum.Confirmed]: "bg-blue-100 text-blue-800",
    [SaleOrderStatusEnum.InProduction]: "bg-yellow-100 text-yellow-800",
    [SaleOrderStatusEnum.Ready]: "bg-orange-100 text-orange-800",
    [SaleOrderStatusEnum.Shipped]: "bg-purple-100 text-purple-800",
    [SaleOrderStatusEnum.Delivered]: "bg-green-100 text-green-800",
    [SaleOrderStatusEnum.Cancelled]: "bg-red-100 text-red-800",
  };
  return statusColors[status];
};

export const getSaleOrderItemStatusnfo = (status: SaleOrderItemStatusEnum) => {
  const statusInfo = {
    [SaleOrderItemStatusEnum.Pending]: {
      label: "Beklemede",
      color: "bg-gray-100 text-gray-800",
      icon: FaClock,
      iconColor: "text-gray-500",
    },
    [SaleOrderItemStatusEnum.Confirmed]: {
      label: "Onaylandı",
      color: "bg-blue-100 text-blue-800",
      icon: FaCheckCircle,
      iconColor: "text-blue-500",
    },
    [SaleOrderItemStatusEnum.InProduction]: {
      label: "Üretimde",
      color: "bg-yellow-100 text-yellow-800",
      icon: FaClock,
      iconColor: "text-yellow-500",
    },
    [SaleOrderItemStatusEnum.Ready]: {
      label: "Hazır",
      color: "bg-orange-100 text-orange-800",
      icon: FaCheckCircle,
      iconColor: "text-orange-500",
    },
    [SaleOrderItemStatusEnum.Shipped]: {
      label: "Kargoda",
      color: "bg-purple-100 text-purple-800",
      icon: FaTruck,
      iconColor: "text-purple-500",
    },
    [SaleOrderItemStatusEnum.Delivered]: {
      label: "Teslim Edildi",
      color: "bg-green-100 text-green-800",
      icon: FaCheckCircle,
      iconColor: "text-green-500",
    },
  };
  return statusInfo[status];
};

export const getBankAccountTypeText = (type: BankAccountTypeEnum) => {
  const typeLabels = {
    [BankAccountTypeEnum.Current]: "Vadesiz",
    [BankAccountTypeEnum.Deposit]: "Vadeli",
    [BankAccountTypeEnum.Credit]: "Kredi",
    [BankAccountTypeEnum.Foreign]: "Döviz",
  };
  return typeLabels[type];
};

export const getBankAccountTypeColor = (type: BankAccountTypeEnum) => {
  const typeColors = {
    [BankAccountTypeEnum.Current]: "bg-blue-100 text-blue-800",
    [BankAccountTypeEnum.Deposit]: "bg-green-100 text-green-800",
    [BankAccountTypeEnum.Credit]: "bg-orange-100 text-orange-800",
    [BankAccountTypeEnum.Foreign]: "bg-purple-100 text-purple-800",
  };
  return typeColors[type];
};

export const getTransactionTypeText = (type: BankTransactionTypeEnum) => {
  const typeLabels = {
    [BankTransactionTypeEnum.Deposit]: "Para Yatırma",
    [BankTransactionTypeEnum.Withdrawal]: "Para Çekme",
    [BankTransactionTypeEnum.Transfer]: "Transfer",
    [BankTransactionTypeEnum.EFT]: "EFT/Havale",
    [BankTransactionTypeEnum.Fee]: "Komisyon",
    [BankTransactionTypeEnum.Interest]: "Faiz",
  };
  return typeLabels[type];
};

export const getTransactionStatusText = (status: TransactionStatusEnum) => {
  const statusLabels = {
    [TransactionStatusEnum.Pending]: "Bekliyor",
    [TransactionStatusEnum.Completed]: "Tamamlandı",
    [TransactionStatusEnum.Failed]: "Başarısız",
    [TransactionStatusEnum.Cancelled]: "İptal",
  };
  return statusLabels[status];
};

export const getTransactionTypeColor = (type: BankTransactionTypeEnum) => {
  const typeColors = {
    [BankTransactionTypeEnum.Deposit]: "bg-green-100 text-green-800",
    [BankTransactionTypeEnum.Withdrawal]: "bg-red-100 text-red-800",
    [BankTransactionTypeEnum.Transfer]: "bg-blue-100 text-blue-800",
    [BankTransactionTypeEnum.EFT]: "bg-purple-100 text-purple-800",
    [BankTransactionTypeEnum.Fee]: "bg-orange-100 text-orange-800",
    [BankTransactionTypeEnum.Interest]: "bg-yellow-100 text-yellow-800",
  };
  return typeColors[type];
};

export const getTransactionStatusColor = (status: TransactionStatusEnum) => {
  const statusColors = {
    [TransactionStatusEnum.Pending]: "bg-yellow-100 text-yellow-800",
    [TransactionStatusEnum.Completed]: "bg-green-100 text-green-800",
    [TransactionStatusEnum.Failed]: "bg-red-100 text-red-800",
    [TransactionStatusEnum.Cancelled]: "bg-gray-100 text-gray-800",
  };
  return statusColors[status];
};

export const getFiDocumentTypeText = (type?: FiDocumentTypeEnum) => {
  if (!type) return "";
  const typeLabels = {
    [FiDocumentTypeEnum.Invoice]: "Fatura",
    [FiDocumentTypeEnum.Waybill]: "İrsaliye",
    [FiDocumentTypeEnum.Receipt]: "Makbuz",
    [FiDocumentTypeEnum.Payment]: "Ödeme",
    [FiDocumentTypeEnum.BankTransfer]: "Banka Havalesi",
    [FiDocumentTypeEnum.CashMovement]: "Kasa Hareketi",
    [FiDocumentTypeEnum.Check]: "Çek",
    [FiDocumentTypeEnum.PromissoryNote]: "Senet",
    [FiDocumentTypeEnum.Other]: "Diğer",
  };
  return typeLabels[type];
};

export const getFiDocumentTypeColor = (type: FiDocumentTypeEnum) => {
  const typeColors = {
    [FiDocumentTypeEnum.Invoice]: "bg-blue-100 text-blue-800",
    [FiDocumentTypeEnum.Payment]: "bg-green-100 text-green-800",
    [FiDocumentTypeEnum.Receipt]: "bg-purple-100 text-purple-800",
    [FiDocumentTypeEnum.Check]: "bg-yellow-100 text-yellow-800",
    [FiDocumentTypeEnum.BankTransfer]: "bg-indigo-100 text-indigo-800",
    [FiDocumentTypeEnum.CashMovement]: "bg-orange-100 text-orange-800",
    [FiDocumentTypeEnum.Waybill]: "bg-gray-100 text-gray-800",
    [FiDocumentTypeEnum.PromissoryNote]: "bg-red-100 text-red-800",
    [FiDocumentTypeEnum.Other]: "bg-gray-100 text-gray-800",
  };
  return typeColors[type];
};

export const getCashMovementTypeText = (type: CashMovementTypeEnum) => {
  return type === CashMovementTypeEnum.Income ? "Giriş" : "Çıkış";
};

export const getCashMovementTypeColor = (type: CashMovementTypeEnum) => {
  return type === CashMovementTypeEnum.Income
    ? "bg-green-100 text-green-800"
    : "bg-red-100 text-red-800";
};

export const getAccountTypeText = (type: AccountTypeEnum) => {
  const typeLabels = {
    [AccountTypeEnum.Customer]: "Müşteri",
    [AccountTypeEnum.Supplier]: "Tedarikçi",
    [AccountTypeEnum.Both]: "Müşteri/Tedarikçi",
    [AccountTypeEnum.Other]: "Diğer",
  };
  return typeLabels[type];
};

export const getAccountTypeColor = (type: AccountTypeEnum) => {
  const typeColors = {
    [AccountTypeEnum.Customer]: "bg-blue-100 text-blue-800",
    [AccountTypeEnum.Supplier]: "bg-green-100 text-green-800",
    [AccountTypeEnum.Both]: "bg-purple-100 text-purple-800",
    [AccountTypeEnum.Other]: "bg-gray-100 text-gray-800",
  };
  return typeColors[type];
};

export const getRiskGroupText = (riskGroup: RiskGroupEnum) => {
  const riskLabels = {
    [RiskGroupEnum.Low]: "Düşük Risk",
    [RiskGroupEnum.Medium]: "Orta Risk",
    [RiskGroupEnum.High]: "Yüksek Risk",
    [RiskGroupEnum.Blocked]: "Blokeli",
  };
  return riskLabels[riskGroup];
};

export const getRiskGroupColor = (riskGroup: RiskGroupEnum) => {
  const riskColors = {
    [RiskGroupEnum.Low]: "bg-green-100 text-green-800",
    [RiskGroupEnum.Medium]: "bg-yellow-100 text-yellow-800",
    [RiskGroupEnum.High]: "bg-orange-100 text-orange-800",
    [RiskGroupEnum.Blocked]: "bg-red-100 text-red-800",
  };
  return riskColors[riskGroup];
};

export const getInvoiceTypeText = (type: InvoiceTypeEnum) => {
  const typeLabels = {
    [InvoiceTypeEnum.Sales]: "Satış",
    [InvoiceTypeEnum.Purchase]: "Alış",
    [InvoiceTypeEnum.Return]: "İade",
    [InvoiceTypeEnum.Proforma]: "Proforma",
  };
  return typeLabels[type];
};

export const getInvoiceTypeColor = (type: InvoiceTypeEnum) => {
  const typeColors = {
    [InvoiceTypeEnum.Sales]: "bg-green-100 text-green-800",
    [InvoiceTypeEnum.Purchase]: "bg-blue-100 text-blue-800",
    [InvoiceTypeEnum.Return]: "bg-orange-100 text-orange-800",
    [InvoiceTypeEnum.Proforma]: "bg-purple-100 text-purple-800",
  };
  return typeColors[type];
};

export const getInvoiceStatusText = (status: InvoiceStatusEnum) => {
  const statusLabels = {
    [InvoiceStatusEnum.Draft]: "Taslak",
    [InvoiceStatusEnum.Sent]: "Gönderildi",
    [InvoiceStatusEnum.Approved]: "Onaylandı",
    [InvoiceStatusEnum.Cancelled]: "İptal",
  };
  return statusLabels[status];
};

export const getInvoiceStatusColor = (status: InvoiceStatusEnum) => {
  const statusColors = {
    [InvoiceStatusEnum.Draft]: "bg-gray-100 text-gray-800",
    [InvoiceStatusEnum.Sent]: "bg-blue-100 text-blue-800",
    [InvoiceStatusEnum.Approved]: "bg-green-100 text-green-800",
    [InvoiceStatusEnum.Cancelled]: "bg-red-100 text-red-800",
  };
  return statusColors[status];
};

export const getPaymentStatusText = (status: PaymentStatusEnum) => {
  const statusLabels = {
    [PaymentStatusEnum.Unpaid]: "Ödenmemiş",
    [PaymentStatusEnum.PartiallyPaid]: "Kısmi Ödeme",
    [PaymentStatusEnum.Paid]: "Ödenmiş",
    [PaymentStatusEnum.Overdue]: "Vadesi Geçmiş",
  };
  return statusLabels[status];
};

export const getPaymentStatusColor = (status: PaymentStatusEnum) => {
  const statusColors = {
    [PaymentStatusEnum.Unpaid]: "bg-yellow-100 text-yellow-800",
    [PaymentStatusEnum.PartiallyPaid]: "bg-orange-100 text-orange-800",
    [PaymentStatusEnum.Paid]: "bg-green-100 text-green-800",
    [PaymentStatusEnum.Overdue]: "bg-red-100 text-red-800",
  };
  return statusColors[status];
};

export const getPaymentMethodText = (method: PaymentMethodEnum) => {
  const labels = {
    [PaymentMethodEnum.Cash]: "Nakit",
    [PaymentMethodEnum.BankTransfer]: "Banka Havalesi",
    [PaymentMethodEnum.CreditCard]: "Kredi Kartı",
    [PaymentMethodEnum.Check]: "Çek",
    [PaymentMethodEnum.PromissoryNote]: "Senet",
  };
  return labels[method];
};

export const getWaybillTypeColor = (type: WaybillTypeEnum) => {
  const typeColors = {
    [WaybillTypeEnum.Outgoing]: "bg-green-100 text-green-800",
    [WaybillTypeEnum.Incoming]: "bg-blue-100 text-blue-800",
    [WaybillTypeEnum.Transfer]: "bg-purple-100 text-purple-800",
    [WaybillTypeEnum.Return]: "bg-orange-100 text-orange-800",
  };
  return typeColors[type];
};

export const iconOptions = [
  { value: "⭐", label: "Yıldız" },
  { value: "🏆", label: "Kupa" },
  { value: "🥇", label: "Altın Madalya" },
  { value: "🥈", label: "Gümüş Madalya" },
  { value: "🥉", label: "Bronz Madalya" },
  { value: "👑", label: "Taç" },
  { value: "💎", label: "Elmas" },
  { value: "💡", label: "Ampul" },
  { value: "🔥", label: "Ateş" },
  { value: "⚡", label: "Şimşek" },
  { value: "🎯", label: "Hedef" },
  { value: "📈", label: "Grafik" },
  { value: "🚀", label: "Roket" },
  { value: "💪", label: "Güç" },
  { value: "❤️", label: "Kalp" },
];

export const getIconComponent = (iconName: string) => {
  switch (iconName) {
    case "star":
      return FaStar;
    case "trophy":
      return FaTrophy;
    case "medal":
      return FaMedal;
    case "award":
    default:
      return FaAward;
  }
};

export const getCostCenterTypeText = (type: CostCenterType): string => {
  const typeMap = {
    [CostCenterType.Revenue]: "Gelir",
    [CostCenterType.Standard]: "Standart",
    [CostCenterType.Discretionary]: "İsteğe Bağlı",
    [CostCenterType.Investment]: "Yatırım",
    [CostCenterType.Service]: "Hizmet",
    [CostCenterType.Production]: "Üretim",
    [CostCenterType.Support]: "Destek",
    [CostCenterType.Administrative]: "İdari",
  };
  return typeMap[type] || type;
};

export const getCostCenterTypeColor = (type: CostCenterType): string => {
  const colorMap = {
    [CostCenterType.Revenue]: "bg-green-100 text-green-800",
    [CostCenterType.Standard]: "bg-blue-100 text-blue-800",
    [CostCenterType.Discretionary]: "bg-purple-100 text-purple-800",
    [CostCenterType.Investment]: "bg-orange-100 text-orange-800",
    [CostCenterType.Service]: "bg-indigo-100 text-indigo-800",
    [CostCenterType.Production]: "bg-red-100 text-red-800",
    [CostCenterType.Support]: "bg-yellow-100 text-yellow-800",
    [CostCenterType.Administrative]: "bg-gray-100 text-gray-800",
  };
  return colorMap[type] || "bg-gray-100 text-gray-800";
};

export const getCampaignStatusColor = (status: CampaignStatusEnum) => {
  switch (status) {
    case CampaignStatusEnum.Draft:
      return "bg-gray-100 text-gray-800";
    case CampaignStatusEnum.Active:
      return "bg-green-100 text-green-800";
    case CampaignStatusEnum.Completed:
      return "bg-blue-100 text-blue-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getCampaignStatusText = (status: CampaignStatusEnum) => {
  switch (status) {
    case CampaignStatusEnum.Draft:
      return "Taslak";
    case CampaignStatusEnum.Active:
      return "Aktif";
    case CampaignStatusEnum.Completed:
      return "Tamamlandı";
    default:
      return "Bilinmiyor";
  }
};

export const getAssessorTypeText = (type: AssessorTypeEnum) => {
  switch (type) {
    case AssessorTypeEnum.Self:
      return "Kendi";
    case AssessorTypeEnum.Manager:
      return "Yönetici";
    case AssessorTypeEnum.Peer:
      return "Meslektaş";
    case AssessorTypeEnum.Subordinate:
      return "Ast";
    case AssessorTypeEnum.Customer:
      return "Müşteri";
    case AssessorTypeEnum.OtherDepartment:
      return "Diğer Departman";
    case AssessorTypeEnum.HRUpperManagement:
      return "İK/Üst Yönetim";
    case AssessorTypeEnum.External:
      return "Dış Paydaş";
    default:
      return "Bilinmiyor";
  }
};

export const getAssessorTypeDescription = (type: AssessorTypeEnum) => {
  switch (type) {
    case AssessorTypeEnum.Self:
      return "Sadece kendisi";
    case AssessorTypeEnum.Manager:
      return "Sadece çalıştığı departmanın müdürü";
    case AssessorTypeEnum.Peer:
      return "Sadece aynı departmanda çalıştığı eşit düzeydeki çalışanlar";
    case AssessorTypeEnum.Subordinate:
      return "Aynı departmanda ama düzeyi değerlendirilen kişinin altında olan";
    case AssessorTypeEnum.Customer:
      return "Sistemde kayıtlı müşterilerden seçilecek";
    case AssessorTypeEnum.External:
      return "Sistemde kayıtlı olmayan harici değerlendirici";
    case AssessorTypeEnum.HRUpperManagement:
      return "Sadece İK departmanında bir kişi seçilmeli";
    case AssessorTypeEnum.OtherDepartment:
      return "Değerlendirilen kişinin çalıştığı departman dışında kalan tüm departman çalışanları";
    default:
      return "";
  }
};

export const getParticipantStatusColor = (status: ParticipantStatusEnum) => {
  switch (status) {
    case ParticipantStatusEnum.Invited:
      return "bg-yellow-100 text-yellow-800";
    case ParticipantStatusEnum.Started:
      return "bg-blue-100 text-blue-800";
    case ParticipantStatusEnum.Completed:
      return "bg-green-100 text-green-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getParticipantStatusText = (status: ParticipantStatusEnum) => {
  switch (status) {
    case ParticipantStatusEnum.Invited:
      return "Davet Edildi";
    case ParticipantStatusEnum.Started:
      return "Başladı";
    case ParticipantStatusEnum.Completed:
      return "Tamamlandı";
    default:
      return "Bilinmiyor";
  }
};

export const getEmployeeStatusColor = (status: EmployeeStatusEnum) => {
  switch (status) {
    case EmployeeStatusEnum.Active:
      return "bg-green-100 text-green-800";
    case EmployeeStatusEnum.Inactive:
      return "bg-gray-100 text-gray-800";
    case EmployeeStatusEnum.OnLeave:
      return "bg-yellow-100 text-yellow-800";
    case EmployeeStatusEnum.Suspended:
      return "bg-red-100 text-red-800";
    case EmployeeStatusEnum.Terminated:
      return "bg-red-100 text-red-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getEmployeeStatusText = (status: EmployeeStatusEnum) => {
  switch (status) {
    case EmployeeStatusEnum.Active:
      return "Aktif";
    case EmployeeStatusEnum.Inactive:
      return "Pasif";
    case EmployeeStatusEnum.OnLeave:
      return "İzinli";
    case EmployeeStatusEnum.Suspended:
      return "Askıda";
    case EmployeeStatusEnum.Terminated:
      return "İşten Çıkarılmış";
    default:
      return "Bilinmiyor";
  }
};

export const getEmployeeStatusIcon = (status: EmployeeStatusEnum) => {
  switch (status) {
    case EmployeeStatusEnum.Active:
      return <FaCheckCircle size={14} />;
    case EmployeeStatusEnum.Inactive:
      return <FaClock size={14} />;
    case EmployeeStatusEnum.OnLeave:
      return <FaCalendar size={14} />;
    case EmployeeStatusEnum.Suspended:
      return <FaExclamationTriangle size={14} />;
    case EmployeeStatusEnum.Terminated:
      return <FaExclamationTriangle size={14} />;
    default:
      return <FaUsers size={14} />;
  }
};

export const getEmploymentTypeColor = (type: EmploymentTypeEnum) => {
  switch (type) {
    case EmploymentTypeEnum.FullTime:
      return "text-green-600";
    case EmploymentTypeEnum.PartTime:
      return "text-blue-600";
    case EmploymentTypeEnum.Contract:
      return "text-orange-600";
    case EmploymentTypeEnum.Temporary:
      return "text-yellow-600";
    case EmploymentTypeEnum.Intern:
      return "text-purple-600";
    case EmploymentTypeEnum.Consultant:
      return "text-red-600";
    default:
      return "text-gray-600";
  }
};

export const getEmploymentTypeText = (type: EmploymentTypeEnum) => {
  switch (type) {
    case EmploymentTypeEnum.FullTime:
      return "Tam Zamanlı";
    case EmploymentTypeEnum.PartTime:
      return "Yarı Zamanlı";
    case EmploymentTypeEnum.Contract:
      return "Sözleşmeli";
    case EmploymentTypeEnum.Temporary:
      return "Geçici";
    case EmploymentTypeEnum.Intern:
      return "Stajyer";
    case EmploymentTypeEnum.Consultant:
      return "Danışman";
    default:
      return "Belirtilmemiş";
  }
};

export const getJobLevelText = (level: JobLevelEnum) => {
  switch (level) {
    case JobLevelEnum.Entry:
      return "Giriş Seviyesi";
    case JobLevelEnum.Junior:
      return "Junior";
    case JobLevelEnum.Mid:
      return "Orta Seviye";
    case JobLevelEnum.Senior:
      return "Senior";
    case JobLevelEnum.Lead:
      return "Lider";
    case JobLevelEnum.Manager:
      return "Yönetici";
    case JobLevelEnum.Director:
      return "Direktör";
    case JobLevelEnum.Executive:
      return "Üst Düzey Yönetici";
    default:
      return "Belirlenmemiş";
  }
};

export const getJobLevelColor = (level: JobLevelEnum) => {
  switch (level) {
    case JobLevelEnum.Entry:
      return "bg-gray-100 text-gray-800";
    case JobLevelEnum.Junior:
      return "bg-blue-100 text-blue-800";
    case JobLevelEnum.Mid:
      return "bg-green-100 text-green-800";
    case JobLevelEnum.Senior:
      return "bg-purple-100 text-purple-800";
    case JobLevelEnum.Lead:
      return "bg-orange-100 text-orange-800";
    case JobLevelEnum.Manager:
      return "bg-red-100 text-red-800";
    case JobLevelEnum.Director:
      return "bg-indigo-100 text-indigo-800";
    case JobLevelEnum.Executive:
      return "bg-pink-100 text-pink-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getLeaveStatusColor = (status: LeaveStatusEnum) => {
  switch (status) {
    case LeaveStatusEnum.Pending:
      return "bg-yellow-100 text-yellow-800";
    case LeaveStatusEnum.Approved:
      return "bg-green-100 text-green-800";
    case LeaveStatusEnum.Rejected:
      return "bg-red-100 text-red-800";
    case LeaveStatusEnum.Cancelled:
      return "bg-gray-100 text-gray-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getLeaveStatusText = (status: LeaveStatusEnum) => {
  switch (status) {
    case LeaveStatusEnum.Pending:
      return "Beklemede";
    case LeaveStatusEnum.Approved:
      return "Onaylandı";
    case LeaveStatusEnum.Rejected:
      return "Reddedildi";
    case LeaveStatusEnum.Cancelled:
      return "İptal Edildi";
    default:
      return "Bilinmiyor";
  }
};

export const getLeaveTypeText = (type: LeaveTypeEnum) => {
  switch (type) {
    case LeaveTypeEnum.Annual:
      return "Yıllık İzin";
    case LeaveTypeEnum.Sick:
      return "Hastalık İzni";
    case LeaveTypeEnum.Maternity:
      return "Doğum İzni";
    case LeaveTypeEnum.Paternity:
      return "Babalık İzni";
    case LeaveTypeEnum.Personal:
      return "Kişisel İzin";
    case LeaveTypeEnum.Emergency:
      return "Acil Durum İzni";
    case LeaveTypeEnum.Study:
      return "Eğitim İzni";
    case LeaveTypeEnum.Unpaid:
      return "Ücretsiz İzin";
    default:
      return "Diğer";
  }
};

export const getPayrollStatusColor = (status: PayrollStatusEnum) => {
  switch (status) {
    case PayrollStatusEnum.Draft:
      return "bg-gray-100 text-gray-800";
    case PayrollStatusEnum.Calculated:
      return "bg-blue-100 text-blue-800";
    case PayrollStatusEnum.Approved:
      return "bg-green-100 text-green-800";
    case PayrollStatusEnum.Paid:
      return "bg-purple-100 text-purple-800";
    case PayrollStatusEnum.Cancelled:
      return "bg-red-100 text-red-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getPayrollStatusText = (status: PayrollStatusEnum) => {
  switch (status) {
    case PayrollStatusEnum.Draft:
      return "Taslak";
    case PayrollStatusEnum.Calculated:
      return "Hesaplandı";
    case PayrollStatusEnum.Approved:
      return "Onaylandı";
    case PayrollStatusEnum.Paid:
      return "Ödendi";
    case PayrollStatusEnum.Cancelled:
      return "İptal Edildi";
    default:
      return "Bilinmiyor";
  }
};

export const getNotificationStatusColor = (status: NotificationStatusEnum) => {
  const colors = {
    [NotificationStatusEnum.Open]: "bg-gray-100 text-gray-800",
    [NotificationStatusEnum.Assigned]: "bg-blue-100 text-blue-800",
    [NotificationStatusEnum.InProgress]: "bg-orange-100 text-orange-800",
    [NotificationStatusEnum.Resolved]: "bg-green-100 text-green-800",
    [NotificationStatusEnum.Closed]: "bg-gray-100 text-gray-800",
    [NotificationStatusEnum.Rejected]: "bg-red-100 text-red-800",
  };
  return colors[status];
};

export const getNotificationStatusIcon = (status: NotificationStatusEnum) => {
  const icons = {
    [NotificationStatusEnum.Open]: (
      <FaExclamationTriangle className="w-4 h-4" />
    ),
    [NotificationStatusEnum.Assigned]: <FaUser className="w-4 h-4" />,
    [NotificationStatusEnum.InProgress]: <FaClock className="w-4 h-4" />,
    [NotificationStatusEnum.Resolved]: <FaCheckCircle className="w-4 h-4" />,
    [NotificationStatusEnum.Closed]: <FaTimesCircle className="w-4 h-4" />,
    [NotificationStatusEnum.Rejected]: <FaTimesCircle className="w-4 h-4" />,
  };
  return icons[status];
};

export const getNotificationStatusText = (status: NotificationStatusEnum) => {
  const statuses = {
    [NotificationStatusEnum.Open]: "Açık",
    [NotificationStatusEnum.Assigned]: "Atandı",
    [NotificationStatusEnum.InProgress]: "Devam Ediyor",
    [NotificationStatusEnum.Resolved]: "Çözüldü",
    [NotificationStatusEnum.Closed]: "Kapatıldı",
    [NotificationStatusEnum.Rejected]: "Reddedildi",
  };
  return statuses[status];
};

export const getWorkOrderStatusText = (status: WorkOrderStatusEnum) => {
  const statuses = {
    [WorkOrderStatusEnum.Created]: "Oluşturuldu",
    [WorkOrderStatusEnum.Planned]: "Planlandı",
    [WorkOrderStatusEnum.Released]: "Serbest Bırakıldı",
    [WorkOrderStatusEnum.InProgress]: "Devam Ediyor",
    [WorkOrderStatusEnum.OnHold]: "Beklemede",
    [WorkOrderStatusEnum.Completed]: "Tamamlandı",
    [WorkOrderStatusEnum.Cancelled]: "İptal Edildi",
  };
  return statuses[status];
};

export const getWorkOrderStatusColor = (status: WorkOrderStatusEnum) => {
  const colors = {
    [WorkOrderStatusEnum.Created]: "bg-gray-100 text-gray-800",
    [WorkOrderStatusEnum.Planned]: "bg-blue-100 text-blue-800",
    [WorkOrderStatusEnum.Released]: "bg-purple-100 text-purple-800",
    [WorkOrderStatusEnum.InProgress]: "bg-orange-100 text-orange-800",
    [WorkOrderStatusEnum.OnHold]: "bg-yellow-100 text-yellow-800",
    [WorkOrderStatusEnum.Completed]: "bg-green-100 text-green-800",
    [WorkOrderStatusEnum.Cancelled]: "bg-red-100 text-red-800",
  };
  return colors[status];
};

export const getWorkOrderStatusIcon = (status: WorkOrderStatusEnum) => {
  const icons = {
    [WorkOrderStatusEnum.Created]: null,
    [WorkOrderStatusEnum.Planned]: null,
    [WorkOrderStatusEnum.Released]: null,
    [WorkOrderStatusEnum.InProgress]: <FaCheck className="w-4 h-4" />,
    [WorkOrderStatusEnum.OnHold]: <FaPause className="w-4 h-4" />,
    [WorkOrderStatusEnum.Completed]: <FaCheck className="w-4 h-4" />,
    [WorkOrderStatusEnum.Cancelled]: <FaTimesCircle className="w-4 h-4" />,
  };
  return icons[status];
};

export const getFaultTypeText = (type: FaultTypeEnum) => {
  const types = {
    [FaultTypeEnum.Mechanical]: "Mekanik",
    [FaultTypeEnum.Electrical]: "Elektrik",
    [FaultTypeEnum.Hydraulic]: "Hidrolik",
    [FaultTypeEnum.Pneumatic]: "Pnömatik",
    [FaultTypeEnum.Software]: "Yazılım",
    [FaultTypeEnum.Safety]: "Güvenlik",
    [FaultTypeEnum.Performance]: "Performans",
    [FaultTypeEnum.Other]: "Diğer",
  };
  return types[type];
};

export const getFaultTypeColor = (type: FaultTypeEnum) => {
  const colors = {
    [FaultTypeEnum.Mechanical]: "bg-blue-100 text-blue-800",
    [FaultTypeEnum.Electrical]: "bg-yellow-100 text-yellow-800",
    [FaultTypeEnum.Hydraulic]: "bg-green-100 text-green-800",
    [FaultTypeEnum.Pneumatic]: "bg-purple-100 text-purple-800",
    [FaultTypeEnum.Software]: "bg-indigo-100 text-indigo-800",
    [FaultTypeEnum.Safety]: "bg-red-100 text-red-800",
    [FaultTypeEnum.Performance]: "bg-orange-100 text-orange-800",
    [FaultTypeEnum.Other]: "bg-gray-100 text-gray-800",
  };
  return colors[type];
};

export const getCriticalityLevelColor = (severity: CriticalityLevelEnum) => {
  const colors = {
    [CriticalityLevelEnum.Low]: "border-l-blue-500",
    [CriticalityLevelEnum.Medium]: "border-l-yellow-500",
    [CriticalityLevelEnum.High]: "border-l-orange-500",
    [CriticalityLevelEnum.Critical]: "border-l-red-500",
  };
  return colors[severity];
};

export const getMaintenancePlanTypeText = (type: MaintenancePlanTypeEnum) => {
  const types = {
    [MaintenancePlanTypeEnum.Preventive]: "Önleyici",
    [MaintenancePlanTypeEnum.Corrective]: "Düzeltici",
    [MaintenancePlanTypeEnum.Predictive]: "Tahminsel",
    [MaintenancePlanTypeEnum.Condition]: "Duruma Bağlı",
  };
  return types[type];
};

export const getMaintenancePlanTypeColor = (type: MaintenancePlanTypeEnum) => {
  const colors = {
    [MaintenancePlanTypeEnum.Preventive]: "bg-green-100 text-green-800",
    [MaintenancePlanTypeEnum.Corrective]: "bg-red-100 text-red-800",
    [MaintenancePlanTypeEnum.Predictive]: "bg-blue-100 text-blue-800",
    [MaintenancePlanTypeEnum.Condition]: "bg-yellow-100 text-yellow-800",
  };
  return colors[type];
};

export const getFrequencyUnitText = (
  frequency: number,
  unit: FrequencyUnitEnum
) => {
  const units = {
    [FrequencyUnitEnum.Days]: "Günlük",
    [FrequencyUnitEnum.Weeks]: "Haftalık",
    [FrequencyUnitEnum.Months]: "Aylık",
    [FrequencyUnitEnum.Years]: "Yıllık",
    [FrequencyUnitEnum.Hours]: "Saatlik",
    [FrequencyUnitEnum.Cycles]: "Döngü",
  };

  return frequency === 1 ? units[unit] : `${frequency} ${units[unit]}`;
};

export const getTeamRoleText = (role: TeamRoleEnum) => {
  const roles = {
    [TeamRoleEnum.Member]: "Üye",
    [TeamRoleEnum.Specialist]: "Uzman",
    [TeamRoleEnum.Lead]: "Lider",
    [TeamRoleEnum.Manager]: "Yönetici",
  };
  return roles[role];
};

export const getTeamRoleColor = (role: TeamRoleEnum) => {
  const colors = {
    [TeamRoleEnum.Member]: "bg-blue-100 text-blue-800",
    [TeamRoleEnum.Specialist]: "bg-green-100 text-green-800",
    [TeamRoleEnum.Lead]: "bg-purple-100 text-purple-800",
    [TeamRoleEnum.Manager]: "bg-red-100 text-red-800",
  };
  return colors[role];
};

export const getTeamRoleIcon = (role: TeamRoleEnum) => {
  const icons = {
    [TeamRoleEnum.Member]: <FaUser className="w-3 h-3" />,
    [TeamRoleEnum.Specialist]: <FaStar className="w-3 h-3" />,
    [TeamRoleEnum.Lead]: <FaAward className="w-3 h-3" />,
    [TeamRoleEnum.Manager]: <FaUserTie className="w-3 h-3" />,
  };
  return icons[role];
};

export const getWorkOrderTypeText = (type: WorkOrderTypeEnum) => {
  const types = {
    [WorkOrderTypeEnum.Preventive]: "Önleyici",
    [WorkOrderTypeEnum.Corrective]: "Düzeltici",
    [WorkOrderTypeEnum.Emergency]: "Acil",
    [WorkOrderTypeEnum.Inspection]: "İnceleme",
    [WorkOrderTypeEnum.Calibration]: "Kalibrasyon",
  };
  return types[type];
};

export const getWorkOrderTypeColor = (type: WorkOrderTypeEnum) => {
  const colors = {
    [WorkOrderTypeEnum.Preventive]: "bg-green-100 text-green-800",
    [WorkOrderTypeEnum.Corrective]: "bg-blue-100 text-blue-800",
    [WorkOrderTypeEnum.Emergency]: "bg-red-100 text-red-800",
    [WorkOrderTypeEnum.Inspection]: "bg-purple-100 text-purple-800",
    [WorkOrderTypeEnum.Calibration]: "bg-yellow-100 text-yellow-800",
  };
  return colors[type];
};

export const getWorkCenterStatusText = (status: WorkCenterStatusEnum) => {
  const statuses = {
    [WorkCenterStatusEnum.Operational]: "Operasyonel",
    [WorkCenterStatusEnum.UnderMaintenance]: "Bakımda",
    [WorkCenterStatusEnum.OutOfOrder]: "Arızalı",
    [WorkCenterStatusEnum.Retired]: "Emekli",
  };
  return statuses[status];
};

export const getWorkCenterStatusColor = (status: WorkCenterStatusEnum) => {
  const colors = {
    [WorkCenterStatusEnum.Operational]: "bg-green-100 text-green-800",
    [WorkCenterStatusEnum.UnderMaintenance]: "bg-yellow-100 text-yellow-800",
    [WorkCenterStatusEnum.OutOfOrder]: "bg-red-100 text-red-800",
    [WorkCenterStatusEnum.Retired]: "bg-gray-100 text-gray-800",
  };
  return colors[status];
};

export const getWorkCenterStatusIcon = (status: WorkCenterStatusEnum) => {
  switch (status) {
    case WorkCenterStatusEnum.Operational:
      return <FaCheckCircle size={14} />;
    case WorkCenterStatusEnum.UnderMaintenance:
      return <FaWrench size={14} />;
    case WorkCenterStatusEnum.OutOfOrder:
      return <FaExclamationTriangle size={14} />;
    case WorkCenterStatusEnum.Retired:
      return <FaClock size={14} />;
    default:
      return <FaCog size={14} />;
  }
};

export const getCriticalityLevelText = (criticality: CriticalityLevelEnum) => {
  const levels = {
    [CriticalityLevelEnum.Low]: "Düşük",
    [CriticalityLevelEnum.Medium]: "Orta",
    [CriticalityLevelEnum.High]: "Yüksek",
    [CriticalityLevelEnum.Critical]: "Kritik",
  };
  return levels[criticality];
};

export const getRequirementSourceTypeText = (
  sourceType: RequirementSourceTypeEnum
) => {
  const sourceLabels = {
    [RequirementSourceTypeEnum.SalesOrder]: "Satış Siparişi",
    [RequirementSourceTypeEnum.Forecast]: "Tahmin",
    [RequirementSourceTypeEnum.SafetyStock]: "Güvenlik Stoku",
    [RequirementSourceTypeEnum.ProductionOrder]: "Üretim Emri",
  };
  return sourceLabels[sourceType];
};

export const getRequirementSourceTypeColor = (
  sourceType: RequirementSourceTypeEnum
) => {
  const sourceColors = {
    [RequirementSourceTypeEnum.SalesOrder]: "bg-blue-100 text-blue-800",
    [RequirementSourceTypeEnum.Forecast]: "bg-green-100 text-green-800",
    [RequirementSourceTypeEnum.SafetyStock]: "bg-orange-100 text-orange-800",
    [RequirementSourceTypeEnum.ProductionOrder]:
      "bg-purple-100 text-purple-800",
  };
  return sourceColors[sourceType];
};

export const getProductionOrderStatus = (
  status: ProductionOrderStatusEnum
): ProjectStatusEnum => {
  switch (status) {
    case ProductionOrderStatusEnum.Created:
    case ProductionOrderStatusEnum.Released:
      return ProjectStatusEnum.Planning;
    case ProductionOrderStatusEnum.InProgress:
      return ProjectStatusEnum.Active;
    case ProductionOrderStatusEnum.Completed:
      return ProjectStatusEnum.Completed;
    case ProductionOrderStatusEnum.Cancelled:
      return ProjectStatusEnum.Cancelled;
    case ProductionOrderStatusEnum.OnHold:
      return ProjectStatusEnum.OnHold;
    default:
      return ProjectStatusEnum.Planning;
  }
};

export const getWorkOrderStatus = (
  status: WorkOrderStatusEnum
): TaskStatusEnum => {
  switch (status) {
    case WorkOrderStatusEnum.Created:
    case WorkOrderStatusEnum.Released:
      return TaskStatusEnum.NotStarted;
    case WorkOrderStatusEnum.InProgress:
      return TaskStatusEnum.InProgress;
    case WorkOrderStatusEnum.Completed:
      return TaskStatusEnum.Completed;
    case WorkOrderStatusEnum.Cancelled:
      return TaskStatusEnum.Cancelled;
    default:
      return TaskStatusEnum.NotStarted;
  }
};

export const getProductionOrderStatusColor = (
  status: ProductionOrderStatusEnum
) => {
  switch (status) {
    case ProductionOrderStatusEnum.Created:
      return "bg-gray-100 text-gray-800";
    case ProductionOrderStatusEnum.Released:
      return "bg-blue-100 text-blue-800";
    case ProductionOrderStatusEnum.InProgress:
      return "bg-yellow-100 text-yellow-800";
    case ProductionOrderStatusEnum.Completed:
      return "bg-green-100 text-green-800";
    case ProductionOrderStatusEnum.Cancelled:
      return "bg-red-100 text-red-800";
    case ProductionOrderStatusEnum.OnHold:
      return "bg-orange-100 text-orange-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getProductionOrderStatusText = (
  status: ProductionOrderStatusEnum
) => {
  switch (status) {
    case ProductionOrderStatusEnum.Created:
      return "Oluşturuldu";
    case ProductionOrderStatusEnum.Released:
      return "Serbest Bırakıldı";
    case ProductionOrderStatusEnum.InProgress:
      return "Devam Ediyor";
    case ProductionOrderStatusEnum.Completed:
      return "Tamamlandı";
    case ProductionOrderStatusEnum.Cancelled:
      return "İptal Edildi";
    case ProductionOrderStatusEnum.OnHold:
      return "Beklemede";
    default:
      return "Bilinmiyor";
  }
};

export const getProductionOrderStatusIcon = (
  status: ProductionOrderStatusEnum
) => {
  switch (status) {
    case ProductionOrderStatusEnum.Created:
      return <FaClock size={14} />;
    case ProductionOrderStatusEnum.Released:
      return <FaPlay size={14} />;
    case ProductionOrderStatusEnum.InProgress:
      return <FaCog size={14} />;
    case ProductionOrderStatusEnum.Completed:
      return <FaCheckCircle size={14} />;
    case ProductionOrderStatusEnum.Cancelled:
      return <FaExclamationTriangle size={14} />;
    case ProductionOrderStatusEnum.OnHold:
      return <FaPause size={14} />;
    default:
      return <FaIndustry size={14} />;
  }
};

export const getProgressPercentage = (order: MrpProductionOrder) => {
  if (order.plannedQuantity === 0) return 0;
  return Math.round((order.confirmedQuantity / order.plannedQuantity) * 100);
};

export const getProgressColor = (percentage: number) => {
  if (percentage >= 90) return "bg-green-500";
  if (percentage >= 70) return "bg-blue-500";
  if (percentage >= 50) return "bg-yellow-500";
  if (percentage >= 25) return "bg-orange-500";
  return "bg-red-500";
};

export const getProductionOrderTypeText = (
  type: ProductionOrderTypeEnum | undefined
) => {
  switch (type) {
    case ProductionOrderTypeEnum.Standard:
      return "Standart";
    case ProductionOrderTypeEnum.Rework:
      return "Yeniden İşleme";
    case ProductionOrderTypeEnum.Maintenance:
      return "Bakım";
    case ProductionOrderTypeEnum.Sample:
      return "Numune";
    default:
      return "-";
  }
};

export const getRecommendationStatusText = (
  status: RecommendationStatusEnum
) => {
  const statusLabels = {
    [RecommendationStatusEnum.Open]: "Açık",
    [RecommendationStatusEnum.Implemented]: "Uygulandı",
    [RecommendationStatusEnum.Rejected]: "Reddedildi",
    [RecommendationStatusEnum.Expired]: "Süresi Doldu",
  };
  return statusLabels[status];
};

export const getRecommendationStatusColor = (
  status: RecommendationStatusEnum
) => {
  const statusColors = {
    [RecommendationStatusEnum.Open]: "bg-blue-100 text-blue-800",
    [RecommendationStatusEnum.Implemented]: "bg-green-100 text-green-800",
    [RecommendationStatusEnum.Rejected]: "bg-red-100 text-red-800",
    [RecommendationStatusEnum.Expired]: "bg-gray-100 text-gray-800",
  };
  return statusColors[status];
};

export const getPsActivityTypeText = (type: PsActivityTypeEnum): string => {
  const labels: Record<PsActivityTypeEnum, string> = {
    [PsActivityTypeEnum.WorkLog]: "İş Kaydı",
    [PsActivityTypeEnum.StatusUpdate]: "Durum Güncelleme",
    [PsActivityTypeEnum.Issue]: "Sorun",
    [PsActivityTypeEnum.Meeting]: "Toplantı",
    [PsActivityTypeEnum.Review]: "İnceleme",
    [PsActivityTypeEnum.TaskCreated]: "Görev Oluşturma",
    [PsActivityTypeEnum.TaskUpdated]: "Görev Güncelleme",
    [PsActivityTypeEnum.TaskCompleted]: "Görev Tamamlama",
    [PsActivityTypeEnum.CommentAdded]: "Yorum Ekleme",
    [PsActivityTypeEnum.FileUploaded]: "Dosya Yükleme",
    [PsActivityTypeEnum.StatusChanged]: "Durum Değişikliği",
    [PsActivityTypeEnum.AssignmentChanged]: "Atama Değişikliği",
    [PsActivityTypeEnum.MeetingScheduled]: "Toplantı Planlama",
  };
  return labels[type] || type;
};

export const getPsActivityTypeIcon = (activityType: PsActivityTypeEnum) => {
  const icons: Record<
    PsActivityTypeEnum,
    React.ComponentType<React.ComponentProps<"svg">>
  > = {
    [PsActivityTypeEnum.WorkLog]: FaFileAlt,
    [PsActivityTypeEnum.StatusUpdate]: FaCog,
    [PsActivityTypeEnum.Issue]: FaFlask,
    [PsActivityTypeEnum.Meeting]: FaVideo,
    [PsActivityTypeEnum.Review]: FaEye,
    [PsActivityTypeEnum.TaskCreated]: FaPlus,
    [PsActivityTypeEnum.TaskUpdated]: FaEdit,
    [PsActivityTypeEnum.TaskCompleted]: FaCog,
    [PsActivityTypeEnum.CommentAdded]: FaComment,
    [PsActivityTypeEnum.FileUploaded]: FaFileAlt,
    [PsActivityTypeEnum.StatusChanged]: FaCog,
    [PsActivityTypeEnum.AssignmentChanged]: FaUsers,
    [PsActivityTypeEnum.MeetingScheduled]: FaVideo,
  };
  return icons[activityType] || FaCog;
};

export const getPsActivityTypeColor = (
  activityType: PsActivityTypeEnum
): string => {
  const colors: Record<PsActivityTypeEnum, string> = {
    [PsActivityTypeEnum.WorkLog]: "bg-gray-100 text-gray-800",
    [PsActivityTypeEnum.StatusUpdate]: "bg-blue-100 text-blue-800",
    [PsActivityTypeEnum.Issue]: "bg-red-100 text-red-800",
    [PsActivityTypeEnum.Meeting]: "bg-teal-100 text-teal-800",
    [PsActivityTypeEnum.Review]: "bg-purple-100 text-purple-800",
    [PsActivityTypeEnum.TaskCreated]: "bg-green-100 text-green-800",
    [PsActivityTypeEnum.TaskUpdated]: "bg-blue-100 text-blue-800",
    [PsActivityTypeEnum.TaskCompleted]: "bg-purple-100 text-purple-800",
    [PsActivityTypeEnum.CommentAdded]: "bg-yellow-100 text-yellow-800",
    [PsActivityTypeEnum.FileUploaded]: "bg-indigo-100 text-indigo-800",
    [PsActivityTypeEnum.StatusChanged]: "bg-orange-100 text-orange-800",
    [PsActivityTypeEnum.AssignmentChanged]: "bg-pink-100 text-pink-800",
    [PsActivityTypeEnum.MeetingScheduled]: "bg-teal-100 text-teal-800",
  };
  return colors[activityType] || "bg-gray-100 text-gray-800";
};

export const getCostTimeTrackingStatusText = (status: string) => {
  const labels = {
    ON_TRACK: "Planında",
    AT_RISK: "Risk Altında",
    DELAYED: "Gecikmiş",
    COMPLETED: "Tamamlandı",
  };
  return labels[status as keyof typeof labels] || status;
};

export const getCostTimeTrackingStatusColor = (status: string) => {
  const colors = {
    ON_TRACK: "bg-green-100 text-green-800",
    AT_RISK: "bg-yellow-100 text-yellow-800",
    DELAYED: "bg-red-100 text-red-800",
    COMPLETED: "bg-blue-100 text-blue-800",
  };
  return colors[status as keyof typeof colors] || "bg-gray-100 text-gray-800";
};

export const getCostTimeTrackingStatusIcon = (status: string) => {
  const icons = {
    ON_TRACK: FaCheckCircle,
    AT_RISK: FaExclamationCircle,
    DELAYED: FaExclamationCircle,
    COMPLETED: FaCheckCircle,
  };
  return icons[status as keyof typeof icons] || FaExclamationCircle;
};

export const getPsDocumentTypeText = (type: PsDocumentTypeEnum): string => {
  const typeLabels = {
    [PsDocumentTypeEnum.Specification]: "Şartname",
    [PsDocumentTypeEnum.Design]: "Tasarım",
    [PsDocumentTypeEnum.Contract]: "Sözleşme",
    [PsDocumentTypeEnum.Report]: "Rapor",
    [PsDocumentTypeEnum.Manual]: "Kılavuz",
    [PsDocumentTypeEnum.Other]: "Diğer",
  };
  return typeLabels[type] || type;
};

export const getPhaseStatusColor = (status: PhaseStatusEnum) => {
  switch (status) {
    case PhaseStatusEnum.NotStarted:
      return "bg-blue-100 text-blue-800";
    case PhaseStatusEnum.InProgress:
      return "bg-yellow-100 text-yellow-800";
    case PhaseStatusEnum.Completed:
      return "bg-green-100 text-green-800";
    case PhaseStatusEnum.OnHold:
      return "bg-orange-100 text-orange-800";
    case PhaseStatusEnum.Cancelled:
      return "bg-red-100 text-red-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getPhaseStatusText = (status: PhaseStatusEnum) => {
  switch (status) {
    case PhaseStatusEnum.NotStarted:
      return "Başlamadı";
    case PhaseStatusEnum.InProgress:
      return "Devam Ediyor";
    case PhaseStatusEnum.Completed:
      return "Tamamlandı";
    case PhaseStatusEnum.OnHold:
      return "Beklemede";
    case PhaseStatusEnum.Cancelled:
      return "İptal Edildi";
    default:
      return "Bilinmiyor";
  }
};

export const getPhaseStatusIcon = (status: PhaseStatusEnum) => {
  switch (status) {
    case PhaseStatusEnum.NotStarted:
      return <FaClock className="w-4 h-4" />;
    case PhaseStatusEnum.InProgress:
      return <FaBolt className="w-4 h-4" />;
    case PhaseStatusEnum.Completed:
      return <FaCheckCircle className="w-4 h-4" />;
    case PhaseStatusEnum.OnHold:
      return <FaExclamationTriangle className="w-4 h-4" />;
    case PhaseStatusEnum.Cancelled:
      return <FaTimesCircle className="w-4 h-4" />;
    default:
      return <FaClock className="w-4 h-4" />;
  }
};

export const getProjectStatusColor = (status: ProjectStatusEnum) => {
  switch (status) {
    case ProjectStatusEnum.Planning:
      return "bg-blue-100 text-blue-800 border-blue-200";
    case ProjectStatusEnum.Active:
      return "bg-green-100 text-green-800 border-green-200";
    case ProjectStatusEnum.OnHold:
      return "bg-yellow-100 text-yellow-800 border-yellow-200";
    case ProjectStatusEnum.Completed:
      return "bg-emerald-100 text-emerald-800 border-emerald-200";
    case ProjectStatusEnum.Cancelled:
      return "bg-red-100 text-red-800 border-red-200";
    default:
      return "bg-gray-100 text-gray-800 border-gray-200";
  }
};

export const getProjectStatusIcon = (status: ProjectStatusEnum) => {
  switch (status) {
    case ProjectStatusEnum.Planning:
      return <FaClock className="w-4 h-4" />;
    case ProjectStatusEnum.Active:
      return <FaCheckCircle className="w-4 h-4" />;
    case ProjectStatusEnum.OnHold:
      return <FaPause className="w-4 h-4" />;
    case ProjectStatusEnum.Completed:
      return <FaCheckCircle className="w-4 h-4" />;
    case ProjectStatusEnum.Cancelled:
      return <FaBan className="w-4 h-4" />;
    default:
      return <FaClock className="w-4 h-4" />;
  }
};

export const getProjectStatusText = (status: ProjectStatusEnum) => {
  switch (status) {
    case ProjectStatusEnum.Planning:
      return "Planlama";
    case ProjectStatusEnum.Active:
      return "Aktif";
    case ProjectStatusEnum.OnHold:
      return "Beklemede";
    case ProjectStatusEnum.Completed:
      return "Tamamlandı";
    case ProjectStatusEnum.Cancelled:
      return "İptal Edildi";
    default:
      return "Bilinmiyor";
  }
};

export const getProjectTypeColor = (type: ProjectTypeEnum) => {
  switch (type) {
    case ProjectTypeEnum.Internal:
      return "bg-purple-100 text-purple-800 border-purple-200";
    case ProjectTypeEnum.Customer:
      return "bg-blue-100 text-blue-800 border-blue-200";
    case ProjectTypeEnum.Research:
      return "bg-green-100 text-green-800 border-green-200";
    case ProjectTypeEnum.Maintenance:
      return "bg-orange-100 text-orange-800 border-orange-200";
    default:
      return "bg-gray-100 text-gray-800 border-gray-200";
  }
};

export const getProjectTypeText = (type: ProjectTypeEnum) => {
  switch (type) {
    case ProjectTypeEnum.Internal:
      return "İç Proje";
    case ProjectTypeEnum.Customer:
      return "Müşteri Projesi";
    case ProjectTypeEnum.Research:
      return "Ar-Ge Projesi";
    case ProjectTypeEnum.Maintenance:
      return "Bakım Projesi";
    default:
      return "Diğer";
  }
};

export const getProjectPhaseTaskStatusColor = (
  status: TaskStatusEnum | ProjectStatusEnum | PhaseStatusEnum
) => {
  switch (status) {
    case TaskStatusEnum.Completed:
    case ProjectStatusEnum.Completed:
    case PhaseStatusEnum.Completed:
      return "bg-gradient-to-r from-green-500 to-green-700";
    case TaskStatusEnum.InProgress:
    case ProjectStatusEnum.Active:
    case PhaseStatusEnum.InProgress:
      return "bg-gradient-to-r from-blue-500 to-blue-700";
    case TaskStatusEnum.OnHold:
    case ProjectStatusEnum.OnHold:
    case PhaseStatusEnum.OnHold:
      return "bg-gradient-to-r from-yellow-500 to-orange-600";
    case TaskStatusEnum.Cancelled:
    case ProjectStatusEnum.Cancelled:
    case PhaseStatusEnum.Cancelled:
      return "bg-gradient-to-r from-red-500 to-red-700";
    default:
      return "bg-gradient-to-r from-black-500 to-black-700";
  }
};

export const getPhaseCategoryColor = (category: string) => {
  switch (category) {
    case "Planning":
      return "bg-purple-100 text-purple-800";
    case "Development":
      return "bg-blue-100 text-blue-800";
    case "Testing":
      return "bg-orange-100 text-orange-800";
    case "Deployment":
      return "bg-green-100 text-green-800";
    case "Design":
      return "bg-pink-100 text-pink-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getTaskStatusIcon = (status: TaskStatusEnum) => {
  switch (status) {
    case TaskStatusEnum.NotStarted:
      return <FaClock className="w-4 h-4" />;
    case TaskStatusEnum.InProgress:
      return <FaBullseye className="w-4 h-4" />;
    case TaskStatusEnum.Completed:
      return <FaCheckCircle className="w-4 h-4" />;
    case TaskStatusEnum.OnHold:
      return <FaExclamationCircle className="w-4 h-4" />;
    case TaskStatusEnum.Cancelled:
      return <FaTimesCircle className="w-4 h-4" />;
    default:
      return <FaClock className="w-4 h-4" />;
  }
};

export const getTaskStatusColor = (status: TaskStatusEnum) => {
  switch (status) {
    case TaskStatusEnum.NotStarted:
      return "bg-gray-100 text-gray-800";
    case TaskStatusEnum.InProgress:
      return "bg-blue-100 text-blue-800";
    case TaskStatusEnum.Completed:
      return "bg-green-100 text-green-800";
    case TaskStatusEnum.OnHold:
      return "bg-yellow-100 text-yellow-800";
    case TaskStatusEnum.Cancelled:
      return "bg-red-100 text-red-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getTaskTypeColor = (taskType: TaskTypeEnum) => {
  switch (taskType) {
    case TaskTypeEnum.Development:
      return "bg-purple-100 text-purple-800";
    case TaskTypeEnum.Testing:
      return "bg-green-100 text-green-800";
    case TaskTypeEnum.Documentation:
      return "bg-blue-100 text-blue-800";
    case TaskTypeEnum.Review:
      return "bg-yellow-100 text-yellow-800";
    case TaskTypeEnum.Deployment:
      return "bg-red-100 text-red-800";
    case TaskTypeEnum.Meeting:
      return "bg-gray-100 text-gray-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getRiskCategoryText = (category: RiskCategoryEnum): string => {
  const labels = {
    [RiskCategoryEnum.Technical]: "Teknik",
    [RiskCategoryEnum.Schedule]: "Program",
    [RiskCategoryEnum.Budget]: "Bütçe",
    [RiskCategoryEnum.Resource]: "Kaynak",
    [RiskCategoryEnum.External]: "Dış Etken",
    [RiskCategoryEnum.Quality]: "Kalite",
  };
  return labels[category] || category;
};

export const getRiskProbabilityText = (
  probability: RiskProbabilityEnum
): string => {
  const labels = {
    [RiskProbabilityEnum.VeryLow]: "Çok Düşük",
    [RiskProbabilityEnum.Low]: "Düşük",
    [RiskProbabilityEnum.Medium]: "Orta",
    [RiskProbabilityEnum.High]: "Yüksek",
    [RiskProbabilityEnum.VeryHigh]: "Çok Yüksek",
  };
  return labels[probability] || probability;
};

export const getRiskImpactText = (impact: RiskImpactEnum): string => {
  const labels = {
    [RiskImpactEnum.VeryLow]: "Çok Düşük",
    [RiskImpactEnum.Low]: "Düşük",
    [RiskImpactEnum.Medium]: "Orta",
    [RiskImpactEnum.High]: "Yüksek",
    [RiskImpactEnum.VeryHigh]: "Çok Yüksek",
  };
  return labels[impact] || impact;
};

export const getRiskLevelText = (level: RiskLevelEnum): string => {
  const labels = {
    [RiskLevelEnum.Low]: "Düşük",
    [RiskLevelEnum.Medium]: "Orta",
    [RiskLevelEnum.High]: "Yüksek",
    [RiskLevelEnum.Critical]: "Kritik",
  };
  return labels[level] || level;
};

export const getRiskStatusText = (status: RiskStatusEnum): string => {
  const labels = {
    [RiskStatusEnum.Identified]: "Tespit Edildi",
    [RiskStatusEnum.Analyzing]: "Analiz Ediliyor",
    [RiskStatusEnum.Mitigating]: "Önlem Alınıyor",
    [RiskStatusEnum.Monitoring]: "İzleniyor",
    [RiskStatusEnum.Closed]: "Kapatıldı",
  };
  return labels[status] || status;
};

export const getRiskLevelColor = (level: RiskLevelEnum): string => {
  const colors = {
    [RiskLevelEnum.Low]: "bg-green-100 text-green-800",
    [RiskLevelEnum.Medium]: "bg-yellow-100 text-yellow-800",
    [RiskLevelEnum.High]: "bg-orange-100 text-orange-800",
    [RiskLevelEnum.Critical]: "bg-red-100 text-red-800",
  };
  return colors[level] || "bg-gray-100 text-gray-800";
};

export const getDailyUpdateStatusColor = (status: DailyUpdateStatusEnum) => {
  switch (status) {
    case DailyUpdateStatusEnum.Draft:
      return "bg-gray-100 text-gray-800";
    case DailyUpdateStatusEnum.Submitted:
      return "bg-blue-100 text-blue-800";
    case DailyUpdateStatusEnum.Approved:
      return "bg-green-100 text-green-800";
    case DailyUpdateStatusEnum.Rejected:
      return "bg-red-100 text-red-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getWorkTypeColor = (workType: WorkTypeEnum) => {
  const colors = {
    [WorkTypeEnum.Development]: "bg-blue-100 text-blue-800",
    [WorkTypeEnum.Testing]: "bg-green-100 text-green-800",
    [WorkTypeEnum.Design]: "bg-purple-100 text-purple-800",
    [WorkTypeEnum.Documentation]: "bg-yellow-100 text-yellow-800",
    [WorkTypeEnum.Meeting]: "bg-orange-100 text-orange-800",
    [WorkTypeEnum.Research]: "bg-indigo-100 text-indigo-800",
    [WorkTypeEnum.Debugging]: "bg-red-100 text-red-800",
    [WorkTypeEnum.Review]: "bg-teal-100 text-teal-800",
    [WorkTypeEnum.Other]: "bg-gray-100 text-gray-800",
  };
  return colors[workType] || "bg-gray-100 text-gray-800";
};

export const getDeliveryStatusColor = (status: DeliveryStatusEnum) => {
  const colors = {
    [DeliveryStatusEnum.Preparing]: "bg-gray-100 text-gray-800",
    [DeliveryStatusEnum.Shipped]: "bg-blue-100 text-blue-800",
    [DeliveryStatusEnum.InTransit]: "bg-indigo-100 text-indigo-800",
    [DeliveryStatusEnum.OutForDelivery]: "bg-purple-100 text-purple-800",
    [DeliveryStatusEnum.Delivered]: "bg-green-100 text-green-800",
    [DeliveryStatusEnum.PartiallyDelivered]: "bg-orange-100 text-orange-800",
    [DeliveryStatusEnum.Delayed]: "bg-red-100 text-red-800",
    [DeliveryStatusEnum.Returned]: "bg-yellow-100 text-yellow-800",
    [DeliveryStatusEnum.Cancelled]: "bg-gray-100 text-gray-800",
  };
  return colors[status];
};

export const getDeliveryStatusIcon = (status: DeliveryStatusEnum) => {
  const icons = {
    [DeliveryStatusEnum.Preparing]: <FaBox className="w-4 h-4" />,
    [DeliveryStatusEnum.Shipped]: <FaTruck className="w-4 h-4" />,
    [DeliveryStatusEnum.InTransit]: <FaTruck className="w-4 h-4" />,
    [DeliveryStatusEnum.OutForDelivery]: <FaMapMarkerAlt className="w-4 h-4" />,
    [DeliveryStatusEnum.Delivered]: <FaCheckCircle className="w-4 h-4" />,
    [DeliveryStatusEnum.PartiallyDelivered]: (
      <FaExclamationTriangle className="w-4 h-4" />
    ),
    [DeliveryStatusEnum.Delayed]: <FaClock className="w-4 h-4" />,
    [DeliveryStatusEnum.Returned]: <FaBox className="w-4 h-4" />,
    [DeliveryStatusEnum.Cancelled]: (
      <FaExclamationTriangle className="w-4 h-4" />
    ),
  };
  return icons[status];
};

export const getConditionColor = (condition: MmDeliveryItem["condition"]) => {
  const colors = {
    Good: "bg-green-100 text-green-800",
    Damaged: "bg-red-100 text-red-800",
    Missing: "bg-orange-100 text-orange-800",
  };
  return colors[condition];
};

export const getConditionText = (condition: MmDeliveryItem["condition"]) => {
  const texts = {
    Good: "İyi",
    Damaged: "Hasarlı",
    Missing: "Eksik",
  };
  return texts[condition];
};

export const getOrderStatusText = (status: OrderStatusEnum) => {
  const texts = {
    [OrderStatusEnum.Draft]: "Taslak",
    [OrderStatusEnum.Pending]: "Beklemede",
    [OrderStatusEnum.Approved]: "Onaylandı",
    [OrderStatusEnum.Sent]: "Gönderildi",
    [OrderStatusEnum.Confirmed]: "Onaylandı",
    [OrderStatusEnum.PartiallyDelivered]: "Kısmi Teslim",
    [OrderStatusEnum.Delivered]: "Teslim Edildi",
    [OrderStatusEnum.Completed]: "Tamamlandı",
    [OrderStatusEnum.Cancelled]: "İptal Edildi",
    [OrderStatusEnum.PartiallyReceived]: "Kısmi Alındı",
    [OrderStatusEnum.Received]: "Alındı",
    [OrderStatusEnum.Invoiced]: "Faturalandırıldı",
    [OrderStatusEnum.Closed]: "Kapandı",
  };
  return texts[status];
};

export const getOrderStatusColor = (status: OrderStatusEnum) => {
  const colors = {
    [OrderStatusEnum.Draft]: "bg-gray-100 text-gray-800",
    [OrderStatusEnum.Pending]: "bg-yellow-100 text-yellow-800",
    [OrderStatusEnum.Approved]: "bg-blue-100 text-blue-800",
    [OrderStatusEnum.Sent]: "bg-indigo-100 text-indigo-800",
    [OrderStatusEnum.Confirmed]: "bg-purple-100 text-purple-800",
    [OrderStatusEnum.PartiallyDelivered]: "bg-orange-100 text-orange-800",
    [OrderStatusEnum.Delivered]: "bg-green-100 text-green-800",
    [OrderStatusEnum.Completed]: "bg-emerald-100 text-emerald-800",
    [OrderStatusEnum.Cancelled]: "bg-red-100 text-red-800",
    [OrderStatusEnum.PartiallyReceived]: "bg-orange-100 text-orange-800",
    [OrderStatusEnum.Received]: "bg-green-100 text-green-800",
    [OrderStatusEnum.Invoiced]: "bg-blue-100 text-blue-800",
    [OrderStatusEnum.Closed]: "bg-gray-100 text-gray-800",
  };
  return colors[status];
};

export const getOrderStatusIcon = (status: OrderStatusEnum) => {
  const icons = {
    [OrderStatusEnum.Draft]: <FaFileAlt className="w-4 h-4" />,
    [OrderStatusEnum.Pending]: <FaClock className="w-4 h-4" />,
    [OrderStatusEnum.Approved]: <FaCheckCircle className="w-4 h-4" />,
    [OrderStatusEnum.Sent]: <FaBox className="w-4 h-4" />,
    [OrderStatusEnum.Confirmed]: <FaCheckCircle className="w-4 h-4" />,
    [OrderStatusEnum.PartiallyDelivered]: (
      <FaExclamationTriangle className="w-4 h-4" />
    ),
    [OrderStatusEnum.Delivered]: <FaTruck className="w-4 h-4" />,
    [OrderStatusEnum.Completed]: <FaCheckCircle className="w-4 h-4" />,
    [OrderStatusEnum.Cancelled]: <FaTimesCircle className="w-4 h-4" />,
    [OrderStatusEnum.PartiallyReceived]: (
      <FaExclamationTriangle className="w-4 h-4" />
    ),
    [OrderStatusEnum.Received]: <FaCheckCircle className="w-4 h-4" />,
    [OrderStatusEnum.Invoiced]: <FaFileInvoiceDollar className="w-4 h-4" />,
    [OrderStatusEnum.Closed]: <FaLock className="w-4 h-4" />,
  };
  return icons[status];
};

export const getRequestStatusText = (status: RequestStatusEnum) => {
  const statuses = {
    [RequestStatusEnum.Draft]: "Taslak",
    [RequestStatusEnum.Submitted]: "Gönderildi",
    [RequestStatusEnum.InReview]: "İnceleniyor",
    [RequestStatusEnum.Approved]: "Onaylandı",
    [RequestStatusEnum.Rejected]: "Reddedildi",
    [RequestStatusEnum.InQuotation]: "Teklif Aşamasında",
    [RequestStatusEnum.Ordered]: "Sipariş Verildi",
    [RequestStatusEnum.Completed]: "Tamamlandı",
    [RequestStatusEnum.Cancelled]: "İptal Edildi",
  };
  return statuses[status];
};

export const getRequestStatusColor = (status: RequestStatusEnum) => {
  const colors = {
    [RequestStatusEnum.Draft]: "bg-gray-100 text-gray-800",
    [RequestStatusEnum.Submitted]: "bg-blue-100 text-blue-800",
    [RequestStatusEnum.InReview]: "bg-yellow-100 text-yellow-800",
    [RequestStatusEnum.Approved]: "bg-green-100 text-green-800",
    [RequestStatusEnum.Rejected]: "bg-red-100 text-red-800",
    [RequestStatusEnum.InQuotation]: "bg-purple-100 text-purple-800",
    [RequestStatusEnum.Ordered]: "bg-indigo-100 text-indigo-800",
    [RequestStatusEnum.Completed]: "bg-green-100 text-green-800",
    [RequestStatusEnum.Cancelled]: "bg-red-100 text-red-800",
  };
  return colors[status];
};

export const getApprovalStatusIcon = (status: ApprovalStatusEnum) => {
  switch (status) {
    case ApprovalStatusEnum.Approved:
      return <FaCheckCircle className="w-4 h-4 text-green-600" />;
    case ApprovalStatusEnum.Rejected:
      return <FaTimesCircle className="w-4 h-4 text-red-600" />;
    case ApprovalStatusEnum.Pending:
      return <FaClock className="w-4 h-4 text-yellow-600" />;
    default:
      return <FaClock className="w-4 h-4 text-gray-600" />;
  }
};

export const getRequisitionStatusColor = (status: RequisitionStatusEnum) => {
  switch (status) {
    case RequisitionStatusEnum.Draft:
      return "bg-gray-100 text-gray-800";
    case RequisitionStatusEnum.Submitted:
      return "bg-blue-100 text-blue-800";
    case RequisitionStatusEnum.InApproval:
      return "bg-yellow-100 text-yellow-800";
    case RequisitionStatusEnum.Approved:
      return "bg-green-100 text-green-800";
    case RequisitionStatusEnum.Rejected:
      return "bg-red-100 text-red-800";
    case RequisitionStatusEnum.Cancelled:
      return "bg-gray-100 text-gray-800";
    case RequisitionStatusEnum.Converted:
      return "bg-purple-100 text-purple-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getRequisitionStatusText = (status: RequisitionStatusEnum) => {
  switch (status) {
    case RequisitionStatusEnum.Draft:
      return "Taslak";
    case RequisitionStatusEnum.Submitted:
      return "Gönderildi";
    case RequisitionStatusEnum.InApproval:
      return "Onayda";
    case RequisitionStatusEnum.Approved:
      return "Onaylandı";
    case RequisitionStatusEnum.Rejected:
      return "Reddedildi";
    case RequisitionStatusEnum.Cancelled:
      return "İptal Edildi";
    case RequisitionStatusEnum.Converted:
      return "Siparişe Dönüştürüldü";
    default:
      return "Bilinmiyor";
  }
};

export const getRequisitionStatusIcon = (status: RequisitionStatusEnum) => {
  switch (status) {
    case RequisitionStatusEnum.Draft:
      return <FaFileAlt size={14} />;
    case RequisitionStatusEnum.Submitted:
      return <FaClock size={14} />;
    case RequisitionStatusEnum.InApproval:
      return <FaClock size={14} />;
    case RequisitionStatusEnum.Approved:
      return <FaCheckCircle size={14} />;
    case RequisitionStatusEnum.Rejected:
      return <FaTimesCircle size={14} />;
    case RequisitionStatusEnum.Cancelled:
      return <FaTimesCircle size={14} />;
    case RequisitionStatusEnum.Converted:
      return <FaCheckCircle size={14} />;
    default:
      return <FaFileAlt size={14} />;
  }
};

export const getQuotationStatusText = (status: QuotationStatusEnum) => {
  const statuses = {
    [QuotationStatusEnum.Draft]: "Taslak",
    [QuotationStatusEnum.Pending]: "Beklemede",
    [QuotationStatusEnum.UnderReview]: "İnceleme",
    [QuotationStatusEnum.Submitted]: "Sunuldu",
    [QuotationStatusEnum.Approved]: "Onaylandı",
    [QuotationStatusEnum.Rejected]: "Reddedildi",
    [QuotationStatusEnum.Expired]: "Süresi Doldu",
  };
  return statuses[status];
};

export const getQuotationStatusColor = (status: QuotationStatusEnum) => {
  const colors = {
    [QuotationStatusEnum.Draft]: "bg-gray-100 text-gray-800",
    [QuotationStatusEnum.Pending]: "bg-yellow-100 text-yellow-800",
    [QuotationStatusEnum.UnderReview]: "bg-blue-100 text-blue-800",
    [QuotationStatusEnum.Submitted]: "bg-indigo-100 text-indigo-800",
    [QuotationStatusEnum.Approved]: "bg-green-100 text-green-800",
    [QuotationStatusEnum.Rejected]: "bg-red-100 text-red-800",
    [QuotationStatusEnum.Expired]: "bg-orange-100 text-orange-800",
  };
  return colors[status];
};

export const getQuotationStatusIcon = (status: QuotationStatusEnum) => {
  const icons = {
    [QuotationStatusEnum.Draft]: <FaFileAlt className="w-4 h-4" />,
    [QuotationStatusEnum.Pending]: <FaClock className="w-4 h-4" />,
    [QuotationStatusEnum.UnderReview]: <FaEye className="w-4 h-4" />,
    [QuotationStatusEnum.Submitted]: <FaFileAlt className="w-4 h-4" />,
    [QuotationStatusEnum.Approved]: <FaCheckCircle className="w-4 h-4" />,
    [QuotationStatusEnum.Rejected]: <FaTimesCircle className="w-4 h-4" />,
    [QuotationStatusEnum.Expired]: <FaExclamationCircle className="w-4 h-4" />,
  };
  return icons[status];
};

export const getSupplierCardTypeText = (type: SupplierCardTypeEnum) => {
  const types = {
    [SupplierCardTypeEnum.Standard]: "Standart",
    [SupplierCardTypeEnum.Premium]: "Premium",
    [SupplierCardTypeEnum.Strategic]: "Stratejik",
    [SupplierCardTypeEnum.Preferred]: "Tercihli",
  };
  return types[type];
};

export const getSupplierCardTypeColor = (type: SupplierCardTypeEnum) => {
  const colors = {
    [SupplierCardTypeEnum.Standard]:
      "bg-gray-100 text-gray-800 border-gray-200",
    [SupplierCardTypeEnum.Premium]: "bg-blue-100 text-blue-800 border-blue-200",
    [SupplierCardTypeEnum.Strategic]:
      "bg-purple-100 text-purple-800 border-purple-200",
    [SupplierCardTypeEnum.Preferred]:
      "bg-green-100 text-green-800 border-green-200",
  };
  return colors[type];
};

export const getPaymentTermsText = (terms: PaymentTerms) => {
  const termsMap = {
    [PaymentTerms.Cash]: "Peşin",
    [PaymentTerms.Net15]: "Net 15",
    [PaymentTerms.Net30]: "Net 30",
    [PaymentTerms.Net45]: "Net 45",
    [PaymentTerms.Net60]: "Net 60",
    [PaymentTerms.Net90]: "Net 90",
    [PaymentTerms.COD]: "Kapıda Ödeme",
    [PaymentTerms.Prepaid]: "Ön Ödeme",
  };
  return termsMap[terms] || terms;
};

export const getSupplierTypeColor = (type: SupplierTypeEnum) => {
  switch (type) {
    case SupplierTypeEnum.Material:
      return "bg-blue-100 text-blue-800";
    case SupplierTypeEnum.Service:
      return "bg-green-100 text-green-800";
    case SupplierTypeEnum.Both:
      return "bg-purple-100 text-purple-800";
    default:
      return "bg-gray-100 text-gray-800";
  }
};

export const getSupplierTypeText = (type: SupplierTypeEnum) => {
  switch (type) {
    case SupplierTypeEnum.Material:
      return "Malzeme";
    case SupplierTypeEnum.Service:
      return "Hizmet";
    case SupplierTypeEnum.Both:
      return "Karma";
    default:
      return "Bilinmiyor";
  }
};

export const getRatingColor = (rating: number) => {
  if (rating >= 4.5) return "text-green-600";
  if (rating >= 4.0) return "text-yellow-600";
  if (rating >= 3.0) return "text-orange-600";
  return "text-red-600";
};

export const getLocationTypeText = (type: LocationTypeEnum) => {
  const labels = {
    [LocationTypeEnum.Shelf]: "Raf",
    [LocationTypeEnum.Bin]: "Kutu",
    [LocationTypeEnum.Floor]: "Zemin",
    [LocationTypeEnum.Rack]: "Yüksek Raf",
    [LocationTypeEnum.Tank]: "Tank",
  };
  return labels[type];
};

export const getZoneTypeText = (type: ZoneTypeEnum) => {
  const labels = {
    [ZoneTypeEnum.Storage]: "Depolama",
    [ZoneTypeEnum.Receiving]: "Giriş",
    [ZoneTypeEnum.Shipping]: "Sevkiyat",
    [ZoneTypeEnum.Picking]: "Toplama",
    [ZoneTypeEnum.Quality]: "Kalite",
    [ZoneTypeEnum.Staging]: "Hazırlık",
  };
  return labels[type];
};

export const getQualityStatusInfo = (status: QualityStatusEnum) => {
  switch (status) {
    case QualityStatusEnum.Approved:
      return { label: "Onaylandı", color: "bg-green-100 text-green-800" };
    case QualityStatusEnum.Rejected:
      return { label: "Reddedildi", color: "bg-red-100 text-red-800" };
    case QualityStatusEnum.Quarantine:
      return { label: "Karantina", color: "bg-yellow-100 text-yellow-800" };
    case QualityStatusEnum.Pending:
      return { label: "Beklemede", color: "bg-blue-100 text-blue-800" };
    default:
      return { label: "Bilinmeyen", color: "bg-gray-100 text-gray-800" };
  }
};

export const getSerialStatusInfo = (status: SerialStatusEnum) => {
  switch (status) {
    case SerialStatusEnum.Available:
      return { label: "Müsait", color: "bg-green-100 text-green-800" };
    case SerialStatusEnum.InUse:
      return { label: "Kullanımda", color: "bg-blue-100 text-blue-800" };
    case SerialStatusEnum.Maintenance:
      return { label: "Bakımda", color: "bg-yellow-100 text-yellow-800" };
    case SerialStatusEnum.Disposed:
      return { label: "İmha Edildi", color: "bg-red-100 text-red-800" };
    default:
      return { label: "Bilinmeyen", color: "bg-gray-100 text-gray-800" };
  }
};

export const getStockStatusText = (status: StockStatusEnum) => {
  const labels = {
    [StockStatusEnum.Available]: "Mevcut",
    [StockStatusEnum.Reserved]: "Rezerve",
    [StockStatusEnum.Blocked]: "Blokeli",
    [StockStatusEnum.InTransit]: "Transfer Halinde",
    [StockStatusEnum.Quarantine]: "Karantina",
  };
  return labels[status];
};

export const getStockStatusColor = (status: StockStatusEnum) => {
  const colors = {
    [StockStatusEnum.Available]: "bg-green-100 text-green-800",
    [StockStatusEnum.Reserved]: "bg-yellow-100 text-yellow-800",
    [StockStatusEnum.Blocked]: "bg-red-100 text-red-800",
    [StockStatusEnum.InTransit]: "bg-blue-100 text-blue-800",
    [StockStatusEnum.Quarantine]: "bg-purple-100 text-purple-800",
  };
  return colors[status];
};

export const getPutawayStrategyText = (strategy: PutawayStrategyEnum) => {
  const labels = {
    [PutawayStrategyEnum.FIFO]: "İlk Giren İlk Çıkar (FIFO)",
    [PutawayStrategyEnum.LIFO]: "Son Giren İlk Çıkar (LIFO)",
    [PutawayStrategyEnum.NearestLocation]: "En Yakın Lokasyon",
    [PutawayStrategyEnum.EmptyLocation]: "Boş Lokasyon",
    [PutawayStrategyEnum.SameProduct]: "Aynı Ürün Gruplaması",
  };
  return labels[strategy];
};

export const getPutawayStrategyColor = (strategy: PutawayStrategyEnum) => {
  const colors = {
    [PutawayStrategyEnum.FIFO]: "bg-green-100 text-green-800",
    [PutawayStrategyEnum.LIFO]: "bg-red-100 text-red-800",
    [PutawayStrategyEnum.NearestLocation]: "bg-blue-100 text-blue-800",
    [PutawayStrategyEnum.EmptyLocation]: "bg-purple-100 text-purple-800",
    [PutawayStrategyEnum.SameProduct]: "bg-yellow-100 text-yellow-800",
  };
  return colors[strategy];
};

export const getConditionTypeText = (type: ConditionTypeEnum) => {
  const labels = {
    [ConditionTypeEnum.MaterialType]: "Malzeme Tipi",
    [ConditionTypeEnum.MaterialGroup]: "Malzeme Grubu",
    [ConditionTypeEnum.Quantity]: "Miktar",
    [ConditionTypeEnum.Weight]: "Ağırlık",
    [ConditionTypeEnum.Volume]: "Hacim",
  };
  return labels[type];
};

export const getConditionOperatorText = (operator: ConditionOperatorEnum) => {
  const labels = {
    [ConditionOperatorEnum.Equals]: "Eşittir",
    [ConditionOperatorEnum.NotEquals]: "Eşit Değildir",
    [ConditionOperatorEnum.GreaterThan]: "Büyüktür",
    [ConditionOperatorEnum.LessThan]: "Küçüktür",
    [ConditionOperatorEnum.Contains]: "İçerir",
  };
  return labels[operator];
};

export const getCountTypeText = (type: CountTypeEnum) => {
  const labels = {
    [CountTypeEnum.Full]: "Tam Sayım",
    [CountTypeEnum.Cycle]: "Döngüsel Sayım",
    [CountTypeEnum.Spot]: "Nokta Sayım",
  };
  return labels[type];
};

export const getCountStatusText = (status: CountStatusEnum) => {
  const labels = {
    [CountStatusEnum.Planned]: "Planlandı",
    [CountStatusEnum.InProgress]: "Devam Ediyor",
    [CountStatusEnum.Completed]: "Tamamlandı",
    [CountStatusEnum.Approved]: "Onaylandı",
  };
  return labels[status];
};

export const getCountStatusColor = (status: CountStatusEnum) => {
  const colors = {
    [CountStatusEnum.Planned]: "bg-gray-100 text-gray-800",
    [CountStatusEnum.InProgress]: "bg-blue-100 text-blue-800",
    [CountStatusEnum.Completed]: "bg-yellow-100 text-yellow-800",
    [CountStatusEnum.Approved]: "bg-green-100 text-green-800",
  };
  return colors[status];
};

export const getMovementStatusText = (status: MovementStatusEnum) => {
  const labels = {
    [MovementStatusEnum.Planned]: "Planlandı",
    [MovementStatusEnum.InProgress]: "Devam Ediyor",
    [MovementStatusEnum.Completed]: "Tamamlandı",
    [MovementStatusEnum.Cancelled]: "İptal Edildi",
  };
  return labels[status];
};

export const getMovementStatusColor = (status: MovementStatusEnum) => {
  const colors = {
    [MovementStatusEnum.Planned]: "bg-gray-100 text-gray-800",
    [MovementStatusEnum.InProgress]: "bg-blue-100 text-blue-800",
    [MovementStatusEnum.Completed]: "bg-green-100 text-green-800",
    [MovementStatusEnum.Cancelled]: "bg-red-100 text-red-800",
  };
  return colors[status];
};

export const getMovementStatusIcon = (status: MovementStatusEnum) => {
  const icons = {
    [MovementStatusEnum.Planned]: FaClock,
    [MovementStatusEnum.InProgress]: FaArrowCircleDown,
    [MovementStatusEnum.Completed]: FaCheckCircle,
    [MovementStatusEnum.Cancelled]: FaExclamationCircle,
  };
  return icons[status];
};