Untitled

import 'dart:math';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';

class AlertListPage extends StatefulWidget {
  const AlertListPage({super.key});

  @override
  State<AlertListPage> createState() => _AlertListPageState();
}

class _AlertListPageState extends State<AlertListPage> with WidgetsBindingObserver {
  final int batchSize = 1;
  int loadedAlertsCount = 3;

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  int compareAlertLevels(String level1, String level2) {
    final priorityOrder = {
      'Emergency': 0,
      'High': 1,
      'Medium': 2,
      'Low': 3,
      'Resolved': 4
    };

    int priority1 = priorityOrder[level1] ?? 999;  // Default to lowest priority
    int priority2 = priorityOrder[level2] ?? 999;  // Default to lowest priority
    return priority1.compareTo(priority2);
  }

  double haversine(double lat1, double lon1, double lat2, double lon2) {
    // Haversine formula to calculate distance
    double dlon = _degreesToRadians(lon2 - lon1);
    double dlat = _degreesToRadians(lat2 - lat1);
    double a = pow(sin(dlat / 2), 2) + cos(_degreesToRadians(lat1)) * cos(_degreesToRadians(lat2)) * pow(sin(dlon / 2), 2);
    double c = 2 * atan2(sqrt(a), sqrt(1 - a));
    double r = 6371.0;  // Radius of the Earth in kilometers
    double distance = c * r * 1000;  // Convert to meters
    return distance;
  }

  double _degreesToRadians(double degrees) {
    return degrees * pi / 180;
  }

  List<Alert> sortAlertsBySeverityAndDistance(List<Alert> alerts, double userLatitude, double userLongitude) {
    // Sort by severity
    alerts.sort((a, b) => compareAlertLevels(a.severity, b.severity));

    // Further sort each severity level by distance
    Map<String, List<Alert>> groupedBySeverity = {};
    for (var alert in alerts) {
      groupedBySeverity.putIfAbsent(alert.severity, () => []).add(alert);
    }

    List<Alert> sortedAlerts = [];
    groupedBySeverity.forEach((severity, group) {
      group.sort((a, b) {
        double distance1 = haversine(a.latitude, a.longitude, userLatitude, userLongitude);
        double distance2 = haversine(b.latitude, b.longitude, userLatitude, userLongitude);
        return distance1.compareTo(distance2);
      });
      sortedAlerts.addAll(group);
    });

    return sortedAlerts;
  }

  @override
  Widget build(BuildContext context) {
    final user = context.read<UserProvider>().user!;
    final bool isAdmin = user.isAdmin;
    final double userLatitude = user.latitude ?? 23.09;
    final double userLongitude = user.longitude ?? 41.121;

    return Scaffold(
      appBar: AppBar(
        title: const Text('Detection Alerts'),
      ),
      body: BlocBuilder<AlertCubit, AlertState>(
        builder: (context, state) {
          if (state is AlertStateLoaded) {
            List<Alert> sortedAlerts = sortAlertsBySeverityAndDistance(state.alertsList, userLatitude, userLongitude);
            final List<Alert> alertsToShow = isAdmin ? state.alertsList : sortedAlerts.where((alert) => alert.isConfirmed || alert.severity == 'Emergency').toList();

            return ListView.builder(
              itemCount: alertsToShow.length,
              itemBuilder: (context, index) {
                final alert = alertsToShow[index];
                double distance = haversine(userLatitude, userLongitude, alert.latitude, alert.longitude);
                bool isClose = distance < 1000;
                return AlertCard(alert: alert, isClose: isClose);
              },
            );
          } else if (state is AlertStateLoading) {
            return const Center(child: CircularProgressIndicator());
          } else {
            return const Center(child: Text('No data available'));
          }
        },
      ),
    );
  }
}

// Assuming Alert, AlertCard, AlertCubit, AlertState, UserProvider classes are defined elsewhere.