import { cookies } from "next/headers";
import { NextResponse } from "next/server";
import { UserProfile } from "@/lib/types";
import { userService } from "@/services/user-service";

export const COOKIE_NAME = "session_token" as const;

export const COOKIE_CONFIG = {
  httpOnly: true,
  secure: process.env.NODE_ENV === "production",
  sameSite: "lax" as const,
  maxAge: 60 * 60 * 24 * 7, // 7 jours
  path: "/",
} as const;

/**
 * Service d'authentification côté serveur
 * Implémente les méthodes qui nécessitent next/headers
 */
export class AuthService {
  /**
   * Récupère l'UUID utilisateur depuis le cookie côté serveur
   */
  static async getUserUuidFromCookie(): Promise<string | null> {
    const cookieStore = await cookies();
    const userUuidCookie = cookieStore.get(COOKIE_NAME);
    return userUuidCookie?.value || null;
  }

  /**
   * Vérifie si l'utilisateur est authentifié côté serveur
   */
  static async isUserAuthenticated(): Promise<boolean> {
    const userUuid = await this.getUserUuidFromCookie();
    return !!userUuid;
  }

  /**
   * Vérifie l'authentification et retourne le profil utilisateur
   * @throws {Error} avec status 401 si non authentifié ou 404 si utilisateur non trouvé
   */
  static async requireAuthenticatedUser(): Promise<{
    userUuid: string;
    userProfile: UserProfile;
  }> {
    const userUuid = await this.getUserUuidFromCookie();

    if (!userUuid) {
      const error = new Error("Utilisateur non authentifié");
      (error as any).status = 401;
      throw error;
    }

    const userProfile = await userService.getUserByUuid(userUuid);
    if (!userProfile) {
      const error = new Error("Utilisateur introuvable");
      (error as any).status = 404;
      throw error;
    }

    return { userUuid, userProfile };
  }

  

  /**
   * Crée une nouvelle session pour un utilisateur et retourne la réponse avec le cookie
   */
  static async createSession(userUuid: string, response: NextResponse): Promise<NextResponse> {
    // Pour l'instant, on utilise l'UUID comme token de session
    // Plus tard, on pourra implémenter un système de JWT ou de sessions en base
    const sessionToken = userUuid;
    response.cookies.set(COOKIE_NAME, sessionToken, COOKIE_CONFIG);
    return response;
  }

  /**
   * Supprime la session et retourne la réponse avec le cookie expiré
   */
  static removeSession(response: NextResponse): NextResponse {
    response.cookies.set(COOKIE_NAME, "", { ...COOKIE_CONFIG, maxAge: 0 });
    return response;
  }

  /**
   * Valide un token de session et retourne l'UUID utilisateur
   */
  static async validateSession(sessionToken: string): Promise<string | null> {
    // Pour l'instant, on considère que le token est valide s'il correspond à un UUID
    // Plus tard, on pourra ajouter une validation plus robuste
    if (sessionToken && sessionToken.length > 0) {
      return sessionToken;
    }
    return null;
  }
}