'use server';

import { tasksService } from '@/services/task-management/tasks';
import { revalidatePath } from 'next/cache';
import { TaskStatus, TaskPriority } from '@/lib/types';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/lib/auth';

export type ActionResult<T = unknown> = {
  success: boolean;
  data?: T;
  error?: string;
};

/**
 * Helper pour vérifier l'authentification
 */
async function getAuthenticatedUser() {
  const session = await getServerSession(authOptions);
  if (!session?.user?.id) {
    throw new Error('Non authentifié');
  }
  return session.user.id;
}

/**
 * Helper pour vérifier qu'une tâche appartient au user connecté
 */
async function verifyTaskOwnership(taskId: string): Promise<boolean> {
  try {
    const userId = await getAuthenticatedUser();
    const tasks = await tasksService.getTasks(userId);
    return tasks.some((t) => t.id === taskId);
  } catch {
    return false;
  }
}

/**
 * Server Action pour mettre à jour le statut d'une tâche
 */
export async function updateTaskStatus(
  taskId: string,
  status: TaskStatus
): Promise<ActionResult> {
  try {
    // Vérifier l'authentification et récupérer l'ID du user
    const userId = await getAuthenticatedUser();

    // Vérifier que la tâche appartient au user connecté
    const isOwner = await verifyTaskOwnership(taskId);
    if (!isOwner) {
      return { success: false, error: 'Tâche non trouvée ou non autorisée' };
    }

    const updatedTask = await tasksService.updateTask(userId, taskId, {
      status,
    });

    // Revalidation automatique du cache
    revalidatePath('/');
    revalidatePath('/tasks');

    return { success: true, data: updatedTask };
  } catch (error) {
    console.error('Error updating task status:', error);
    return {
      success: false,
      error:
        error instanceof Error ? error.message : 'Failed to update task status',
    };
  }
}

/**
 * Server Action pour mettre à jour le titre d'une tâche
 */
export async function updateTaskTitle(
  taskId: string,
  title: string
): Promise<ActionResult> {
  try {
    if (!title.trim()) {
      return { success: false, error: 'Title cannot be empty' };
    }

    // Vérifier l'authentification et récupérer l'ID du user
    const userId = await getAuthenticatedUser();

    // Vérifier que la tâche appartient au user connecté
    const isOwner = await verifyTaskOwnership(taskId);
    if (!isOwner) {
      return { success: false, error: 'Tâche non trouvée ou non autorisée' };
    }

    const task = await tasksService.updateTask(userId, taskId, {
      title: title.trim(),
    });

    // Revalidation automatique du cache
    revalidatePath('/');
    revalidatePath('/tasks');

    return { success: true, data: task };
  } catch (error) {
    console.error('Error updating task title:', error);
    return {
      success: false,
      error:
        error instanceof Error ? error.message : 'Failed to update task title',
    };
  }
}

/**
 * Server Action pour supprimer une tâche
 */
export async function deleteTask(taskId: string): Promise<ActionResult> {
  try {
    // Vérifier l'authentification et récupérer l'ID du user
    const userId = await getAuthenticatedUser();

    // Vérifier que la tâche appartient au user connecté
    const isOwner = await verifyTaskOwnership(taskId);
    if (!isOwner) {
      return { success: false, error: 'Tâche non trouvée ou non autorisée' };
    }

    await tasksService.deleteTask(userId, taskId);

    // Revalidation automatique du cache
    revalidatePath('/');
    revalidatePath('/tasks');

    return { success: true };
  } catch (error) {
    console.error('Error deleting task:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to delete task',
    };
  }
}

/**
 * Server Action pour mettre à jour une tâche complète (formulaire d'édition)
 */
export async function updateTask(data: {
  taskId: string;
  title?: string;
  description?: string;
  status?: TaskStatus;
  priority?: TaskPriority;
  tags?: string[];
  primaryTagId?: string;
  dueDate?: Date;
}): Promise<ActionResult> {
  try {
    // Vérifier l'authentification et récupérer l'ID du user
    const userId = await getAuthenticatedUser();

    // Vérifier que la tâche appartient au user connecté
    const isOwner = await verifyTaskOwnership(data.taskId);
    if (!isOwner) {
      return { success: false, error: 'Tâche non trouvée ou non autorisée' };
    }

    const updateData: Record<string, unknown> = {};

    if (data.title !== undefined) {
      if (!data.title.trim()) {
        return { success: false, error: 'Title cannot be empty' };
      }
      updateData.title = data.title.trim();
    }

    if (data.description !== undefined)
      updateData.description = data.description.trim();
    if (data.status !== undefined) updateData.status = data.status;
    if (data.priority !== undefined) updateData.priority = data.priority;
    if (data.tags !== undefined) updateData.tags = data.tags;
    if (data.primaryTagId !== undefined)
      updateData.primaryTagId = data.primaryTagId;
    if (data.dueDate !== undefined) updateData.dueDate = data.dueDate;

    const task = await tasksService.updateTask(userId, data.taskId, updateData);

    // Revalidation automatique du cache
    revalidatePath('/');
    revalidatePath('/tasks');

    return { success: true, data: task };
  } catch (error) {
    console.error('Error updating task:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to update task',
    };
  }
}

/**
 * Server Action pour créer une nouvelle tâche
 */
export async function createTask(data: {
  title: string;
  description?: string;
  status?: TaskStatus;
  priority?: TaskPriority;
  tags?: string[];
  primaryTagId?: string;
}): Promise<ActionResult> {
  try {
    if (!data.title.trim()) {
      return { success: false, error: 'Title is required' };
    }

    // Vérifier l'authentification et récupérer l'ID du user
    const userId = await getAuthenticatedUser();

    const task = await tasksService.createTask({
      title: data.title.trim(),
      description: data.description?.trim() || '',
      status: data.status || 'todo',
      priority: data.priority || 'medium',
      tags: data.tags || [],
      primaryTagId: data.primaryTagId,
      ownerId: userId, // Assigner la tâche au user connecté
    });

    // Revalidation automatique du cache
    revalidatePath('/');
    revalidatePath('/tasks');

    return { success: true, data: task };
  } catch (error) {
    console.error('Error creating task:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to create task',
    };
  }
}
