import { supabase } from './supabase';
import { supabaseAdmin } from './supabase-admin';

export interface UserPermissions {
  user_id: string;
  is_admin: boolean;
  is_super_admin: boolean;
  created_at: string;
  updated_at: string;
}

export const authService = {
  // Vérifier si l'utilisateur actuel est connecté
  async getCurrentUser() {
    const { data: { user }, error } = await supabase.auth.getUser();
    if (error) throw error;
    return user;
  },

  // Vérifier si l'utilisateur actuel est admin
  async isAdmin(): Promise<boolean> {
    try {
      const user = await this.getCurrentUser();
      if (!user) {
        console.log('🔍 isAdmin: Aucun utilisateur connecté');
        return false;
      }

      console.log('🔍 isAdmin: Vérification pour utilisateur:', user.id, user.email);
      
      const { data, error } = await supabase
        .from('user_permissions')
        .select('is_admin')
        .eq('user_id', user.id)
        .single();

      if (error) {
        console.error('❌ isAdmin: Erreur lors de la vérification:', error);
        return false;
      }
      
      console.log('✅ isAdmin: Utilisateur trouvé dans user_permissions:', !!data);
      return data?.is_admin || false;
    } catch (error) {
      console.error('❌ isAdmin: Exception:', error);
      return false;
    }
  },

  // Vérifier si l'utilisateur actuel est super admin
  async isSuperAdmin(): Promise<boolean> {
    try {
      const user = await this.getCurrentUser();
      if (!user) return false;

      const { data, error } = await supabase
        .from('user_permissions')
        .select('is_super_admin')
        .eq('user_id', user.id)
        .single();

      if (error) return false;
      return data?.is_super_admin || false;
    } catch {
      return false;
    }
  },

  // Obtenir les permissions de l'utilisateur actuel
  async getCurrentPermissions(): Promise<UserPermissions | null> {
    try {
      const user = await this.getCurrentUser();
      if (!user) return null;

      const { data, error } = await supabase
        .from('user_permissions')
        .select('*')
        .eq('user_id', user.id)
        .single();

      if (error) return null;
      return data;
    } catch {
      return null;
    }
  },

  // Connexion
  async signIn(email: string, password: string) {
    const { data, error } = await supabase.auth.signInWithPassword({
      email,
      password,
    });
    if (error) throw error;
    return data;
  },

  // Déconnexion
  async signOut() {
    const { error } = await supabase.auth.signOut();
    if (error) throw error;
  },

  // Inscription (pour les tests)
  async signUp(email: string, password: string) {
    const { data, error } = await supabase.auth.signUp({
      email,
      password,
    });
    if (error) throw error;
    return data;
  },

  // Créer un utilisateur admin (côté serveur uniquement)
  async createAdminUser(email: string, password: string): Promise<{ user: any; permissions: UserPermissions }> {
    // Créer l'utilisateur dans auth.users
    const { data: userData, error: userError } = await supabaseAdmin.auth.admin.createUser({
      email,
      password,
      email_confirm: true
    });

    if (userError) throw userError;
    if (!userData.user) throw new Error('Utilisateur non créé');

    // Créer les permissions admin
    const { data: permissionsData, error: permissionsError } = await supabaseAdmin
      .from('user_permissions')
      .insert({
        user_id: userData.user.id,
        is_admin: true,
        is_super_admin: true
      })
      .select()
      .single();

    if (permissionsError) throw permissionsError;

    return {
      user: userData.user,
      permissions: permissionsData
    };
  }
};