managarten/memoro/apps/mobile/features/location/locationService.ts

import * as Location from 'expo-location';
import AsyncStorage from '@react-native-async-storage/async-storage';

interface LocationData {
  latitude: number;
  longitude: number;
  timestamp: number;
}

/**
 * Fordert Standortberechtigungen vom Benutzer an
 * @returns {Promise<boolean>} True wenn Berechtigungen erteilt wurden
 */
export const requestLocationPermissions = async (): Promise<boolean> => {
  const { status } = await Location.requestForegroundPermissionsAsync();
  return status === 'granted';
};

/**
 * Ruft den aktuellen Standort des Geräts ab
 * @returns {Promise<LocationData | null>} Standortdaten oder null bei Fehler
 */
export const getCurrentLocation = async (): Promise<LocationData | null> => {
  try {
    const { coords, timestamp } = await Location.getCurrentPositionAsync({
      accuracy: Location.Accuracy.Balanced,
    });
    
    return {
      latitude: coords.latitude,
      longitude: coords.longitude,
      timestamp,
    };
  } catch (error) {
     
    console.debug('Fehler beim Abrufen des Standorts:', error);
    return null;
  }
};

/**
 * Speichert Standortdaten in der lokalen Speicherung
 * @param {LocationData} locationData Zu speichernde Standortdaten
 */
export const saveLocationData = async (locationData: LocationData): Promise<void> => {
  try {
    const existingDataString = await AsyncStorage.getItem('locationHistory');
    const existingData = existingDataString ? JSON.parse(existingDataString) : [];
    
    // Neuen Standort zur Historie hinzufügen
    const updatedData = [...existingData, locationData];
    
    // Maximal 100 Einträge speichern (kann angepasst werden)
    const limitedData = updatedData.slice(-100);
    
    await AsyncStorage.setItem('locationHistory', JSON.stringify(limitedData));
  } catch (error) {
     
    console.debug('Fehler beim Speichern des Standorts:', error);
  }
};

/**
 * Ruft die gespeicherte Standorthistorie ab
 * @returns {Promise<LocationData[]>} Array mit Standortdaten
 */
export const getLocationHistory = async (): Promise<LocationData[]> => {
  try {
    const dataString = await AsyncStorage.getItem('locationHistory');
    return dataString ? JSON.parse(dataString) : [];
  } catch (error) {
     
    console.debug('Fehler beim Abrufen der Standorthistorie:', error);
    return [];
  }
};

/**
 * Löscht die gesamte Standorthistorie
 */
export const clearLocationHistory = async (): Promise<void> => {
  try {
    await AsyncStorage.removeItem('locationHistory');
  } catch (error) {
     
    console.debug('Fehler beim Löschen der Standorthistorie:', error);
  }
};

/**
 * Prüft, ob die Standortspeicherung aktiviert ist und ruft ggf. den aktuellen Standort ab
 * @returns LocationData-Objekt oder null, wenn deaktiviert oder Fehler
 */
/**
 * Adressinformationen aus Reverse Geocoding
 */
export interface AddressInfo {
  street?: string;
  streetNumber?: string;
  postalCode?: string;
  city?: string;
  district?: string;
  region?: string;
  country?: string;
  name?: string;
  formattedAddress?: string;
}

/**
 * Erweiterte Standortdaten mit Adressinformationen
 */
export interface EnhancedLocationData extends LocationData {
  address?: AddressInfo;
}

/**
 * Führt ein Reverse Geocoding mit Expo Location durch
 * @param latitude Breitengrad
 * @param longitude Längengrad
 * @returns Adressinformationen oder null bei Fehler
 */
export const reverseGeocodeWithExpo = async (latitude: number, longitude: number): Promise<AddressInfo | null> => {
  try {
    const addressResults = await Location.reverseGeocodeAsync({
      latitude,
      longitude,
    });

    if (addressResults && addressResults.length > 0) {
      const addressData = addressResults[0];
      return {
        street: addressData.street || undefined,
        streetNumber: addressData.streetNumber || undefined,
        postalCode: addressData.postalCode || undefined,
        city: addressData.city || undefined,
        district: addressData.district || undefined,
        region: addressData.region || undefined,
        country: addressData.country || undefined,
        name: addressData.name || undefined,
        formattedAddress: [
          // Verwende addressData.name falls vorhanden, sonst kombiniere street + streetNumber
          addressData.name || [addressData.street, addressData.streetNumber].filter(Boolean).join(' '),
          [addressData.postalCode, addressData.city].filter(Boolean).join(' '),
          addressData.country
        ].filter(Boolean).join(', ')
      };
    }
    return null;
  } catch (error) {
     
    console.debug('Fehler beim Reverse Geocoding mit Expo:', error);
    return null;
  }
};

/**
 * Führt ein Reverse Geocoding mit OpenStreetMap/Nominatim durch
 * @param latitude Breitengrad
 * @param longitude Längengrad
 * @returns Adressinformationen oder null bei Fehler
 */
export const reverseGeocodeWithOSM = async (latitude: number, longitude: number): Promise<AddressInfo | null> => {
  try {
    const url = `https://nominatim.openstreetmap.org/reverse?format=json&lat=${latitude}&lon=${longitude}&addressdetails=1`;
    
    const response = await fetch(url, {
      headers: {
        'User-Agent': 'Memoro App' // OSM erfordert einen User-Agent
      }
    });
    
    if (!response.ok) {
      throw new Error(`OSM API responded with status: ${response.status}`);
    }
    
    const data = await response.json();
    
    if (data && data.address) {
      return {
        street: data.address.road || data.address.pedestrian || data.address.street,
        streetNumber: data.address.house_number,
        postalCode: data.address.postcode,
        city: data.address.city || data.address.town || data.address.village,
        district: data.address.suburb || data.address.neighbourhood,
        region: data.address.state,
        country: data.address.country,
        name: data.name,
        formattedAddress: data.display_name
      };
    }
    return null;
  } catch (error) {
     
    console.debug('Fehler beim Reverse Geocoding mit OSM:', error);
    return null;
  }
};

/**
 * Führt ein Reverse Geocoding durch und versucht, die beste verfügbare Adresse zu ermitteln
 * @param latitude Breitengrad
 * @param longitude Längengrad
 * @returns Adressinformationen oder null bei Fehler
 */
export const getAddressFromCoordinates = async (latitude: number, longitude: number): Promise<AddressInfo | null> => {
  try {
    // Zuerst mit Expo versuchen
    const expoResult = await reverseGeocodeWithExpo(latitude, longitude);
    
    // Wenn Expo ein gutes Ergebnis liefert, dieses verwenden
    if (expoResult && expoResult.street && expoResult.city) {
      return expoResult;
    }
    
    // Ansonsten mit OSM versuchen
    return await reverseGeocodeWithOSM(latitude, longitude);
  } catch (error) {
     
    console.debug('Fehler beim Reverse Geocoding:', error);
    return null;
  }
};

/**
 * Prüft, ob die Standortspeicherung aktiviert ist und ruft ggf. den aktuellen Standort ab
 * @param includeAddress Ob Adressinformationen abgerufen werden sollen
 * @returns LocationData-Objekt oder null, wenn deaktiviert oder Fehler
 */
export const getLocationForMemo = async (includeAddress: boolean = false): Promise<LocationData | EnhancedLocationData | null> => {
  try {
    // Prüfe, ob die Standortspeicherung aktiviert ist
    const saveLocationSetting = await AsyncStorage.getItem('saveLocation');
    if (saveLocationSetting !== 'true') {
      // Standortspeicherung ist deaktiviert
      return null;
    }
    
    // Prüfe Berechtigungen
    const hasPermission = await requestLocationPermissions();
    if (!hasPermission) {
      // Keine Berechtigung
      return null;
    }
    
    // Rufe aktuellen Standort ab
    const locationData = await getCurrentLocation();
    if (!locationData) return null;
    
    // Wenn Adressinformationen nicht benötigt werden, nur Koordinaten zurückgeben
    if (!includeAddress) return locationData;
    
    // Adressinformationen abrufen
    const addressInfo = await getAddressFromCoordinates(locationData.latitude, locationData.longitude);
    
    // Erweiterte Standortdaten zurückgeben
    return {
      ...locationData,
      address: addressInfo || undefined
    };
  } catch (error) {
     
    console.debug('Fehler beim Abrufen des Standorts für Memo:', error);
    return null;
  }
};