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/app_logger.dart'; 
import 'package:marco/helpers/services/permission_service.dart';
import 'package:marco/model/user_permission.dart';
import 'package:marco/model/employee_info.dart';
import 'package:marco/model/projects_model.dart';

class PermissionController extends GetxController {
  var permissions = <UserPermission>[].obs;
  var employeeInfo = Rxn<EmployeeInfo>();
  var projectsInfo = <ProjectInfo>[].obs;
  Timer? _refreshTimer;

  @override
  void onInit() {
    super.onInit();
    _loadDataFromAPI();
    _startAutoRefresh();
  }

  Future<void> _storeData() async {
    try {
      final prefs = await SharedPreferences.getInstance();

      await prefs.setString(
        'user_permissions',
        jsonEncode(permissions.map((e) => e.toJson()).toList()),
      );

      if (employeeInfo.value != null) {
        await prefs.setString(
          'employee_info',
          jsonEncode(employeeInfo.value!.toJson()),
        );
      }

      if (projectsInfo.isNotEmpty) {
        await prefs.setString(
          'projects_info',
          jsonEncode(projectsInfo.map((e) => e.toJson()).toList()),
        );
      }

      logSafe("User data successfully stored in SharedPreferences.");
    } catch (e, stacktrace) {
      logSafe("Error storing data", level: LogLevel.error, error: e, stackTrace: stacktrace);
    }
  }

  Future<void> _loadDataFromAPI() async {
    final token = await _getAuthToken();
    if (token?.isNotEmpty ?? false) {
      await loadData(token!);
    } else {
      logSafe("No token found for loading API data.", level: LogLevel.warning);
    }
  }

  Future<void> loadData(String token) async {
    try {
      final userData = await PermissionService.fetchAllUserData(token);
      _updateState(userData);
      await _storeData();
      logSafe("Data loaded and state updated successfully.");
    } catch (e, stacktrace) {
      logSafe("Error loading data from API", level: LogLevel.error, error: e, stackTrace: stacktrace);
    }
  }

  void _updateState(Map<String, dynamic> userData) {
    try {
      permissions.assignAll(userData['permissions']);
      employeeInfo.value = userData['employeeInfo'];
      projectsInfo.assignAll(userData['projects']);

      logSafe("State updated with new user data.", sensitive: true);
    } catch (e, stacktrace) {
      logSafe("Error updating state", level: LogLevel.error, error: e, stackTrace: stacktrace);
    }
  }

  Future<String?> _getAuthToken() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final token = prefs.getString('jwt_token');
      logSafe("Auth token retrieved successfully.", sensitive: true);
      return token;
    } catch (e, stacktrace) {
      logSafe("Error retrieving auth token", level: LogLevel.error, error: e, stackTrace: stacktrace);
      return null;
    }
  }

  void _startAutoRefresh() {
    _refreshTimer = Timer.periodic(Duration(minutes: 30), (timer) async {
      logSafe("Auto-refresh triggered.");
      await _loadDataFromAPI();
    });
  }

  bool hasPermission(String permissionId) {
    final hasPerm = permissions.any((p) => p.id == permissionId);
    logSafe("Checking permission $permissionId: $hasPerm", level: LogLevel.debug);
    return hasPerm;
  }

  bool isUserAssignedToProject(String projectId) {
    final assigned = projectsInfo.any((project) => project.id == projectId);
    logSafe("Checking project assignment for $projectId: $assigned", level: LogLevel.debug);
    return assigned;
  }

  @override
  void onClose() {
    _refreshTimer?.cancel();
    logSafe("PermissionController disposed and timer cancelled.");
    super.onClose();
  }
}