// Example implementation of persistent cooldown in panic button controller

import 'dart:async';

import 'package:get/get.dart';
import 'package:shared_preferences/shared_preferences.dart';

class PanicButtonCooldownExample {
  // SharedPreferences keys for cooldown persistence
  static const String _cooldownEndTimeKey = 'panic_cooldown_end_time';
  static const String _cooldownActiveKey = 'panic_cooldown_active';

  // Cooldown variables
  final RxBool isCooldownActive = false.obs;
  final RxInt cooldownSeconds = 0.obs;
  Timer? _cooldownTimer;

  // Load cooldown state from SharedPreferences
  Future<void> _loadCooldownState() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final cooldownEndTime = prefs.getString(_cooldownEndTimeKey);

      if (cooldownEndTime != null) {
        final endTime = DateTime.parse(cooldownEndTime);
        final now = DateTime.now();

        if (now.isBefore(endTime)) {
          // Cooldown is still active
          isCooldownActive.value = true;
          cooldownSeconds.value = endTime.difference(now).inSeconds;
          _startCooldownTimer();
        } else {
          // Cooldown has expired, clean up
          await _clearCooldownState();
        }
      }
    } catch (e) {
      print('Error loading cooldown state: $e');
    }
  }

  // Save cooldown state to SharedPreferences
  Future<void> _saveCooldownState(DateTime endTime) async {
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.setString(_cooldownEndTimeKey, endTime.toIso8601String());
      await prefs.setBool(_cooldownActiveKey, true);
    } catch (e) {
      print('Error saving cooldown state: $e');
    }
  }

  // Clear cooldown state from SharedPreferences
  Future<void> _clearCooldownState() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.remove(_cooldownEndTimeKey);
      await prefs.remove(_cooldownActiveKey);
      isCooldownActive.value = false;
      cooldownSeconds.value = 0;
    } catch (e) {
      print('Error clearing cooldown state: $e');
    }
  }

  // Start cooldown timer
  void _startCooldown() {
    int cooldownDuration = 300; // 5 minutes

    isCooldownActive.value = true;
    cooldownSeconds.value = cooldownDuration;

    // Save cooldown end time to persistent storage
    final endTime = DateTime.now().add(Duration(seconds: cooldownDuration));
    _saveCooldownState(endTime);

    _startCooldownTimer();
  }

  // Start cooldown timer (separated for reuse)
  void _startCooldownTimer() {
    _cooldownTimer?.cancel();
    _cooldownTimer = Timer.periodic(const Duration(seconds: 1), (timer) {
      cooldownSeconds.value--;

      if (cooldownSeconds.value <= 0) {
        _endCooldown();
      }
    });
  }

  // End cooldown period
  void _endCooldown() {
    _cooldownTimer?.cancel();
    isCooldownActive.value = false;
    cooldownSeconds.value = 0;

    // Clear persistent storage
    _clearCooldownState();
  }

  // Force clear cooldown - useful for testing or admin override
  Future<void> forceClearCooldown() async {
    _cooldownTimer?.cancel();
    await _clearCooldownState();
  }

  // Check if cooldown should still be active
  Future<bool> shouldCooldownBeActive() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final cooldownEndTime = prefs.getString(_cooldownEndTimeKey);

      if (cooldownEndTime != null) {
        final endTime = DateTime.parse(cooldownEndTime);
        return DateTime.now().isBefore(endTime);
      }
      return false;
    } catch (e) {
      print('Error checking cooldown state: $e');
      return false;
    }
  }

  // Initialize - call this in onInit()
  Future<void> initializeCooldown() async {
    await _loadCooldownState();
  }

  // Dispose - call this in onClose()
  void disposeCooldown() {
    _cooldownTimer?.cancel();
  }
}