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/employee_model.dart';
import 'package:marco/helpers/widgets/my_form_validator.dart';
import 'package:marco/helpers/widgets/my_snackbar.dart';
import 'package:marco/controller/project_controller.dart';
import 'package:marco/model/dailyTaskPlaning/master_work_category_model.dart';

final Logger log = Logger();

class AddTaskController extends GetxController {
  List<ProjectModel> projects = [];
  List<EmployeeModel> employees = [];
  RxMap<String, RxBool> uploadingStates = <String, RxBool>{}.obs;
  MyFormValidator basicValidator = MyFormValidator();
   RxnInt selectedCategoryId = RxnInt();

  List<Map<String, dynamic>> roles = [];
  RxnString selectedRoleId = RxnString();
  RxList<EmployeeModel> selectedEmployees = <EmployeeModel>[].obs;
  RxBool isLoadingWorkMasterCategories = false.obs;
  RxList<WorkCategoryModel> workMasterCategories = <WorkCategoryModel>[].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();
    fetchWorkMasterCategories();
    final projectId = Get.find<ProjectController>().selectedProject?.id;
    fetchEmployeesByProject(projectId);
  }

  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<bool> createTask({
    required String parentTaskId,
    required int plannedTask,
    required String description,
    required List<String> taskTeam,
    required String workItemId,
    DateTime? assignmentDate,
  }) async {
    logger.i("Creating new task...");

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

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

  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;
  }

  Future<void> fetchWorkMasterCategories() async {
    isLoadingWorkMasterCategories.value = true;

    final response = await ApiService.getMasterWorkCategories();
    if (response != null) {
      try {
        final dataList = response['data'] ?? [];
        workMasterCategories.assignAll(
          List<WorkCategoryModel>.from(
            dataList.map((e) => WorkCategoryModel.fromJson(e)),
          ),
        );
        logger.i("Work categories fetched: ${dataList.length}");
      } catch (e) {
        logger.e("Error parsing work categories: $e");
        workMasterCategories.clear();
      }
    } else {
      logger.w("No work categories found or API call failed.");
    }

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