import { Alert } from 'react-native';
import { supabase } from '../lib/supabase';

export const authAPI = {
  // Login Funktion
  login: async (email: string, password: string) => {
    try {
      console.log('Versuche Anmeldung für:', email);
      
      const { data, error } = await supabase.auth.signInWithPassword({
        email: email.trim(),
        password: password,
      });

      if (error) {
        console.error('Anmeldung fehlgeschlagen:', error.message);
        
        if (error.message.includes('Invalid login credentials')) {
          Alert.alert('Anmeldung fehlgeschlagen', 'E-Mail oder Passwort ist falsch');
        } else if (error.message.includes('Email not confirmed')) {
          Alert.alert('E-Mail nicht bestätigt', 'Bitte bestätigen Sie Ihre E-Mail-Adresse');
        } else {
          Alert.alert('Anmeldung fehlgeschlagen', error.message);
        }
        return null;
      }

      console.log('Anmeldung erfolgreich für:', data.user?.email);

      // Update last_login in users table
      if (data.user) {
        await supabase
          .from('users')
          .update({ last_login: new Date().toISOString() })
          .eq('id', data.user.id);
      }

      return data.user;
    } catch (error) {
      console.error('Unerwarteter Fehler bei der Anmeldung:', error);
      Alert.alert('Fehler', 'Ein unerwarteter Fehler ist aufgetreten. Bitte versuche es später erneut.');
      return null;
    }
  },

  // Register Funktion
  register: async (email: string, password: string, displayName: string) => {
    try {
      console.log('Versuche Registrierung für:', email);
      
      const { data, error } = await supabase.auth.signUp({
        email: email.trim(),
        password: password,
        options: {
          data: {
            display_name: displayName.trim() || undefined,
          }
        }
      });

      if (error) {
        console.error('Registrierung fehlgeschlagen:', error.message);
        
        if (error.message.includes('User already registered')) {
          Alert.alert('Registrierung fehlgeschlagen', 'Ein Benutzer mit dieser E-Mail existiert bereits');
        } else if (error.message.includes('Password should be at least')) {
          Alert.alert('Registrierung fehlgeschlagen', 'Das Passwort muss mindestens 6 Zeichen lang sein');
        } else if (error.message.includes('Unable to validate email address')) {
          Alert.alert('Registrierung fehlgeschlagen', 'Bitte geben Sie eine gültige E-Mail-Adresse ein');
        } else {
          Alert.alert('Registrierung fehlgeschlagen', error.message);
        }
        return null;
      }

      console.log('Registrierung erfolgreich für:', data.user?.email);
      
      if (data.user && !data.user.email_confirmed_at) {
        Alert.alert(
          'Registrierung erfolgreich!', 
          'Bitte überprüfen Sie Ihre E-Mails und klicken Sie auf den Bestätigungslink.'
        );
      } else {
        Alert.alert('Registrierung erfolgreich!', 'Sie können sich jetzt anmelden.');
      }

      return data.user;
    } catch (error) {
      console.error('Unerwarteter Fehler bei der Registrierung:', error);
      Alert.alert('Fehler', 'Ein unerwarteter Fehler ist aufgetreten. Bitte versuche es später erneut.');
      return null;
    }
  },

  // Logout Funktion
  logout: async () => {
    try {
      const { error } = await supabase.auth.signOut();
      if (error) {
        console.error('Logout-Fehler:', error);
        Alert.alert('Fehler', 'Fehler beim Abmelden');
      } else {
        console.log('Erfolgreich abgemeldet');
      }
    } catch (error) {
      console.error('Unerwarteter Logout-Fehler:', error);
      Alert.alert('Fehler', 'Ein unerwarteter Fehler ist beim Abmelden aufgetreten');
    }
  },

  // User Data laden
  loadUserData: async (userId: string) => {
    try {
      const { data, error } = await supabase
        .from('users')
        .select('*')
        .eq('id', userId)
        .single();

      if (error) {
        console.error('Fehler beim Laden der Benutzerdaten:', error);
        
        // Fallback: Erstelle temporäre userData basierend auf auth.users
        console.log('Fallback: Verwende auth.users Daten');
        const { data: authUser } = await supabase.auth.getUser();
        if (authUser.user) {
          return {
            id: authUser.user.id,
            email: authUser.user.email,
            display_name: authUser.user.user_metadata?.display_name || authUser.user.email,
            user_group: 'Admin', // Temporär: Alle als Admin setzen für Demo
            created_at: authUser.user.created_at,
            last_login: new Date().toISOString()
          };
        }
        return null;
      }

      return data;
    } catch (error) {
      console.error('Unerwarteter Fehler beim Laden der Benutzerdaten:', error);
      return null;
    }
  }
};

export const userAPI = {
  // Alle Benutzer laden
  loadAllUsers: async (currentUserId: string) => {
    try {
      // Versuche zuerst die users Tabelle
      const { data, error } = await supabase
        .from('users')
        .select('*')
        .order('created_at', { ascending: false });
      
      if (error) {
        console.error('Fehler beim Laden der Benutzer:', error);
        
        if (error.code === 'PGRST116' || error.code === 'PGRST106') {
          console.log('Fallback: users Tabelle nicht gefunden, verwende auth.users');
          
          // Fallback: Verwende auth.users über Admin API
          const { data: authUsers, error: authError } = await supabase.auth.admin.listUsers();
          
          if (authError) {
            console.error('Auch auth.users Admin API fehlgeschlagen:', authError);
            return [];
          }
          
          // Konvertiere auth.users zu users Format
          return authUsers.users.map(user => ({
            id: user.id,
            email: user.email,
            display_name: user.user_metadata?.display_name || user.email,
            user_group: user.email?.includes('admin') ? 'Admin' : 'Benutzer', // Einfache Heuristik
            created_at: user.created_at,
            last_login: user.last_sign_in_at,
            updated_at: user.updated_at
          }));
        } else {
          return [];
        }
      }

      console.log('Benutzer erfolgreich aus users Tabelle geladen:', data?.length);
      return data || [];
    } catch (error) {
      console.error('Unerwarteter Fehler beim Laden der Benutzer:', error);
      return [];
    }
  },

  // Benutzergruppe aktualisieren
  updateUserGroup: async (userId: string, userEmail: string, currentGroup: string) => {
    const groups = ['Benutzer', 'Trainer', 'Admin'] as const;
    
    return new Promise<void>((resolve) => {
      Alert.alert(
        'Benutzergruppe ändern',
        `Benutzergruppe für "${userEmail}" ändern:`,
        [
          { text: 'Abbrechen', style: 'cancel', onPress: () => resolve() },
          ...groups.map(group => ({
            text: group + (group === currentGroup ? ' (aktuell)' : ''),
            onPress: async () => {
              if (group === currentGroup) {
                resolve();
                return;
              }
              
              try {
                const { error } = await supabase
                  .from('users')
                  .update({ 
                    user_group: group,
                    updated_at: new Date().toISOString()
                  })
                  .eq('id', userId);
                
                if (error) {
                  console.error('Fehler beim Ändern der Benutzergruppe:', error);
                  Alert.alert('Fehler', 'Benutzergruppe konnte nicht geändert werden: ' + error.message);
                } else {
                  Alert.alert('Erfolg', `Benutzergruppe wurde zu "${group}" geändert`);
                }
              } catch (error) {
                console.error('Unerwarteter Fehler beim Ändern der Benutzergruppe:', error);
                Alert.alert('Fehler', 'Ein unerwarteter Fehler ist aufgetreten');
              }
              resolve();
            }
          }))
        ]
      );
    });
  },

  // Benutzer löschen
  deleteUser: async (userId: string, userEmail: string) => {
    return new Promise<void>((resolve) => {
      Alert.alert(
        'Benutzer löschen',
        `Möchten Sie den Benutzer "${userEmail}" wirklich löschen?\n\nDieser Vorgang kann nicht rückgängig gemacht werden.`,
        [
          { text: 'Abbrechen', style: 'cancel', onPress: () => resolve() },
          {
            text: 'Löschen',
            style: 'destructive',
            onPress: async () => {
              try {
                console.log('Lösche Benutzer:', userId);
                
                // Lösche aus der users Tabelle (dies wird durch CASCADE auch den auth.users Eintrag löschen)
                const { error } = await supabase
                  .from('users')
                  .delete()
                  .eq('id', userId);
                
                if (error) {
                  console.error('Fehler beim Löschen des Benutzers:', error);
                  Alert.alert('Fehler', 'Benutzer konnte nicht gelöscht werden: ' + error.message);
                } else {
                  Alert.alert('Erfolg', 'Benutzer wurde erfolgreich gelöscht');
                }
              } catch (error) {
                console.error('Unerwarteter Fehler beim Löschen:', error);
                Alert.alert('Fehler', 'Ein unerwarteter Fehler ist aufgetreten');
              }
              resolve();
            }
          }
        ]
      );
    });
  }
};