'use server';

import { userPreferencesService } from '@/services/core/user-preferences';
import { revalidatePath } from 'next/cache';
import { tfsService, TfsConfig } from '@/services/integrations/tfs/tfs';
import { getServerSession } from 'next-auth';
import { authOptions } from '@/lib/auth';

/**
 * Sauvegarde la configuration TFS
 */
export async function saveTfsConfig(config: TfsConfig) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return { success: false, error: 'Non authentifié' };
    }

    await userPreferencesService.saveTfsConfig(session.user.id, config);

    // Réinitialiser le service pour prendre en compte la nouvelle config
    tfsService.reset();

    revalidatePath('/settings/integrations');
    return {
      success: true,
      message: 'Configuration TFS sauvegardée avec succès',
    };
  } catch (error) {
    console.error('Erreur sauvegarde config TFS:', error);
    return {
      success: false,
      error:
        error instanceof Error ? error.message : 'Erreur lors de la sauvegarde',
    };
  }
}

/**
 * Récupère la configuration TFS
 */
export async function getTfsConfig() {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return { success: false, error: 'Non authentifié' };
    }

    const config = await userPreferencesService.getTfsConfig(session.user.id);
    return { success: true, data: config };
  } catch (error) {
    console.error('Erreur récupération config TFS:', error);
    return {
      success: false,
      error:
        error instanceof Error
          ? error.message
          : 'Erreur lors de la récupération',
      data: {
        enabled: false,
        organizationUrl: '',
        projectName: '',
        personalAccessToken: '',
        repositories: [],
        ignoredRepositories: [],
      },
    };
  }
}

/**
 * Sauvegarde les préférences du scheduler TFS
 */
export async function saveTfsSchedulerConfig(
  tfsAutoSync: boolean,
  tfsSyncInterval: 'hourly' | 'daily' | 'weekly'
) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return { success: false, error: 'Non authentifié' };
    }

    await userPreferencesService.saveTfsSchedulerConfig(
      session.user.id,
      tfsAutoSync,
      tfsSyncInterval
    );
    revalidatePath('/settings/integrations');
    return {
      success: true,
      message: 'Configuration scheduler TFS mise à jour',
    };
  } catch (error) {
    console.error('Erreur sauvegarde scheduler TFS:', error);
    return {
      success: false,
      error:
        error instanceof Error
          ? error.message
          : 'Erreur lors de la sauvegarde du scheduler',
    };
  }
}

/**
 * Lance la synchronisation manuelle des Pull Requests TFS
 */
export async function syncTfsPullRequests() {
  try {
    // Récupérer l'utilisateur connecté
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return {
        success: false,
        error: 'Utilisateur non authentifié',
      };
    }

    // Lancer la synchronisation via le service singleton
    const result = await tfsService.syncTasks(session.user.id);

    if (result.success) {
      revalidatePath('/');
      revalidatePath('/settings/integrations');
      return {
        success: true,
        message: `Synchronisation terminée: ${result.pullRequestsCreated} créées, ${result.pullRequestsUpdated} mises à jour, ${result.pullRequestsDeleted} supprimées`,
        data: result,
      };
    } else {
      return {
        success: false,
        error: result.errors.join(', ') || 'Erreur lors de la synchronisation',
      };
    }
  } catch (error) {
    console.error('Erreur sync TFS:', error);
    return {
      success: false,
      error:
        error instanceof Error
          ? error.message
          : 'Erreur de connexion lors de la synchronisation',
    };
  }
}

/**
 * Supprime toutes les tâches TFS de la base de données locale
 */
export async function deleteAllTfsTasks() {
  try {
    // Supprimer toutes les tâches TFS via le service singleton
    const result = await tfsService.deleteAllTasks();

    if (result.success) {
      revalidatePath('/');
      revalidatePath('/settings/integrations');
      return {
        success: true,
        message: `${result.deletedCount} tâche(s) TFS supprimée(s) avec succès`,
        data: { deletedCount: result.deletedCount },
      };
    } else {
      return {
        success: false,
        error: result.error || 'Erreur lors de la suppression',
      };
    }
  } catch (error) {
    console.error('Erreur suppression TFS:', error);
    return {
      success: false,
      error:
        error instanceof Error
          ? error.message
          : 'Erreur de connexion lors de la suppression',
    };
  }
}
