import 'dart:async';
import 'dart:convert';
import 'package:get/get.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:marco/helpers/services/permission_service.dart';
import 'package:marco/model/user_permission.dart';

class PermissionController extends GetxController {
  var permissions = <UserPermission>[].obs;
  Timer? _refreshTimer;

  @override
  void onInit() {
    super.onInit();
    _loadStoredPermissions(); // Try to load from local storage first
    _startAutoRefresh(); // Schedule auto-refresh every 15 minutes
  }

  // Load permissions from SharedPreferences
  Future<void> _loadStoredPermissions() async {
    final prefs = await SharedPreferences.getInstance();
    final storedJson = prefs.getString('user_permissions');

    if (storedJson != null) {
      print("Loaded Permissions from SharedPreferences: $storedJson");
      try {
        final List<dynamic> parsedList = jsonDecode(storedJson);

        permissions.assignAll(
          parsedList
              .map((e) => UserPermission.fromJson(e as Map<String, dynamic>))
              .toList(),
        );
      } catch (e) {
        print("Error decoding stored permissions: $e");
        await prefs.remove('user_permissions');
        await _loadPermissionsFromAPI(); // fallback to API load
      }
    } else {
      // If no permissions stored, fallback to API
      await _loadPermissionsFromAPI();
    }
  }

  // Save permissions to SharedPreferences
  Future<void> _storePermissions() async {
    final prefs = await SharedPreferences.getInstance();
    final jsonList = permissions.map((e) => e.toJson()).toList();
    print("Storing Permissions: $jsonList");
    await prefs.setString('user_permissions', jsonEncode(jsonList));
  }

  // Public method to load permissions (usually called from outside)
  Future<void> loadPermissions(String token) async {
    try {
      final result = await PermissionService.fetchPermissions(token);
      print("Fetched Permissions from API: $result");

      permissions.assignAll(result); // Update observable list
      await _storePermissions(); // Cache locally
    } catch (e) {
      print('Error loading permissions from API: $e');
    }
  }

  // Internal helper to load token and fetch permissions from API
  Future<void> _loadPermissionsFromAPI() async {
    final token = await _getAuthToken();
    if (token != null && token.isNotEmpty) {
      await loadPermissions(token);
    } else {
      print("No token available for fetching permissions.");
    }
  }

  // Retrieve token from SharedPreferences
  Future<String?> _getAuthToken() async {
    final prefs = await SharedPreferences.getInstance();
    return prefs.getString(
        'jwt_token'); // Or 'auth_token' if that’s the key you're using
  }

  // Auto-refresh every 15 minutes
  void _startAutoRefresh() {
    _refreshTimer = Timer.periodic(Duration(minutes: 30), (timer) async {
      await _loadPermissionsFromAPI();
    });
  }

  // Check for specific permission
  bool hasPermission(String permissionId) {
    return permissions.any((p) => p.id == permissionId);
  }

  @override
  void onClose() {
    _refreshTimer?.cancel();
    super.onClose();
  }
}