towercontrol/src/actions/jira-filters.ts

'use server';

import { JiraAnalyticsService, JiraAnalyticsConfig } from '@/services/integrations/jira/analytics';
import { JiraAdvancedFiltersService } from '@/services/integrations/jira/advanced-filters';
import { userPreferencesService } from '@/services/core/user-preferences';
import { AvailableFilters, JiraAnalyticsFilters, JiraAnalytics } from '@/lib/types';
import { getServerSession } from 'next-auth';
import { authOptions } from '@/lib/auth';

export interface FiltersResult {
  success: boolean;
  data?: AvailableFilters;
  error?: string;
}

export interface FilteredAnalyticsResult {
  success: boolean;
  data?: JiraAnalytics;
  error?: string;
}

/**
 * Récupère les filtres disponibles depuis les données Jira
 */
export async function getAvailableJiraFilters(): Promise<FiltersResult> {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return { success: false, error: 'Non authentifié' };
    }

    // Récupérer la config Jira
    const jiraConfig = await userPreferencesService.getJiraConfig(session.user.id);
    
    if (!jiraConfig?.baseUrl || !jiraConfig?.email || !jiraConfig?.apiToken || !jiraConfig?.projectKey) {
      return {
        success: false,
        error: 'Configuration Jira incomplète'
      };
    }

    // Récupérer toutes les issues du projet pour extraire les filtres
    if (!jiraConfig.baseUrl || !jiraConfig.projectKey) {
      return { success: false, error: 'Configuration Jira incomplète' };
    }
    
    const analyticsService = new JiraAnalyticsService(jiraConfig as JiraAnalyticsConfig);
    
    // Récupérer la liste des issues pour extraire les filtres
    const allIssues = await analyticsService.getAllProjectIssues();
    
    // Extraire les filtres disponibles
    const availableFilters = JiraAdvancedFiltersService.extractAvailableFilters(allIssues);

    return {
      success: true,
      data: availableFilters
    };
  } catch (error) {
    console.error('❌ Erreur lors de la récupération des filtres:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Erreur inconnue'
    };
  }
}

/**
 * Applique des filtres aux analytics et retourne les données filtrées
 */
export async function getFilteredJiraAnalytics(filters: Partial<JiraAnalyticsFilters>): Promise<FilteredAnalyticsResult> {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return { success: false, error: 'Non authentifié' };
    }

    // Récupérer la config Jira
    const jiraConfig = await userPreferencesService.getJiraConfig(session.user.id);
    
    if (!jiraConfig?.baseUrl || !jiraConfig?.email || !jiraConfig?.apiToken || !jiraConfig?.projectKey) {
      return {
        success: false,
        error: 'Configuration Jira incomplète'
      };
    }

    // Récupérer les analytics originales
    if (!jiraConfig.baseUrl || !jiraConfig.projectKey) {
      return { success: false, error: 'Configuration Jira incomplète' };
    }
    
    const analyticsService = new JiraAnalyticsService(jiraConfig as JiraAnalyticsConfig);
    const originalAnalytics = await analyticsService.getProjectAnalytics();
    
    // Si aucun filtre actif, retourner les données originales
    if (!JiraAdvancedFiltersService.hasActiveFilters(filters)) {
      return {
        success: true,
        data: originalAnalytics
      };
    }

    // Récupérer toutes les issues pour appliquer les filtres
    const allIssues = await analyticsService.getAllProjectIssues();
    
    // Appliquer les filtres
    const filteredAnalytics = JiraAdvancedFiltersService.applyFiltersToAnalytics(
      originalAnalytics,
      filters,
      allIssues
    );

    return {
      success: true,
      data: filteredAnalytics
    };
  } catch (error) {
    console.error('❌ Erreur lors du filtrage des analytics:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Erreur inconnue'
    };
  }
}