workshop-manager/src/actions/weekly-checkin.ts

'use server';

import { revalidatePath, revalidateTag } from 'next/cache';
import { auth } from '@/lib/auth';
import * as weeklyCheckInService from '@/services/weekly-checkin';
import { sessionsListTag } from '@/lib/cache-tags';
import { broadcastToWeeklyCheckInSession } from '@/app/api/weekly-checkin/[id]/subscribe/route';
import type { WeeklyCheckInCategory, Emotion } from '@prisma/client';

// ============================================
// Session Actions
// ============================================

export async function createWeeklyCheckInSession(data: {
  title: string;
  participant: string;
  date?: Date;
}) {
  const session = await auth();
  if (!session?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  try {
    const weeklyCheckInSession = await weeklyCheckInService.createWeeklyCheckInSession(
      session.user.id,
      data
    );
    try {
      await weeklyCheckInService.shareWeeklyCheckInSession(
        weeklyCheckInSession.id,
        session.user.id,
        data.participant,
        'EDITOR'
      );
    } catch (shareError) {
      console.error('Auto-share failed:', shareError);
    }
    revalidatePath('/weekly-checkin');
    revalidatePath('/sessions');
    revalidateTag(sessionsListTag(session.user.id), 'default');
    return { success: true, data: weeklyCheckInSession };
  } catch (error) {
    console.error('Error creating weekly check-in session:', error);
    return { success: false, error: 'Erreur lors de la création' };
  }
}

export async function updateWeeklyCheckInSession(
  sessionId: string,
  data: { title?: string; participant?: string; date?: Date }
) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  try {
    await weeklyCheckInService.updateWeeklyCheckInSession(sessionId, authSession.user.id, data);

    // Emit event for real-time sync
    await weeklyCheckInService.createWeeklyCheckInSessionEvent(
      sessionId,
      authSession.user.id,
      'SESSION_UPDATED',
      data
    );

    broadcastToWeeklyCheckInSession(sessionId, { type: 'SESSION_UPDATED' });
    revalidatePath(`/weekly-checkin/${sessionId}`);
    revalidatePath('/weekly-checkin');
    revalidatePath('/sessions');
    revalidateTag(sessionsListTag(authSession.user.id), 'default');
    return { success: true };
  } catch (error) {
    console.error('Error updating weekly check-in session:', error);
    return { success: false, error: 'Erreur lors de la mise à jour' };
  }
}

export async function deleteWeeklyCheckInSession(sessionId: string) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  try {
    await weeklyCheckInService.deleteWeeklyCheckInSession(sessionId, authSession.user.id);
    revalidatePath('/weekly-checkin');
    revalidatePath('/sessions');
    revalidateTag(sessionsListTag(authSession.user.id), 'default');
    return { success: true };
  } catch (error) {
    console.error('Error deleting weekly check-in session:', error);
    return { success: false, error: 'Erreur lors de la suppression' };
  }
}

// ============================================
// Item Actions
// ============================================

export async function createWeeklyCheckInItem(
  sessionId: string,
  data: { content: string; category: WeeklyCheckInCategory; emotion?: Emotion }
) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  // Check edit permission
  const canEdit = await weeklyCheckInService.canEditWeeklyCheckInSession(
    sessionId,
    authSession.user.id
  );
  if (!canEdit) {
    return { success: false, error: 'Permission refusée' };
  }

  try {
    const item = await weeklyCheckInService.createWeeklyCheckInItem(sessionId, data);

    // Emit event for real-time sync
    await weeklyCheckInService.createWeeklyCheckInSessionEvent(
      sessionId,
      authSession.user.id,
      'ITEM_CREATED',
      {
        itemId: item.id,
        content: item.content,
        category: item.category,
        emotion: item.emotion,
      }
    );

    broadcastToWeeklyCheckInSession(sessionId, { type: 'ITEM_CREATED' });
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true, data: item };
  } catch (error) {
    console.error('Error creating weekly check-in item:', error);
    return { success: false, error: 'Erreur lors de la création' };
  }
}

export async function updateWeeklyCheckInItem(
  itemId: string,
  sessionId: string,
  data: { content?: string; category?: WeeklyCheckInCategory; emotion?: Emotion }
) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  // Check edit permission
  const canEdit = await weeklyCheckInService.canEditWeeklyCheckInSession(
    sessionId,
    authSession.user.id
  );
  if (!canEdit) {
    return { success: false, error: 'Permission refusée' };
  }

  try {
    const item = await weeklyCheckInService.updateWeeklyCheckInItem(itemId, data);

    // Emit event for real-time sync
    await weeklyCheckInService.createWeeklyCheckInSessionEvent(
      sessionId,
      authSession.user.id,
      'ITEM_UPDATED',
      {
        itemId: item.id,
        ...data,
      }
    );

    broadcastToWeeklyCheckInSession(sessionId, { type: 'ITEM_UPDATED' });
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true, data: item };
  } catch (error) {
    console.error('Error updating weekly check-in item:', error);
    return { success: false, error: 'Erreur lors de la mise à jour' };
  }
}

export async function deleteWeeklyCheckInItem(itemId: string, sessionId: string) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  // Check edit permission
  const canEdit = await weeklyCheckInService.canEditWeeklyCheckInSession(
    sessionId,
    authSession.user.id
  );
  if (!canEdit) {
    return { success: false, error: 'Permission refusée' };
  }

  try {
    await weeklyCheckInService.deleteWeeklyCheckInItem(itemId);

    // Emit event for real-time sync
    await weeklyCheckInService.createWeeklyCheckInSessionEvent(
      sessionId,
      authSession.user.id,
      'ITEM_DELETED',
      { itemId }
    );

    broadcastToWeeklyCheckInSession(sessionId, { type: 'ITEM_DELETED' });
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true };
  } catch (error) {
    console.error('Error deleting weekly check-in item:', error);
    return { success: false, error: 'Erreur lors de la suppression' };
  }
}

export async function moveWeeklyCheckInItem(
  itemId: string,
  sessionId: string,
  newCategory: WeeklyCheckInCategory,
  newOrder: number
) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  // Check edit permission
  const canEdit = await weeklyCheckInService.canEditWeeklyCheckInSession(
    sessionId,
    authSession.user.id
  );
  if (!canEdit) {
    return { success: false, error: 'Permission refusée' };
  }

  try {
    await weeklyCheckInService.moveWeeklyCheckInItem(itemId, newCategory, newOrder);

    // Emit event for real-time sync
    await weeklyCheckInService.createWeeklyCheckInSessionEvent(
      sessionId,
      authSession.user.id,
      'ITEM_MOVED',
      {
        itemId,
        category: newCategory,
        order: newOrder,
      }
    );

    broadcastToWeeklyCheckInSession(sessionId, { type: 'ITEM_MOVED' });
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true };
  } catch (error) {
    console.error('Error moving weekly check-in item:', error);
    return { success: false, error: 'Erreur lors du déplacement' };
  }
}

export async function reorderWeeklyCheckInItems(
  sessionId: string,
  category: WeeklyCheckInCategory,
  itemIds: string[]
) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  // Check edit permission
  const canEdit = await weeklyCheckInService.canEditWeeklyCheckInSession(
    sessionId,
    authSession.user.id
  );
  if (!canEdit) {
    return { success: false, error: 'Permission refusée' };
  }

  try {
    await weeklyCheckInService.reorderWeeklyCheckInItems(sessionId, category, itemIds);

    // Emit event for real-time sync
    await weeklyCheckInService.createWeeklyCheckInSessionEvent(
      sessionId,
      authSession.user.id,
      'ITEMS_REORDERED',
      { category, itemIds }
    );

    broadcastToWeeklyCheckInSession(sessionId, { type: 'ITEMS_REORDERED' });
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true };
  } catch (error) {
    console.error('Error reordering weekly check-in items:', error);
    return { success: false, error: 'Erreur lors du réordonnancement' };
  }
}

// ============================================
// Sharing Actions
// ============================================

export async function shareWeeklyCheckInSession(
  sessionId: string,
  targetEmail: string,
  role: 'VIEWER' | 'EDITOR' = 'EDITOR'
) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  try {
    const share = await weeklyCheckInService.shareWeeklyCheckInSession(
      sessionId,
      authSession.user.id,
      targetEmail,
      role
    );
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true, data: share };
  } catch (error) {
    console.error('Error sharing weekly check-in session:', error);
    const message = error instanceof Error ? error.message : 'Erreur lors du partage';
    return { success: false, error: message };
  }
}

export async function removeWeeklyCheckInShare(sessionId: string, shareUserId: string) {
  const authSession = await auth();
  if (!authSession?.user?.id) {
    return { success: false, error: 'Non autorisé' };
  }

  try {
    await weeklyCheckInService.removeWeeklyCheckInShare(
      sessionId,
      authSession.user.id,
      shareUserId
    );
    revalidatePath(`/weekly-checkin/${sessionId}`);
    return { success: true };
  } catch (error) {
    console.error('Error removing weekly check-in share:', error);
    return { success: false, error: 'Erreur lors de la suppression du partage' };
  }
}