import { JiraAnalytics } from './types';
import { getToday, subtractDays, parseDate } from './date-utils';

export type PeriodFilter = '7d' | '30d' | '3m' | 'current';

/**
 * Filtre les analytics Jira selon la période sélectionnée
 */
export function filterAnalyticsByPeriod(
  analytics: JiraAnalytics,
  period: PeriodFilter
): JiraAnalytics {
  const now = getToday();
  let cutoffDate: Date;

  switch (period) {
    case '7d':
      cutoffDate = subtractDays(now, 7);
      break;
    case '30d':
      cutoffDate = subtractDays(now, 30);
      break;
    case '3m':
      cutoffDate = subtractDays(now, 90);
      break;
    case 'current':
    default:
      // Pour "Sprint actuel", on garde toutes les données mais on filtre les sprints
      return filterCurrentSprintAnalytics(analytics);
  }

  // Filtrer les données par date
  return filterAnalyticsByDate(analytics, cutoffDate);
}

/**
 * Filtre les analytics pour ne garder que le sprint actuel
 */
function filterCurrentSprintAnalytics(analytics: JiraAnalytics): JiraAnalytics {
  // Garder seulement le dernier sprint (le plus récent)
  const currentSprint = analytics.velocityMetrics.sprintHistory.slice(-1);

  return {
    ...analytics,
    velocityMetrics: {
      ...analytics.velocityMetrics,
      sprintHistory: currentSprint,
      // Recalculer la vélocité moyenne avec seulement le sprint actuel
      averageVelocity:
        currentSprint.length > 0 ? currentSprint[0].completedPoints : 0,
    },
  };
}

/**
 * Filtre les analytics par date de cutoff
 */
function filterAnalyticsByDate(
  analytics: JiraAnalytics,
  cutoffDate: Date
): JiraAnalytics {
  // Filtrer l'historique des sprints
  const filteredSprintHistory = analytics.velocityMetrics.sprintHistory.filter(
    (sprint) => {
      const sprintEndDate = parseDate(sprint.endDate);
      return sprintEndDate >= cutoffDate;
    }
  );

  // Si aucun sprint dans la période, garder au moins le plus récent
  const sprintHistory =
    filteredSprintHistory.length > 0
      ? filteredSprintHistory
      : analytics.velocityMetrics.sprintHistory.slice(-1);

  // Recalculer la vélocité moyenne
  const averageVelocity =
    sprintHistory.length > 0
      ? Math.round(
          sprintHistory.reduce(
            (sum, sprint) => sum + sprint.completedPoints,
            0
          ) / sprintHistory.length
        )
      : 0;

  // Pour simplifier, on garde les autres métriques inchangées
  // Dans une vraie implémentation, on devrait re-filtrer toutes les données
  return {
    ...analytics,
    velocityMetrics: {
      ...analytics.velocityMetrics,
      sprintHistory,
      averageVelocity,
    },
  };
}

/**
 * Retourne un label descriptif pour la période sélectionnée
 */
export function getPeriodLabel(period: PeriodFilter): string {
  switch (period) {
    case '7d':
      return 'Derniers 7 jours';
    case '30d':
      return 'Derniers 30 jours';
    case '3m':
      return 'Derniers 3 mois';
    case 'current':
      return 'Sprint actuel';
    default:
      return 'Période inconnue';
  }
}

/**
 * Retourne des informations sur la période pour l'affichage
 */
export function getPeriodInfo(period: PeriodFilter): {
  label: string;
  description: string;
  icon: string;
} {
  switch (period) {
    case '7d':
      return {
        label: 'Derniers 7 jours',
        description: 'Vue hebdomadaire des métriques',
        icon: '📅',
      };
    case '30d':
      return {
        label: 'Derniers 30 jours',
        description: 'Vue mensuelle des métriques',
        icon: '📊',
      };
    case '3m':
      return {
        label: 'Derniers 3 mois',
        description: 'Vue trimestrielle des métriques',
        icon: '📈',
      };
    case 'current':
      return {
        label: 'Sprint actuel',
        description: 'Focus sur le sprint en cours',
        icon: '🎯',
      };
    default:
      return {
        label: 'Période inconnue',
        description: '',
        icon: '❓',
      };
  }
}
