marco.pms.mobileapp/lib/controller/task_planing/daily_task_planing_controller.dart

import 'package:get/get.dart';
import 'package:logger/logger.dart';
import 'package:marco/helpers/services/api_service.dart';
import 'package:marco/model/project_model.dart';
import 'package:marco/model/dailyTaskPlaning/daily_task_planing_model.dart';
import 'package:marco/model/employee_model.dart';
import 'package:marco/helpers/widgets/my_form_validator.dart';
import 'package:marco/helpers/widgets/my_snackbar.dart';

final Logger log = Logger();

class DailyTaskPlaningController extends GetxController {
  List<ProjectModel> projects = [];
  String? selectedProjectId;
  List<EmployeeModel> employees = [];
  List<TaskPlanningDetailsModel> dailyTasks = [];
  RxMap<String, RxBool> uploadingStates = <String, RxBool>{}.obs;
  MyFormValidator basicValidator = MyFormValidator();

  List<Map<String, dynamic>> roles = [];
  RxnString selectedRoleId = RxnString();
  RxList<EmployeeModel> selectedEmployees = <EmployeeModel>[].obs;

  void updateSelectedEmployees() {
    final selected =
        employees.where((e) => uploadingStates[e.id]?.value == true).toList();
    selectedEmployees.value = selected;
  }

  RxBool isLoading = false.obs;
  @override
  void onInit() {
    super.onInit();
    fetchRoles();
    _initializeDefaults();
  }

  void _initializeDefaults() {
    fetchProjects();
  }

  String? formFieldValidator(String? value, {required String fieldType}) {
    if (value == null || value.trim().isEmpty) {
      return 'This field is required';
    }
    if (fieldType == "target") {
      if (int.tryParse(value.trim()) == null) {
        return 'Please enter a valid number';
      }
    }
    if (fieldType == "description") {
      if (value.trim().length < 5) {
        return 'Description must be at least 5 characters';
      }
    }
    return null;
  }

  Future<void> fetchRoles() async {
    logger.i("Fetching roles...");
    final result = await ApiService.getRoles();
    if (result != null) {
      roles = List<Map<String, dynamic>>.from(result);
      logger.i("Roles fetched successfully.");
      update();
    } else {
      logger.e("Failed to fetch roles.");
    }
  }

  void onRoleSelected(String? roleId) {
    selectedRoleId.value = roleId;
    logger.i("Role selected: $roleId");
  }

  Future<bool> assignDailyTask({
  required String workItemId,
  required int plannedTask,
  required String description,
  required List<String> taskTeam,
  DateTime? assignmentDate,
}) async {
  logger.i("Starting assign task...");

  final response = await ApiService.assignDailyTask(
    workItemId: workItemId,
    plannedTask: plannedTask,
    description: description,
    taskTeam: taskTeam,
    assignmentDate: assignmentDate,
  );

  if (response == true) {
    logger.i("Task assigned successfully.");
    showAppSnackbar(
      title: "Success",
      message: "Task assigned successfully!",
      type: SnackbarType.success,
    );
    return true;
  } else {
    logger.e("Failed to assign task.");
    showAppSnackbar(
      title: "Error",
      message: "Failed to assign task.",
      type: SnackbarType.error,
    );
    return false;
  }
}


  Future<void> fetchProjects() async {
    try {
      isLoading.value = true;

      final response = await ApiService.getProjects();
      if (response?.isEmpty ?? true) {
        log.w("No project data found or API call failed.");
        return;
      }

      projects = response!.map((json) => ProjectModel.fromJson(json)).toList();
      selectedProjectId = projects.first.id.toString();
      log.i("Projects fetched: ${projects.length} projects loaded.");
      update();

      await fetchTaskData(selectedProjectId);
    } catch (e, stack) {
      log.e("Error fetching projects", error: e, stackTrace: stack);
    } finally {
      isLoading.value = false;
    }
  }

  Future<void> fetchTaskData(String? projectId) async {
    if (projectId == null) return;

    try {
      isLoading.value = true;

      final response = await ApiService.getDailyTasksDetails(projectId);
      if (response != null) {
        final data = response['data'];
        if (data != null) {
          dailyTasks = [TaskPlanningDetailsModel.fromJson(data)];
          log.i("Daily task Planning Details fetched.");
        } else {
          log.e("Data field is null");
        }
      } else {
        log.e(
            "Failed to fetch daily task planning Details for project $projectId");
      }
    } catch (e, stack) {
      log.e("Error fetching daily task data", error: e, stackTrace: stack);
    } finally {
      isLoading.value = false;
      update();
    }
  }

  Future<void> fetchEmployeesByProject(String? projectId) async {
    if (projectId == null || projectId.isEmpty) {
      log.e("Project ID is required but was null or empty.");
      return;
    }

    isLoading.value = true;
    try {
      final response = await ApiService.getAllEmployeesByProject(projectId);
      if (response != null && response.isNotEmpty) {
        employees =
            response.map((json) => EmployeeModel.fromJson(json)).toList();
        for (var emp in employees) {
          uploadingStates[emp.id] = false.obs;
        }
        log.i("Employees fetched: ${employees.length} for project $projectId");
      } else {
        log.w("No employees found for project $projectId.");
        employees = [];
      }
    } catch (e) {
      log.e("Error fetching employees for project $projectId: $e");
    }

    update();
    isLoading.value = false;
  }
}