import 'dart:io';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:image_picker/image_picker.dart';
import 'package:geolocator/geolocator.dart';
import 'package:intl/intl.dart';

import 'package:marco/helpers/services/app_logger.dart';
import 'package:marco/helpers/services/api_service.dart';
import 'package:marco/helpers/widgets/my_image_compressor.dart';

import 'package:marco/model/attendance/attendance_model.dart';
import 'package:marco/model/project_model.dart';
import 'package:marco/model/employees/employee_model.dart';
import 'package:marco/model/attendance/attendance_log_model.dart';
import 'package:marco/model/regularization_log_model.dart';
import 'package:marco/model/attendance/attendance_log_view_model.dart';
import 'package:marco/model/attendance/organization_per_project_list_model.dart';
import 'package:marco/controller/project_controller.dart';

class AttendanceController extends GetxController {
  // Data models
  List<AttendanceModel> attendances = [];
  List<ProjectModel> projects = [];
  List<EmployeeModel> employees = [];
  List<AttendanceLogModel> attendanceLogs = [];
  List<RegularizationLogModel> regularizationLogs = [];
  List<AttendanceLogViewModel> attendenceLogsView = [];
  // ------------------ Organizations ------------------
  List<Organization> organizations = [];
  Organization? selectedOrganization;
  final isLoadingOrganizations = false.obs;

  // States
String selectedTab = 'todaysAttendance'; 
  DateTime? startDateAttendance;
  DateTime? endDateAttendance;

  final isLoading = true.obs;
  final isLoadingProjects = true.obs;
  final isLoadingEmployees = true.obs;
  final isLoadingAttendanceLogs = true.obs;
  final isLoadingRegularizationLogs = true.obs;
  final isLoadingLogView = true.obs;
  final uploadingStates = <String, RxBool>{}.obs;
  var showPendingOnly = false.obs;

  @override
  void onInit() {
    super.onInit();
    _initializeDefaults();

    // 🔹 Fetch organizations for the selected project
    final projectId = Get.find<ProjectController>().selectedProject?.id;
    if (projectId != null) {
      fetchOrganizations(projectId);
    }
  }

  void _initializeDefaults() {
    _setDefaultDateRange();
  }

  void _setDefaultDateRange() {
    final today = DateTime.now();
    startDateAttendance = today.subtract(const Duration(days: 7));
    endDateAttendance = today.subtract(const Duration(days: 1));
    logSafe(
        "Default date range set: $startDateAttendance to $endDateAttendance");
  }

  // ------------------ Project & Employee ------------------
  /// Called when a notification says attendance has been updated
  Future<void> refreshDataFromNotification({String? projectId}) async {
    projectId ??= Get.find<ProjectController>().selectedProject?.id;
    if (projectId == null) {
      logSafe("No project selected for attendance refresh from notification",
          level: LogLevel.warning);
      return;
    }
    await fetchProjectData(projectId);
    logSafe(
        "Attendance data refreshed from notification for project $projectId");
  }

  // 🔍 Search query
  final searchQuery = ''.obs;

  // Computed filtered employees
  List<EmployeeModel> get filteredEmployees {
    if (searchQuery.value.isEmpty) return employees;
    return employees
        .where((e) =>
            e.name.toLowerCase().contains(searchQuery.value.toLowerCase()))
        .toList();
  }

  // Computed filtered logs
  List<AttendanceLogModel> get filteredLogs {
    if (searchQuery.value.isEmpty) return attendanceLogs;
    return attendanceLogs
        .where((log) =>
            (log.name).toLowerCase().contains(searchQuery.value.toLowerCase()))
        .toList();
  }

// Computed filtered regularization logs
  List<RegularizationLogModel> get filteredRegularizationLogs {
    if (searchQuery.value.isEmpty) return regularizationLogs;
    return regularizationLogs
        .where((log) =>
            log.name.toLowerCase().contains(searchQuery.value.toLowerCase()))
        .toList();
  }

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

    isLoadingEmployees.value = true;

    final response = await ApiService.getTodaysAttendance(
      projectId,
      organizationId: selectedOrganization?.id,
    );
    if (response != null) {
      employees = response.map((e) => EmployeeModel.fromJson(e)).toList();
      for (var emp in employees) {
        uploadingStates[emp.id] = false.obs;
      }
      logSafe("Employees fetched: ${employees.length} for project $projectId");
    } else {
      logSafe("Failed to fetch employees for project $projectId",
          level: LogLevel.error);
    }
    isLoadingEmployees.value = false;
    update();
  }

  Future<void> fetchOrganizations(String projectId) async {
    isLoadingOrganizations.value = true;
    final response = await ApiService.getAssignedOrganizations(projectId);
    if (response != null) {
      organizations = response.data;
      logSafe("Organizations fetched: ${organizations.length}");
    } else {
      logSafe("Failed to fetch organizations for project $projectId",
          level: LogLevel.error);
    }
    isLoadingOrganizations.value = false;
    update();
  }

  // ------------------ Attendance Capture ------------------

  Future<bool> captureAndUploadAttendance(
    String id,
    String employeeId,
    String projectId, {
    String comment = "Marked via mobile app",
    required int action,
    bool imageCapture = true,
    String? markTime, // still optional in controller
    String? date, // new optional param
  }) async {
    try {
      uploadingStates[employeeId]?.value = true;

      XFile? image;
      if (imageCapture) {
        image = await ImagePicker()
            .pickImage(source: ImageSource.camera, imageQuality: 80);
        if (image == null) {
          logSafe("Image capture cancelled.", level: LogLevel.warning);
          return false;
        }

        final compressedBytes =
            await compressImageToUnder100KB(File(image.path));
        if (compressedBytes == null) {
          logSafe("Image compression failed.", level: LogLevel.error);
          return false;
        }

        final compressedFile = await saveCompressedImageToFile(compressedBytes);
        image = XFile(compressedFile.path);
      }

      if (!await _handleLocationPermission()) return false;
      final position = await Geolocator.getCurrentPosition(
          desiredAccuracy: LocationAccuracy.high);

      final imageName = imageCapture
          ? ApiService.generateImageName(employeeId, employees.length + 1)
          : "";

      // ---------------- DATE / TIME LOGIC ----------------
      final now = DateTime.now();

      // Default effectiveDate = now
      DateTime effectiveDate = now;

      if (action == 1) {
        // Checkout
        // Try to find today's open log for this employee
        final log = attendanceLogs.firstWhereOrNull(
          (log) => log.employeeId == employeeId && log.checkOut == null,
        );
        if (log?.checkIn != null) {
          effectiveDate = log!.checkIn!; // use check-in date
        }
      }

      final formattedMarkTime = markTime ?? DateFormat('hh:mm a').format(now);

      final formattedDate =
          date ?? DateFormat('yyyy-MM-dd').format(effectiveDate);

      // ---------------- API CALL ----------------
      final result = await ApiService.uploadAttendanceImage(
        id,
        employeeId,
        image,
        position.latitude,
        position.longitude,
        imageName: imageName,
        projectId: projectId,
        comment: comment,
        action: action,
        imageCapture: imageCapture,
        markTime: formattedMarkTime,
        date: formattedDate,
      );

      logSafe(
          "Attendance uploaded for $employeeId, action: $action, date: $formattedDate");
      return result;
    } catch (e, stacktrace) {
      logSafe("Error uploading attendance",
          level: LogLevel.error, error: e, stackTrace: stacktrace);
      return false;
    } finally {
      uploadingStates[employeeId]?.value = false;
    }
  }

  Future<bool> _handleLocationPermission() async {
    LocationPermission permission = await Geolocator.checkPermission();

    if (permission == LocationPermission.denied) {
      permission = await Geolocator.requestPermission();
      if (permission == LocationPermission.denied) {
        logSafe('Location permissions are denied', level: LogLevel.warning);
        return false;
      }
    }

    if (permission == LocationPermission.deniedForever) {
      logSafe('Location permissions are permanently denied',
          level: LogLevel.error);
      return false;
    }

    return true;
  }

  // ------------------ Attendance Logs ------------------

  Future<void> fetchAttendanceLogs(String? projectId,
      {DateTime? dateFrom, DateTime? dateTo}) async {
    if (projectId == null) return;

    isLoadingAttendanceLogs.value = true;

    final response = await ApiService.getAttendanceLogs(
      projectId,
      dateFrom: dateFrom,
      dateTo: dateTo,
      organizationId: selectedOrganization?.id,
    );
    if (response != null) {
      attendanceLogs =
          response.map((e) => AttendanceLogModel.fromJson(e)).toList();
      logSafe("Attendance logs fetched: ${attendanceLogs.length}");
    } else {
      logSafe("Failed to fetch attendance logs for project $projectId",
          level: LogLevel.error);
    }

    isLoadingAttendanceLogs.value = false;
    update();
  }

  Map<String, List<AttendanceLogModel>> groupLogsByCheckInDate() {
    final groupedLogs = <String, List<AttendanceLogModel>>{};

    for (var logItem in attendanceLogs) {
      final checkInDate = logItem.checkIn != null
          ? DateFormat('dd MMM yyyy').format(logItem.checkIn!)
          : 'Unknown';
      groupedLogs.putIfAbsent(checkInDate, () => []).add(logItem);
    }

    final sortedEntries = groupedLogs.entries.toList()
      ..sort((a, b) {
        if (a.key == 'Unknown') return 1;
        if (b.key == 'Unknown') return -1;
        final dateA = DateFormat('dd MMM yyyy').parse(a.key);
        final dateB = DateFormat('dd MMM yyyy').parse(b.key);
        return dateB.compareTo(dateA);
      });

    return Map<String, List<AttendanceLogModel>>.fromEntries(sortedEntries);
  }

  // ------------------ Regularization Logs ------------------

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

    isLoadingRegularizationLogs.value = true;

    final response = await ApiService.getRegularizationLogs(
      projectId,
      organizationId: selectedOrganization?.id,
    );
    if (response != null) {
      regularizationLogs =
          response.map((e) => RegularizationLogModel.fromJson(e)).toList();
      logSafe("Regularization logs fetched: ${regularizationLogs.length}");
    } else {
      logSafe("Failed to fetch regularization logs for project $projectId",
          level: LogLevel.error);
    }

    isLoadingRegularizationLogs.value = false;
    update();
  }

  // ------------------ Attendance Log View ------------------

  Future<void> fetchLogsView(String? id) async {
    if (id == null) return;

    isLoadingLogView.value = true;

    final response = await ApiService.getAttendanceLogView(id);
    if (response != null) {
      attendenceLogsView =
          response.map((e) => AttendanceLogViewModel.fromJson(e)).toList();
      attendenceLogsView.sort((a, b) => (b.activityTime ?? DateTime(2000))
          .compareTo(a.activityTime ?? DateTime(2000)));
      logSafe("Attendance log view fetched for ID: $id");
    } else {
      logSafe("Failed to fetch attendance log view for ID $id",
          level: LogLevel.error);
    }

    isLoadingLogView.value = false;
    update();
  }

  // ------------------ Combined Load ------------------

  Future<void> loadAttendanceData(String projectId) async {
    isLoading.value = true;
    await fetchProjectData(projectId);
    isLoading.value = false;
  }

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

    await fetchOrganizations(projectId);

    // Call APIs depending on the selected tab only
    switch (selectedTab) {
      case 'todaysAttendance':
        await fetchTodaysAttendance(projectId);
        break;
      case 'attendanceLogs':
        await fetchAttendanceLogs(
          projectId,
          dateFrom: startDateAttendance,
          dateTo: endDateAttendance,
        );
        break;
      case 'regularizationRequests':
        await fetchRegularizationLogs(projectId);
        break;
    }

    logSafe(
        "Project data fetched for project ID: $projectId, tab: $selectedTab");
    update();
  }

  // ------------------ UI Interaction ------------------

  Future<void> selectDateRangeForAttendance(
      BuildContext context, AttendanceController controller) async {
    final today = DateTime.now();

    final picked = await showDateRangePicker(
      context: context,
      firstDate: DateTime(2022),
      lastDate: today.subtract(const Duration(days: 1)),
      initialDateRange: DateTimeRange(
        start: startDateAttendance ?? today.subtract(const Duration(days: 7)),
        end: endDateAttendance ?? today.subtract(const Duration(days: 1)),
      ),
    );

    if (picked != null) {
      startDateAttendance = picked.start;
      endDateAttendance = picked.end;
      logSafe(
          "Date range selected: $startDateAttendance to $endDateAttendance");

      await controller.fetchAttendanceLogs(
        Get.find<ProjectController>().selectedProject?.id,
        dateFrom: picked.start,
        dateTo: picked.end,
      );
    }
  }
}