/**
 * Formatadores de data usando Intl.DateTimeFormat (API nativa do JavaScript).
 * Mais performático e sem dependências externas.
 */

export const formatDate = (dateString?: string): string => {
  if (!dateString) return '-';
  try {
    const date = new Date(dateString);
    if (Number.isNaN(date.getTime())) return '-';

    return new Intl.DateTimeFormat('pt-BR', {
      day: '2-digit',
      month: '2-digit',
      year: 'numeric',
      timeZone: 'America/Sao_Paulo',
    }).format(date);
  } catch {
    return '-';
  }
};

export const formatDateTime = (dateString?: string): string | null => {
  if (!dateString) return null;
  try {
    const date = new Date(dateString);
    if (Number.isNaN(date.getTime())) return null;

    const timeString = new Intl.DateTimeFormat('pt-BR', {
      hour: '2-digit',
      minute: '2-digit',
      timeZone: 'America/Sao_Paulo',
    }).format(date);

    const [hours, minutes] = timeString.split(':').map(Number);
    if (hours === 0 && minutes === 0) return null;

    return timeString;
  } catch {
    return null;
  }
};

/**
 * Formatadores numéricos usando Intl.NumberFormat (API nativa do JavaScript).
 * Substitui react-number-format para melhor performance e bundle menor.
 */

// Instância reutilizável do formatador de moeda para melhor performance
const currencyFormatter = new Intl.NumberFormat('pt-BR', {
  style: 'currency',
  currency: 'BRL',
});

export const formatCurrency = (value: number | null | undefined): string => {
  if (!value || value <= 0) return '-';
  return currencyFormatter.format(value);
};

export const formatNumber = (
  value: number | null | undefined,
  decimals: number = 2
): string => {
  if (!value || value <= 0) return '-';
  return new Intl.NumberFormat('pt-BR', {
    minimumFractionDigits: decimals,
    maximumFractionDigits: decimals,
  }).format(value);
};

/**
 * Mapeamento de cores para status e prioridades.
 * Configurações carregadas de arquivo JSON para facilitar manutenção.
 */
import colorMappings from '../config/colorMappings.json';

type ColorType = 'success' | 'error' | 'warning' | 'default';

/**
 * Mapeia códigos de status para texto legível.
 */
export const STATUS_LABELS: Record<string, string> = {
  F: 'Faturado',
  C: 'Cancelado',
  P: 'Pendente',
};

export const getStatusLabel = (status: string): string =>
  STATUS_LABELS[status] || status;

/**
 * Retorna a cor apropriada para um status de pedido.
 * Usa configuração JSON para mapear status → cores.
 */
export const getStatusColor = (
  status: string
): 'success' | 'error' | 'warning' => {
  if (!status) return 'warning';

  const statusUpper = status.toUpperCase();

  // Verifica se o status contém alguma palavra-chave de sucesso
  if (
    colorMappings.status.success.some((keyword) =>
      statusUpper.includes(keyword)
    )
  ) {
    return 'success';
  }

  // Verifica se o status contém alguma palavra-chave de erro
  if (
    colorMappings.status.error.some((keyword) => statusUpper.includes(keyword))
  ) {
    return 'error';
  }

  return 'warning';
};

/**
 * Retorna a cor apropriada para uma prioridade de entrega.
 * Usa configuração JSON para mapear prioridade → cores.
 */
export const getPriorityColor = (priority: unknown): ColorType => {
  if (typeof priority !== 'string' && typeof priority !== 'number') {
    return 'default';
  }

  const priorityStr = String(priority).trim().toUpperCase();
  if (priorityStr === '') return 'default';

  // Verifica cada categoria de prioridade
  if (
    colorMappings.priority.error.some((keyword) =>
      priorityStr.includes(keyword)
    )
  ) {
    return 'error';
  }

  if (
    colorMappings.priority.warning.some((keyword) =>
      priorityStr.includes(keyword)
    )
  ) {
    return 'warning';
  }

  if (
    colorMappings.priority.success.some((keyword) =>
      priorityStr.includes(keyword)
    )
  ) {
    return 'success';
  }

  return 'default';
};
