marco.pms.mobileapp/lib/controller/permission_controller.dart

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';
import 'package:marco/model/employee_info.dart';  // Import the EmployeeInfo model

class PermissionController extends GetxController {
  var permissions = <UserPermission>[].obs;
  var employeeInfo = Rxn<EmployeeInfo>();  // Observable for employee info
  Timer? _refreshTimer;

  @override
  void onInit() {
    super.onInit();
    _loadStoredData(); // Load both permissions and employee info
    _startAutoRefresh(); // Schedule auto-refresh every 30 minutes
  }

  // Load permissions and employee info from SharedPreferences
  Future<void> _loadStoredData() async {
    final prefs = await SharedPreferences.getInstance();

    // Load stored permissions
    final storedPermissionsJson = prefs.getString('user_permissions');
    if (storedPermissionsJson != null) {
      print("Loaded Permissions from SharedPreferences: $storedPermissionsJson");
      try {
        final List<dynamic> parsedList = jsonDecode(storedPermissionsJson);
        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');
      }
    }

    // Load stored employee info
    final storedEmployeeInfoJson = prefs.getString('employee_info');
    if (storedEmployeeInfoJson != null) {
      print("Loaded Employee Info from SharedPreferences: $storedEmployeeInfoJson");
      try {
        final decodedEmployeeInfo = jsonDecode(storedEmployeeInfoJson);
        employeeInfo.value = EmployeeInfo.fromJson(decodedEmployeeInfo);
      } catch (e) {
        print("Error decoding stored employee info: $e");
        await prefs.remove('employee_info');
      }
    }

    // If permissions or employee info are missing, fallback to API
    if (storedPermissionsJson == null || storedEmployeeInfoJson == null) {
      await _loadDataFromAPI();
    }
  }

  // Save permissions and employee info to SharedPreferences
  Future<void> _storeData() async {
    final prefs = await SharedPreferences.getInstance();

    // Store permissions
    final permissionsJson = permissions.map((e) => e.toJson()).toList();
    print("Storing Permissions: $permissionsJson");
    await prefs.setString('user_permissions', jsonEncode(permissionsJson));

    // Store employee info
    if (employeeInfo.value != null) {
      final employeeInfoJson = employeeInfo.value!.toJson();
      print("Storing Employee Info: $employeeInfoJson");
      await prefs.setString('employee_info', jsonEncode(employeeInfoJson));
    }
  }

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

      permissions.assignAll(result); // Update observable list
      await _storeData(); // Cache locally

      // Also fetch employee info from the API (you can extend the service if needed)
      await _loadEmployeeInfoFromAPI(token);
    } catch (e) {
      print('Error loading data from API: $e');
    }
  }

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

  // 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 30 minutes
  void _startAutoRefresh() {
    _refreshTimer = Timer.periodic(Duration(minutes: 30), (timer) async {
      await _loadDataFromAPI();
    });
  }

  // Load employee info from the API
  Future<void> _loadEmployeeInfoFromAPI(String token) async {
    final employeeInfoResponse = await PermissionService.fetchEmployeeInfo(token);
    print("Fetched Employee Info from API: $employeeInfoResponse");

    employeeInfo.value = employeeInfoResponse; // Update observable employee info
    await _storeData(); // Cache employee info locally
  }

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

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