import 'package:flutter/material.dart';
import '../models/group_model.dart';
import '../models/group_member_model.dart';
import '../services/service_locator.dart';
import '../services/api/api_client.dart';

class GroupProvider extends ChangeNotifier {
  List<GroupModel> _groups = [];
  final Map<String, List<GroupMemberModel>> _membersCache = {};
  LoadStatus _status = LoadStatus.idle;
  String? _error;

  List<GroupModel> get groups => List.unmodifiable(_groups);
  LoadStatus get status => _status;
  String? get error => _error;
  bool get isLoading => _status == LoadStatus.loading;

  int get totalCount => _groups.length;
  int get activeCount => _groups.where((g) => g.isActive).length;

  List<GroupMemberModel> membersOf(String groupId) =>
      List.unmodifiable(_membersCache[groupId] ?? []);

  Future<void> loadGroups() async {
    _status = LoadStatus.loading;
    _error = null;
    notifyListeners();

    try {
      _groups = await ServiceLocator().groups.getGroups();
      _status = LoadStatus.success;
    } on ApiException catch (e) {
      _error = e.message;
      _status = LoadStatus.error;
    } catch (e) {
      _error = 'خطا در دریافت گروه‌ها';
      _status = LoadStatus.error;
    }
    notifyListeners();
  }

  Future<GroupModel?> createGroup(String name, String? description) async {
    _error = null;
    try {
      final group = await ServiceLocator().groups.createGroup(name, description);
      _groups = [..._groups, group];
      _membersCache[group.id] = [];
      notifyListeners();
      return group;
    } on ApiException catch (e) {
      _error = e.message;
      notifyListeners();
      return null;
    } catch (e) {
      _error = 'خطا در ایجاد گروه';
      notifyListeners();
      return null;
    }
  }

  Future<GroupMemberModel?> addMember(
    String groupId,
    String userId,
    GroupRole role,
    String? username,
  ) async {
    _error = null;
    try {
      final member =
          await ServiceLocator().groups.addMember(groupId, userId, role);
      final withUsername = member.copyWith(username: username);
      _membersCache.putIfAbsent(groupId, () => []).add(withUsername);

      // Refresh member count on cached group
      final idx = _groups.indexWhere((g) => g.id == groupId);
      if (idx != -1) {
        _groups[idx] = _groups[idx].copyWith(
          memberCount: _membersCache[groupId]!.length,
        );
      }
      notifyListeners();
      return withUsername;
    } on ApiException catch (e) {
      _error = e.message;
      notifyListeners();
      return null;
    } catch (e) {
      _error = 'خطا در افزودن عضو';
      notifyListeners();
      return null;
    }
  }

  Future<void> loadGroupMembers(String groupId) async {
    try {
      final members = await ServiceLocator().groups.getGroupMembers(groupId);
      _membersCache[groupId] = members.toList();
      notifyListeners();
    } on ApiException catch (e) {
      _error = e.message;
      notifyListeners();
    } catch (_) {
      // Silently fail — members may just not be loaded
    }
  }

  void clearError() {
    _error = null;
    notifyListeners();
  }
}

// Re-export to avoid importing user_provider for the enum
enum LoadStatus { idle, loading, success, error }