fforte/lib/services/tracking_service.dart

import 'dart:async';
import 'dart:math' as math;

import 'package:fforte/l10n/app_localizations.dart';
import 'package:fforte/services/notification_service.dart';
import 'package:flutter/material.dart';
import 'package:geolocator/geolocator.dart';
import 'package:latlong2/latlong.dart';
import 'package:shared_preferences/shared_preferences.dart';

class TrackingService {
  static TrackingService? _instance;
  
  factory TrackingService() {
    _instance ??= TrackingService._internal();
    return _instance!;
  }
  
  TrackingService._internal();

  static void resetInstance() {
    if (_instance != null) {
      _instance!.dispose();
      _instance = null;
    }
  }

  List<LatLng> pathList = [];
  List<double> accuracyList = [];
  Timer? _positionTimer;
  bool isTracking = false;
  BuildContext? _lastContext;
  final _positionController = StreamController<Position>.broadcast();
  final _statsController = StreamController<TrackingStats>.broadcast();

  Stream<Position> get positionStream$ => _positionController.stream;
  Stream<TrackingStats> get statsStream$ => _statsController.stream;

  double? currentAccuracy;
  
  double _calculateMedianAccuracy(List<double> accuracies) {
    if (accuracies.isEmpty) return 0;
    if (accuracies.length == 1) return accuracies.first;
    
    // Kopiere die Liste, um die Originaldaten nicht zu verändern
    var sorted = List<double>.from(accuracies)..sort();
    
    if (sorted.length % 2 == 0) {
      // Bei gerader Anzahl: Durchschnitt der beiden mittleren Werte
      int midIndex = sorted.length ~/ 2;
      return (sorted[midIndex - 1] + sorted[midIndex]) / 2;
    } else {
      // Bei ungerader Anzahl: Der mittlere Wert
      return sorted[sorted.length ~/ 2];
    }
  }
  
  Future<void> startTracking(BuildContext context) async {
    if (isTracking) return;

    _lastContext = context;
    await NotificationService().initNotification();
    NotificationService().showNotification(
      title: AppLocalizations.of(context)!.trackingRunningInBackground,
    );

    // Get tracking interval from settings
    final prefs = await SharedPreferences.getInstance();
    final intervalSeconds = prefs.getInt('trackingInterval') ?? 60;

    // Create a timer that triggers position updates
    _positionTimer = Timer.periodic(Duration(seconds: intervalSeconds), (_) async {
      try {
        final Position position = await Geolocator.getCurrentPosition(
          desiredAccuracy: LocationAccuracy.high,
        );
        
        pathList.add(LatLng(position.latitude, position.longitude));
        accuracyList.add(position.accuracy);
        currentAccuracy = position.accuracy;
        _positionController.add(position);
        _updateStats();
      } catch (e) {
        NotificationService().deleteNotification();
        NotificationService().showNotification(title: "ERROR: $e");
      }
    });

    // Get initial position immediately
    try {
      final Position position = await Geolocator.getCurrentPosition(
        desiredAccuracy: LocationAccuracy.high,
      );
      
      pathList.add(LatLng(position.latitude, position.longitude));
      accuracyList.add(position.accuracy);
      currentAccuracy = position.accuracy;
      _positionController.add(position);
      _updateStats();
    } catch (e) {
      NotificationService().deleteNotification();
      NotificationService().showNotification(title: "ERROR: $e");
    }

    isTracking = true;
  }

  TrackingStats? _lastStats;
  TrackingStats? get currentStats => _lastStats;

  void _updateStats() {
    if (pathList.isEmpty) {
      _lastStats = TrackingStats(
        currentAccuracy: currentAccuracy ?? 0,
        averageAccuracy: 0,
        totalDistanceMeters: 0
      );
      _statsController.add(_lastStats!);
      return;
    }
    
    double totalDistance = 0;
    for (int i = 1; i < pathList.length; i++) {
      totalDistance += _calculateDistance(
        pathList[i-1].latitude,
        pathList[i-1].longitude,
        pathList[i].latitude,
        pathList[i].longitude
      );
    }

    double medianAccuracy = _calculateMedianAccuracy(accuracyList);

    _lastStats = TrackingStats(
      currentAccuracy: currentAccuracy ?? 0,
      averageAccuracy: medianAccuracy,
      totalDistanceMeters: totalDistance
    );
    _statsController.add(_lastStats!);
  }

  void requestStatsUpdate() {
    _updateStats();
  }

  double _calculateDistance(double lat1, double lon1, double lat2, double lon2) {
    const double earthRadius = 6371000; // Erdradius in Metern
    
    double lat1Rad = lat1 * math.pi / 180;
    double lat2Rad = lat2 * math.pi / 180;
    double deltaLat = (lat2 - lat1) * math.pi / 180;
    double deltaLon = (lon2 - lon1) * math.pi / 180;

    double a = math.sin(deltaLat/2) * math.sin(deltaLat/2) +
        math.cos(lat1Rad) * math.cos(lat2Rad) *
        math.sin(deltaLon/2) * math.sin(deltaLon/2);
    
    double c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a));
    return earthRadius * c;
  }

  void pauseTracking() {
    _positionTimer?.cancel();
    isTracking = false;
  }

  void resumeTracking() {
    if (!isTracking && _lastContext != null) {
      startTracking(_lastContext!);
    }
    isTracking = true;
  }

  void stopTracking() {
    _positionTimer?.cancel();
    NotificationService().deleteNotification();
    isTracking = false;
    accuracyList.clear();
    currentAccuracy = null;
    _lastContext = null;
  }

  void clearPath() {
    pathList.clear();
    accuracyList.clear();
    currentAccuracy = null;
    _updateStats();
  }

  String getPathAsString() {
    return pathList.map((pos) => "${pos.latitude},${pos.longitude}").join(";");
  }

  void dispose() {
    stopTracking();
    _positionController.close();
    _statsController.close();
  }
}

class TrackingStats {
  final double currentAccuracy;
  final double averageAccuracy;
  final double totalDistanceMeters;

  TrackingStats({
    required this.currentAccuracy,
    required this.averageAccuracy,
    required this.totalDistanceMeters,
  });
}