MIF_E31230910_MP-HRIS-MOBILE/lib/providers/pengajuan_provider.dart

import 'package:flutter/material.dart';
import '../../repositories/pengajuan_repository.dart';
import '../../repositories/lembur_repository.dart';
import '../../repositories/signature_repository.dart';
import '../../models/pengajuan_model.dart';

class PengajuanProvider extends ChangeNotifier {
  final PengajuanRepository _repository = PengajuanRepository();
  final LemburRepository _lemburRepository = LemburRepository();
  final SignatureRepository _signatureRepository = SignatureRepository();

  List<PengajuanModel> listPengajuan = [];
  bool isLoading = false;
  String? errorMessage;
  int selectedTabIndex = 0;
  bool hasSignature = false;

  Future<void> checkSignatureStatus() async {
    final result = await _signatureRepository.getActiveSignature();
    hasSignature = result['success'] == true;
    notifyListeners();
  }

  void setTabIndex(int index) {
    selectedTabIndex = index;
    fetchPengajuan();
    notifyListeners();
  }

  Future<void> fetchPengajuan() async {
    isLoading = true;
    notifyListeners();

    try {
      String status = 'approved';
      if (selectedTabIndex == 1) status = 'pending';
      if (selectedTabIndex == 2) status = 'rejected';

      final submissions = await _repository.getPengajuan(status: status);
      final lemburResult = await _lemburRepository.getLemburHistory();

      List<PengajuanModel> lemburList = [];
      if (lemburResult['success'] == true && lemburResult['data'] != null) {
        final dynamic lemburData = lemburResult['data'];

        List rawData = [];
        if (lemburData is List) {
          rawData = lemburData;
        } else if (lemburData is Map && lemburData['data'] != null) {
          rawData = lemburData['data'];
        }

        lemburList = rawData
            .map((json) => PengajuanModel.fromLemburJson(json))
            .where((item) => item.status == status)
            .toList();
      }

      listPengajuan = [...submissions, ...lemburList];
      listPengajuan.sort((a, b) => b.tanggalPengajuan.compareTo(a.tanggalPengajuan));

    } catch (e) {
      // Gagal fetch pengajuan — abaikan error silently
    } finally {
      isLoading = false;
      notifyListeners();
    }
  }

  Future<bool> submitCuti(Map<String, dynamic> data) async {
     return await _submitGeneric('Cuti', data);
  }

  Future<bool> submitSakit(Map<String, dynamic> data) async {
     return await _submitGeneric('Sakit', data);
  }

  Future<bool> submitIzin(Map<String, dynamic> data) async {
     return await _submitGeneric('Izin', data);
  }

  Future<bool> submitLembur(Map<String, dynamic> data) async {
    isLoading = true;
    notifyListeners();
    try {
      final tanggalLembur = data['date'] as String;

      final result = await _lemburRepository.submitLembur(
        tanggalLembur: tanggalLembur,
        jamMulai: _convertTo24Hour(data['start_time']),
        jamSelesai: _convertTo24Hour(data['end_time']),
        keterangan: data['reason'],
        idKompensasi: data['id_kompensasi'],
      );

      return result['success'] == true;
    } catch(e) {
      print('Error submitting lembur: $e');
      return false;
    } finally {
      isLoading = false;
      notifyListeners();
    }
  }

  String _convertTo24Hour(String? timeStr) {
    if (timeStr == null || timeStr.isEmpty) return "00:00";

    // Jika sudah format HH:mm atau HH:mm:ss tanpa AM/PM
    if (!timeStr.toUpperCase().contains('AM') && !timeStr.toUpperCase().contains('PM')) {
      return timeStr.substring(0, 5); // Ambil HH:mm saja
    }

    try {
      // Bersihkan string dan pastikan ada spasi sebelum AM/PM jika menempel
      String cleaned = timeStr.toUpperCase().replaceAll('AM', ' AM').replaceAll('PM', ' PM').replaceAll(RegExp(r'\s+'), ' ').trim();
      
      final parts = cleaned.split(' ');
      if (parts.length < 2) return cleaned.substring(0, 5);

      final timeParts = parts[0].split(':');
      if (timeParts.length < 2) return "00:00";

      int hour = int.tryParse(timeParts[0]) ?? 0;
      final minute = timeParts[1];
      final period = parts[1];

      if (period == 'PM' && hour != 12) hour += 12;
      if (period == 'AM' && hour == 12) hour = 0;

      return '${hour.toString().padLeft(2, '0')}:${minute.padLeft(2, '0')}';
    } catch (e) {
      print('Error converting time: $e');
      return timeStr.length >= 5 ? timeStr.substring(0, 5) : "00:00";
    }
  }

  Future<bool> _submitGeneric(String type, Map<String, dynamic> data) async {
    isLoading = true;
    errorMessage = null;
    notifyListeners();
    try {
      return await _repository.submitPengajuan(type, data);
    } catch(e) {
      if (e.toString().contains('DioException')) {
        try {
          final dioError = e as dynamic;
          if (dioError.response?.data != null && dioError.response?.data['message'] != null) {
            errorMessage = dioError.response?.data['message'];
          } else {
            errorMessage = 'Pengajuan gagal: Kesalahan server.';
          }
        } catch(_) {
          errorMessage = 'Pengajuan gagal.';
        }
      } else {
         errorMessage = e.toString().replaceAll('Exception: ', '');
      }
      print('Error submitting $type: $errorMessage');
      return false;
    } finally {
      isLoading = false;
      notifyListeners();
    }
  }

  void reset() {
    listPengajuan = [];
    isLoading = false;
    errorMessage = null;
    selectedTabIndex = 0;
    hasSignature = false;
    notifyListeners();
  }
}