import 'package:flutter/material.dart';
import 'package:geolocator/geolocator.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import '../config/language/language_enum.dart';
import '../providers/language_provider.dart';
import '../routes/app_routes.dart';

import 'NewUiScreen/PermissionModals/ContactsPermissionModal.dart';
import 'NewUiScreen/PermissionModals/LocationPermissionModal.dart';
import 'NewUiScreen/PermissionModals/NotificationsPermissionModal.dart';
import 'NewUiScreen/PermissionModals/ProfileCompletedModal.dart';
import 'NewUiScreen/RegistrationScreen.dart';
import 'NewUiScreen/Selfi/AddProfilePicture.dart';

class AllowLocationScreen extends StatefulWidget {
  final bool showRegistration;
  const AllowLocationScreen({super.key, required this.showRegistration});

  @override
  State<AllowLocationScreen> createState() => _AllowLocationScreenState();
}

class _AllowLocationScreenState extends State<AllowLocationScreen> {
  int currentPermissionStep = 0;
  bool showRegistration = true;
  bool _isChecking = true;

  @override
  void initState() {
    super.initState();
    _checkAllPermissions();
  }

  Future<void> _checkAllPermissions() async {
    // ✅ FIXED: Check if all permissions are actually GRANTED
    final allGranted = await _areAllPermissionsGranted();

    if (allGranted) {
      // All permissions granted, go directly to home
      if (mounted) {
        Get.offAllNamed(AppRoutes.home);
      }
      return;
    }

    // ✅ FIXED: Check which permissions are missing and start from there
    await _determineStartingStep();

    // Show permission screens
    if (mounted) {
      setState(() {
        _isChecking = false;
      });
    }
  }

  Future<void> _determineStartingStep() async {
    // Check location permission
    final locationPermission = await Geolocator.checkPermission();
    final isLocationGranted = locationPermission == LocationPermission.always ||
        locationPermission == LocationPermission.whileInUse;

    if (!isLocationGranted) {
      currentPermissionStep = 0; // Start with location
      return;
    }

    // Check contacts permission
    final contactsStatus = await Permission.contacts.status;
    if (!contactsStatus.isGranted) {
      currentPermissionStep = 1; // Start with contacts
      return;
    }

    // Check notification permission
    final notificationStatus = await Permission.notification.status;
    if (!notificationStatus.isGranted) {
      currentPermissionStep = 2; // Start with notifications
      return;
    }
  }

  Future<bool> _areAllPermissionsGranted() async {
    // Check location permission
    final locationPermission = await Geolocator.checkPermission();
    final isLocationGranted = locationPermission == LocationPermission.always ||
        locationPermission == LocationPermission.whileInUse;

    // Check contacts permission
    final contactsStatus = await Permission.contacts.status;
    final isContactsGranted = contactsStatus.isGranted;

    // Check notification permission
    final notificationStatus = await Permission.notification.status;
    final isNotificationGranted = notificationStatus.isGranted;

    print('✅ Permissions Status:');
    print('   Location: $isLocationGranted');
    print('   Contacts: $isContactsGranted');
    print('   Notification: $isNotificationGranted');

    return isLocationGranted && isContactsGranted && isNotificationGranted;
  }

  @override
  Widget build(BuildContext context) {
    final languageProvider =
    Provider.of<LanguageProvider>(context, listen: false);
    bool isArabic = languageProvider.currentLangCode == Language.ar;

    if (_isChecking) {
      return const Scaffold(
        body: Center(
          child: CircularProgressIndicator(),
        ),
      );
    }

    if (widget.showRegistration) {
      return RegistrationScreen(
        onRegistrationComplete: () {
          _showProfileCompletedModal(context, isArabic);
        },
      );
    }

    return SafeArea(
      child: Scaffold(
        backgroundColor: Colors.black.withOpacity(0.5),
        body: Center(
          child: Padding(
            padding: const EdgeInsets.all(20),
            child: _buildCurrentPermissionModal(context, isArabic),
          ),
        ),
      ),
    );
  }

  Widget _buildCurrentPermissionModal(BuildContext context, bool isArabic) {
    switch (currentPermissionStep) {
      case 0:
        return LocationPermissionModal(
          isArabic: isArabic,
          onAllow: () => _handleLocationPermission(context),
          onMaybeLater: () => _nextPermissionStep(),
        );
      case 1:
        return ContactsPermissionModal(
          isArabic: isArabic,
          onAllow: () => _handleContactsPermission(context),
          onMaybeLater: () => _nextPermissionStep(),
        );
      case 2:
        return NotificationsPermissionModal(
          isArabic: isArabic,
          onAllow: () => _handleNotificationsPermission(context),
          onMaybeLater: () => _finishPermissions(),
        );
      default:
        return const SizedBox();
    }
  }

  void _showProfileCompletedModal(BuildContext context, bool isArabic) {
    showDialog(
      context: context,
      barrierDismissible: false,
      builder: (context) => Dialog(
        backgroundColor: Colors.transparent,
        child: ProfileCompletedModal(
          isArabic: isArabic,
          onContinue: () {
            Navigator.push(
                context,
                MaterialPageRoute(
                    builder: (context) => const AddProfilePicture()));
            setState(() {
              showRegistration = false;
              currentPermissionStep = 0;
            });
          },
        ),
      ),
    );
  }

  void _nextPermissionStep() async {
    if (currentPermissionStep < 2) {
      // ✅ FIXED: Check if next permission is already granted
      int nextStep = currentPermissionStep + 1;

      // Skip already granted permissions
      while (nextStep <= 2) {
        bool isGranted = await _isStepPermissionGranted(nextStep);
        if (!isGranted) {
          break; // Found a permission that needs to be granted
        }
        nextStep++;
      }

      if (nextStep <= 2) {
        setState(() {
          currentPermissionStep = nextStep;
        });
      } else {
        _finishPermissions();
      }
    } else {
      _finishPermissions();
    }
  }

  Future<bool> _isStepPermissionGranted(int step) async {
    switch (step) {
      case 0: // Location
        final locationPermission = await Geolocator.checkPermission();
        return locationPermission == LocationPermission.always ||
            locationPermission == LocationPermission.whileInUse;
      case 1: // Contacts
        final contactsStatus = await Permission.contacts.status;
        return contactsStatus.isGranted;
      case 2: // Notifications
        final notificationStatus = await Permission.notification.status;
        return notificationStatus.isGranted;
      default:
        return false;
    }
  }

  Future<void> _handleLocationPermission(BuildContext context) async {
    LocationPermission permission = await Geolocator.checkPermission();
    if (permission == LocationPermission.denied) {
      permission = await Geolocator.requestPermission();
    }

    _nextPermissionStep();
  }

  Future<void> _handleContactsPermission(BuildContext context) async {
    await Permission.contacts.request();
    _nextPermissionStep();
  }

  Future<void> _handleNotificationsPermission(BuildContext context) async {
    await Permission.notification.request();
    _finishPermissions();
  }

  Future<void> _finishPermissions() async {
    // ✅ FIXED: Save that permissions flow was completed
    final prefs = await SharedPreferences.getInstance();
    await prefs.setBool('permissions_flow_completed', true);

    Get.offAllNamed(AppRoutes.home);
  }
}