import 'dart:async';
import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';
import 'package:superport/core/errors/failures.dart';
import 'package:superport/models/license_model.dart';
import 'package:superport/services/license_service.dart';
import 'package:superport/services/mock_data_service.dart';

// 라이센스 상태 필터
enum LicenseStatusFilter {
  all,
  active,
  inactive,
  expiringSoon, // 30일 이내
  expired,
}

// 라이센스 목록 화면의 상태 및 비즈니스 로직을 담당하는 컨트롤러
class LicenseListController extends ChangeNotifier {
  final bool useApi;
  final MockDataService? mockDataService;
  late final LicenseService _licenseService;
  
  List<License> _licenses = [];
  List<License> _filteredLicenses = [];
  bool _isLoading = false;
  String? _error;
  String _searchQuery = '';
  int _currentPage = 1;
  final int _pageSize = 20;
  bool _hasMore = true;
  int _total = 0;

  // 필터 옵션
  int? _selectedCompanyId;
  bool? _isActive;
  String? _licenseType;
  LicenseStatusFilter _statusFilter = LicenseStatusFilter.all;
  String _sortBy = 'expiry_date';
  String _sortOrder = 'asc';
  
  // 선택된 라이선스 관리
  final Set<int> _selectedLicenseIds = {};
  
  // 통계 데이터
  Map<String, int> _statistics = {
    'total': 0,
    'active': 0,
    'inactive': 0,
    'expiringSoon': 0,
    'expired': 0,
  };
  
  // 검색 디바운스를 위한 타이머
  Timer? _debounceTimer;

  LicenseListController({this.useApi = false, this.mockDataService}) {
    if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
      _licenseService = GetIt.instance<LicenseService>();
    }
  }

  // Getters
  List<License> get licenses => _filteredLicenses;
  bool get isLoading => _isLoading;
  String? get error => _error;
  String get searchQuery => _searchQuery;
  int get currentPage => _currentPage;
  bool get hasMore => _hasMore;
  int get total => _total;
  int? get selectedCompanyId => _selectedCompanyId;
  bool? get isActive => _isActive;
  String? get licenseType => _licenseType;
  LicenseStatusFilter get statusFilter => _statusFilter;
  Set<int> get selectedLicenseIds => _selectedLicenseIds;
  Map<String, int> get statistics => _statistics;
  
  // 선택된 라이선스 개수
  int get selectedCount => _selectedLicenseIds.length;
  
  // 전체 선택 여부 확인
  bool get isAllSelected => 
      _filteredLicenses.isNotEmpty && 
      _filteredLicenses.where((l) => l.id != null)
          .every((l) => _selectedLicenseIds.contains(l.id));

  // 데이터 로드
  Future<void> loadData({bool isInitialLoad = true}) async {
    if (_isLoading) return;

    _isLoading = true;
    _error = null;
    
    if (isInitialLoad) {
      _currentPage = 1;
      _licenses.clear();
      _hasMore = true;
    }
    
    notifyListeners();

    try {
      if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
        debugPrint('📑 API 모드로 라이센스 로드 시작...');
        
        // API 사용
        final fetchedLicenses = await _licenseService.getLicenses(
          page: _currentPage,
          perPage: _pageSize,
          isActive: _isActive,
          companyId: _selectedCompanyId,
          licenseType: _licenseType,
        );
        
        debugPrint('📑 API에서 ${fetchedLicenses.length}개 라이센스 받음');

        if (isInitialLoad) {
          _licenses = fetchedLicenses;
          debugPrint('📑 초기 로드: _licenses에 ${_licenses.length}개 저장');
        } else {
          _licenses.addAll(fetchedLicenses);
          debugPrint('📑 추가 로드: _licenses에 총 ${_licenses.length}개');
        }

        _hasMore = fetchedLicenses.length >= _pageSize;
        
        // 전체 개수 조회
        debugPrint('📑 전체 개수 조회 시작...');
        _total = await _licenseService.getTotalLicenses(
          isActive: _isActive,
          companyId: _selectedCompanyId,
          licenseType: _licenseType,
        );
        debugPrint('📑 전체 개수: $_total');
      } else {
        // Mock 데이터 사용
        final allLicenses = mockDataService?.getAllLicenses() ?? [];
        
        // 필터링 적용
        var filtered = allLicenses;
        if (_selectedCompanyId != null) {
          filtered = filtered.where((l) => l.companyId == _selectedCompanyId).toList();
        }

        // 페이지네이션 적용
        final startIndex = (_currentPage - 1) * _pageSize;
        final endIndex = startIndex + _pageSize;
        
        if (startIndex < filtered.length) {
          final pageLicenses = filtered.sublist(
            startIndex,
            endIndex > filtered.length ? filtered.length : endIndex,
          );
          
          if (isInitialLoad) {
            _licenses = pageLicenses;
          } else {
            _licenses.addAll(pageLicenses);
          }
          
          _hasMore = endIndex < filtered.length;
        } else {
          _hasMore = false;
        }
        
        _total = filtered.length;
      }

      debugPrint('📑 _applySearchFilter 호출 전: _licenses=${_licenses.length}개');
      _applySearchFilter();
      _applyStatusFilter();
      await _updateStatistics();
      debugPrint('📑 _applySearchFilter 호출 후: _filteredLicenses=${_filteredLicenses.length}개');
    } catch (e) {
      debugPrint('❌ loadData 에러 발생: $e');
      _error = e.toString();
    } finally {
      _isLoading = false;
      debugPrint('📑 loadData 종료: _filteredLicenses=${_filteredLicenses.length}개');
      notifyListeners();
    }
  }

  // 다음 페이지 로드
  Future<void> loadNextPage() async {
    if (!_hasMore || _isLoading) return;
    _currentPage++;
    await loadData(isInitialLoad: false);
  }

  // 검색 (디바운싱 적용)
  void search(String query) {
    _searchQuery = query;
    
    // 기존 타이머 취소
    _debounceTimer?.cancel();
    
    // Mock 데이터는 즉시 검색
    if (!useApi) {
      _applySearchFilter();
      notifyListeners();
      return;
    }
    
    // API 검색은 디바운싱 적용 (300ms)
    _debounceTimer = Timer(const Duration(milliseconds: 300), () {
      loadData();
    });
  }

  // 검색 필터 적용
  void _applySearchFilter() {
    debugPrint('🔎 _applySearchFilter 시작: _searchQuery="$_searchQuery", _licenses=${_licenses.length}개');
    
    if (_searchQuery.isEmpty) {
      _filteredLicenses = List.from(_licenses);
      debugPrint('🔎 검색어 없음: 전체 복사 ${_filteredLicenses.length}개');
    } else {
      _filteredLicenses = _licenses.where((license) {
        final productName = license.productName?.toLowerCase() ?? '';
        final licenseKey = license.licenseKey.toLowerCase();
        final vendor = license.vendor?.toLowerCase() ?? '';
        final companyName = license.companyName?.toLowerCase() ?? '';
        final searchLower = _searchQuery.toLowerCase();
        
        return productName.contains(searchLower) ||
               licenseKey.contains(searchLower) ||
               vendor.contains(searchLower) ||
               companyName.contains(searchLower);
      }).toList();
      debugPrint('🔎 검색 필터링 완료: ${_filteredLicenses.length}개');
    }
  }
  
  // 상태 필터 적용
  void _applyStatusFilter() {
    if (_statusFilter == LicenseStatusFilter.all) return;
    
    final now = DateTime.now();
    _filteredLicenses = _filteredLicenses.where((license) {
      switch (_statusFilter) {
        case LicenseStatusFilter.active:
          return license.isActive;
        case LicenseStatusFilter.inactive:
          return !license.isActive;
        case LicenseStatusFilter.expiringSoon:
          if (license.expiryDate != null) {
            final days = license.expiryDate!.difference(now).inDays;
            return days > 0 && days <= 30;
          }
          return false;
        case LicenseStatusFilter.expired:
          if (license.expiryDate != null) {
            return license.expiryDate!.isBefore(now);
          }
          return false;
        case LicenseStatusFilter.all:
        default:
          return true;
      }
    }).toList();
  }

  // 필터 설정
  void setFilters({
    int? companyId,
    bool? isActive,
    String? licenseType,
  }) {
    _selectedCompanyId = companyId;
    _isActive = isActive;
    _licenseType = licenseType;
    loadData();
  }

  // 필터 초기화
  void clearFilters() {
    _selectedCompanyId = null;
    _isActive = null;
    _licenseType = null;
    _searchQuery = '';
    loadData();
  }

  // 라이센스 삭제
  Future<void> deleteLicense(int id) async {
    try {
      if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
        await _licenseService.deleteLicense(id);
      } else {
        mockDataService?.deleteLicense(id);
      }
      
      // 목록에서 제거
      _licenses.removeWhere((l) => l.id == id);
      _applySearchFilter();
      _total--;
      notifyListeners();
    } catch (e) {
      _error = e.toString();
      notifyListeners();
    }
  }

  // 새로고침
  Future<void> refresh() async {
    await loadData();
  }

  // 만료 예정 라이선스 조회
  Future<List<License>> getExpiringLicenses({int days = 30}) async {
    try {
      if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
        return await _licenseService.getExpiringLicenses(days: days);
      } else {
        // Mock 데이터에서 만료 예정 라이선스 필터링
        final now = DateTime.now();
        final allLicenses = mockDataService?.getAllLicenses() ?? [];
        
        return allLicenses.where((license) {
          // 실제 License 모델에서 만료일 확인
          if (license.expiryDate != null) {
            final daysUntilExpiry = license.expiryDate!.difference(now).inDays;
            return daysUntilExpiry > 0 && daysUntilExpiry <= days;
          }
          return false;
        }).toList();
      }
    } catch (e) {
      _error = e.toString();
      notifyListeners();
      return [];
    }
  }
  
  // 상태별 라이선스 개수 조회
  Future<Map<String, int>> getLicenseStatusCounts() async {
    if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
      try {
        // API에서 상태별 개수 조회 (실제로는 별도 엔드포인트가 있다면 사용)
        final activeCount = await _licenseService.getTotalLicenses(isActive: true);
        final inactiveCount = await _licenseService.getTotalLicenses(isActive: false);
        final expiringLicenses = await getExpiringLicenses(days: 30);
        
        return {
          'active': activeCount,
          'inactive': inactiveCount,
          'expiring': expiringLicenses.length,
          'total': activeCount + inactiveCount,
        };
      } catch (e) {
        return {'active': 0, 'inactive': 0, 'expiring': 0, 'total': 0};
      }
    } else {
      // Mock 데이터에서 계산
      final allLicenses = mockDataService?.getAllLicenses() ?? [];
      final now = DateTime.now();
      
      int activeCount = 0;
      int expiredCount = 0;
      int expiringCount = 0;
      
      for (var license in allLicenses) {
        if (license.isActive) {
          activeCount++;
          
          if (license.expiryDate != null) {
            final daysUntilExpiry = license.expiryDate!.difference(now).inDays;
            if (daysUntilExpiry <= 0) {
              expiredCount++;
            } else if (daysUntilExpiry <= 30) {
              expiringCount++;
            }
          }
        }
      }
      
      return {
        'active': activeCount,
        'inactive': allLicenses.length - activeCount,
        'expiring': expiringCount,
        'expired': expiredCount,
        'total': allLicenses.length,
      };
    }
  }
  
  // 정렬 변경
  void sortBy(String field, String order) {
    _sortBy = field;
    _sortOrder = order;
    loadData();
  }
  
  // 상태 필터 변경
  Future<void> changeStatusFilter(LicenseStatusFilter filter) async {
    _statusFilter = filter;
    await loadData();
  }
  
  // 라이선스 선택/해제
  void selectLicense(int? id, bool? isSelected) {
    if (id == null) return;
    
    if (isSelected == true) {
      _selectedLicenseIds.add(id);
    } else {
      _selectedLicenseIds.remove(id);
    }
    notifyListeners();
  }
  
  // 전체 선택/해제
  void selectAll(bool? isSelected) {
    if (isSelected == true) {
      // 현재 필터링된 라이선스 모두 선택
      for (var license in _filteredLicenses) {
        if (license.id != null) {
          _selectedLicenseIds.add(license.id!);
        }
      }
    } else {
      // 모두 해제
      _selectedLicenseIds.clear();
    }
    notifyListeners();
  }
  
  // 선택된 라이선스 목록 반환
  List<License> getSelectedLicenses() {
    return _filteredLicenses
        .where((l) => l.id != null && _selectedLicenseIds.contains(l.id))
        .toList();
  }
  
  // 선택 초기화
  void clearSelection() {
    _selectedLicenseIds.clear();
    notifyListeners();
  }
  
  // 라이선스 할당
  Future<bool> assignLicense(int licenseId, int userId) async {
    try {
      if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
        await _licenseService.assignLicense(licenseId, userId);
        await loadData();
        clearSelection();
        return true;
      }
      return false;
    } catch (e) {
      _error = e.toString();
      notifyListeners();
      return false;
    }
  }
  
  // 라이선스 할당 해제
  Future<bool> unassignLicense(int licenseId) async {
    try {
      if (useApi && GetIt.instance.isRegistered<LicenseService>()) {
        await _licenseService.unassignLicense(licenseId);
        await loadData();
        clearSelection();
        return true;
      }
      return false;
    } catch (e) {
      _error = e.toString();
      notifyListeners();
      return false;
    }
  }
  
  // 선택된 라이선스 일괄 삭제
  Future<void> deleteSelectedLicenses() async {
    if (_selectedLicenseIds.isEmpty) return;
    
    final selectedIds = List<int>.from(_selectedLicenseIds);
    int successCount = 0;
    int failCount = 0;
    
    for (var id in selectedIds) {
      try {
        await deleteLicense(id);
        successCount++;
      } catch (e) {
        failCount++;
        debugPrint('라이선스 $id 삭제 실패: $e');
      }
    }
    
    _selectedLicenseIds.clear();
    await loadData();
    
    if (successCount > 0) {
      debugPrint('✅ $successCount개 라이선스 삭제 완료');
    }
    if (failCount > 0) {
      debugPrint('❌ $failCount개 라이선스 삭제 실패');
    }
  }
  
  // 통계 업데이트
  Future<void> _updateStatistics() async {
    try {
      final counts = await getLicenseStatusCounts();
      
      final now = DateTime.now();
      int expiringSoonCount = 0;
      int expiredCount = 0;
      
      for (var license in _licenses) {
        if (license.expiryDate != null) {
          final days = license.expiryDate!.difference(now).inDays;
          if (days <= 0) {
            expiredCount++;
          } else if (days <= 30) {
            expiringSoonCount++;
          }
        }
      }
      
      _statistics = {
        'total': counts['total'] ?? 0,
        'active': counts['active'] ?? 0,
        'inactive': counts['inactive'] ?? 0,
        'expiringSoon': expiringSoonCount,
        'expired': expiredCount,
      };
    } catch (e) {
      debugPrint('❌ 통계 업데이트 오류: $e');
      // 오류 발생 시 기본값 사용
      _statistics = {
        'total': _licenses.length,
        'active': 0,
        'inactive': 0,
        'expiringSoon': 0,
        'expired': 0,
      };
    }
  }
  
  // 만료일까지 남은 일수 계산
  int? getDaysUntilExpiry(License license) {
    if (license.expiryDate == null) return null;
    return license.expiryDate!.difference(DateTime.now()).inDays;
  }
  
  @override
  void dispose() {
    _debounceTimer?.cancel();
    super.dispose();
  }
}
