import { NextResponse } from 'next/server';
import {
  createJiraService,
  JiraService,
} from '@/services/integrations/jira/jira';
import { userPreferencesService } from '@/services/core/user-preferences';
import { jiraScheduler } from '@/services/integrations/jira/scheduler';
import { getServerSession } from 'next-auth';
import { authOptions } from '@/lib/auth';

/**
 * Route POST /api/jira/sync
 * Synchronise les tickets Jira avec la base locale
 * Supporte aussi les actions du scheduler
 */
export async function POST(request: Request) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return NextResponse.json(
        { success: false, error: 'Non authentifié' },
        { status: 401 }
      );
    }

    // Vérifier s'il y a des actions spécifiques (scheduler)
    const body = await request.json().catch(() => ({}));
    const { action, ...params } = body;

    // Actions du scheduler
    if (action) {
      switch (action) {
        case 'scheduler':
          if (params.enabled) {
            await jiraScheduler.start(session.user.id);
          } else {
            jiraScheduler.stop();
          }
          return NextResponse.json({
            success: true,
            data: await jiraScheduler.getStatus(session.user.id),
          });

        case 'config':
          await userPreferencesService.saveJiraSchedulerConfig(
            session.user.id,
            params.jiraAutoSync,
            params.jiraSyncInterval
          );
          // Redémarrer le scheduler si la config a changé
          await jiraScheduler.restart(session.user.id);
          return NextResponse.json({
            success: true,
            message: 'Configuration scheduler mise à jour',
            data: await jiraScheduler.getStatus(session.user.id),
          });

        default:
          return NextResponse.json(
            { success: false, error: 'Action inconnue' },
            { status: 400 }
          );
      }
    }

    // Synchronisation normale (manuelle)
    const jiraConfig = await userPreferencesService.getJiraConfig(
      session.user.id
    );

    let jiraService: JiraService | null = null;

    if (
      jiraConfig.enabled &&
      jiraConfig.baseUrl &&
      jiraConfig.email &&
      jiraConfig.apiToken
    ) {
      // Utiliser la config depuis la base de données
      jiraService = new JiraService({
        enabled: jiraConfig.enabled,
        baseUrl: jiraConfig.baseUrl,
        email: jiraConfig.email,
        apiToken: jiraConfig.apiToken,
        projectKey: jiraConfig.projectKey,
        ignoredProjects: jiraConfig.ignoredProjects || [],
      });
    } else {
      // Fallback sur les variables d'environnement
      jiraService = createJiraService();
    }

    if (!jiraService) {
      return NextResponse.json(
        {
          error:
            "Configuration Jira manquante. Configurez Jira dans les paramètres ou vérifiez les variables d'environnement.",
        },
        { status: 400 }
      );
    }

    console.log('🔄 Début de la synchronisation Jira manuelle...');

    // Tester la connexion d'abord
    const connectionOk = await jiraService.testConnection();
    if (!connectionOk) {
      return NextResponse.json(
        {
          error:
            'Impossible de se connecter à Jira. Vérifiez la configuration.',
        },
        { status: 401 }
      );
    }

    // Effectuer la synchronisation
    const syncResult = await jiraService.syncTasks(session.user.id);

    // Convertir SyncResult en JiraSyncResult pour le client
    // Utiliser les actions Jira originales si disponibles pour préserver les détails (changes, etc.)
    const actions =
      syncResult.jiraActions ||
      syncResult.actions.map((action) => ({
        type: action.type as 'created' | 'updated' | 'skipped' | 'deleted',
        taskKey: action.itemId.toString(),
        taskTitle: action.title,
        reason: action.message,
        changes: action.message ? [action.message] : undefined,
      }));

    const jiraSyncResult = {
      success: syncResult.success,
      tasksFound: syncResult.totalItems,
      tasksCreated: syncResult.stats.created,
      tasksUpdated: syncResult.stats.updated,
      tasksSkipped: syncResult.stats.skipped,
      tasksDeleted: syncResult.stats.deleted,
      errors: syncResult.errors,
      unknownStatuses: syncResult.unknownStatuses || [], // Nouveaux statuts inconnus
      actions,
    };

    if (syncResult.success) {
      return NextResponse.json({
        message: 'Synchronisation Jira terminée avec succès',
        data: jiraSyncResult,
      });
    } else {
      return NextResponse.json(
        {
          error: 'Synchronisation Jira terminée avec des erreurs',
          data: jiraSyncResult,
        },
        { status: 207 } // Multi-Status
      );
    }
  } catch (error) {
    console.error('❌ Erreur API sync Jira:', error);

    return NextResponse.json(
      {
        error: 'Erreur interne lors de la synchronisation',
        details: error instanceof Error ? error.message : 'Erreur inconnue',
      },
      { status: 500 }
    );
  }
}

/**
 * Route GET /api/jira/sync
 * Teste la connexion Jira
 */
export async function GET() {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return NextResponse.json(
        { success: false, error: 'Non authentifié' },
        { status: 401 }
      );
    }

    // Essayer d'abord la config depuis la base de données
    const jiraConfig = await userPreferencesService.getJiraConfig(
      session.user.id
    );

    let jiraService: JiraService | null = null;

    if (
      jiraConfig.enabled &&
      jiraConfig.baseUrl &&
      jiraConfig.email &&
      jiraConfig.apiToken
    ) {
      // Utiliser la config depuis la base de données
      jiraService = new JiraService({
        enabled: jiraConfig.enabled,
        baseUrl: jiraConfig.baseUrl,
        email: jiraConfig.email,
        apiToken: jiraConfig.apiToken,
        projectKey: jiraConfig.projectKey,
        ignoredProjects: jiraConfig.ignoredProjects || [],
      });
    } else {
      // Fallback sur les variables d'environnement
      jiraService = createJiraService();
    }

    if (!jiraService) {
      return NextResponse.json({
        connected: false,
        message: 'Configuration Jira manquante',
      });
    }

    const connected = await jiraService.testConnection();

    // Si connexion OK et qu'un projet est configuré, tester aussi le projet
    let projectValidation = null;
    if (connected && jiraConfig.projectKey) {
      projectValidation = await jiraService.validateProject(
        jiraConfig.projectKey
      );
    }

    // Récupérer aussi le statut du scheduler avec l'utilisateur connecté
    const schedulerStatus = await jiraScheduler.getStatus(session.user.id);

    return NextResponse.json({
      connected,
      message: connected
        ? 'Connexion Jira OK'
        : 'Impossible de se connecter à Jira',
      project: projectValidation
        ? {
            key: jiraConfig.projectKey,
            exists: projectValidation.exists,
            name: projectValidation.name,
            error: projectValidation.error,
          }
        : null,
      scheduler: schedulerStatus,
    });
  } catch (error) {
    console.error('❌ Erreur test connexion Jira:', error);

    return NextResponse.json({
      connected: false,
      message: 'Erreur lors du test de connexion',
      details: error instanceof Error ? error.message : 'Erreur inconnue',
    });
  }
}
