import 'dart:async';

import 'package:doublefeel_flutter/app/modules/friends/controllers/friends_controller.dart';
import 'package:doublefeel_flutter/app/modules/friends/data/friends_repository.dart';
import 'package:doublefeel_flutter/app/modules/friends/data/self_health_repository.dart';
import 'package:doublefeel_flutter/app/modules/friends/models/friend_health_data.dart';
import 'package:doublefeel_flutter/data/models/health/health_v2_models.dart';
import 'package:flutter_test/flutter_test.dart';

void main() {
  test('refresh loads friends and self health independently', () async {
    final friendsRepository = _FakeFriendsRepository();
    final selfHealthRepository = _FakeSelfHealthRepository();
    final controller = FriendsController(
      repository: friendsRepository,
      selfHealthRepository: selfHealthRepository,
    );

    final refresh = controller.refreshData();

    expect(friendsRepository.getFriendsCallCount, 1);
    expect(selfHealthRepository.getHealthDataCallCount, 1);
    expect(selfHealthRepository.getStressScoreCallCount, 1);
    expect(controller.isLoading.value, isTrue);
    expect(controller.isSelfHealthLoading.value, isTrue);

    selfHealthRepository.healthDataCompleter.complete(
      const V2HealthData(steps: 8424, sleepScore: 92),
    );
    await Future<void>.delayed(Duration.zero);

    expect(controller.selfHealthData.value?.steps, 8424);
    expect(controller.isSelfHealthLoading.value, isTrue);
    expect(controller.isLoading.value, isTrue);

    selfHealthRepository.stressScoreCompleter.complete(
      const V2StressScore(state: 2, comprehensiveScore: 72),
    );
    friendsRepository.friendsCompleter.complete(const []);
    await refresh;

    expect(controller.selfStressScore.value?.comprehensiveScore, 72);
    expect(controller.selfHealthUpdatedAt.value, isNotNull);
    expect(controller.isLoading.value, isFalse);
    expect(controller.isSelfHealthLoading.value, isFalse);
  });
}

class _FakeFriendsRepository implements FriendsRepository {
  final friendsCompleter = Completer<List<FriendHealthData>>();
  int getFriendsCallCount = 0;

  @override
  Future<List<FriendHealthData>> getFriends() {
    getFriendsCallCount++;
    return friendsCompleter.future;
  }

  @override
  Future<void> deleteFriend(int userId) async {}

  @override
  Future<void> selectWatchFaceFriend(int userId) async {}

  @override
  Future<void> updateRemark(int userId, String remark) async {}
}

class _FakeSelfHealthRepository implements SelfHealthRepository {
  final healthDataCompleter = Completer<V2HealthData>();
  final stressScoreCompleter = Completer<V2StressScore>();
  int getHealthDataCallCount = 0;
  int getStressScoreCallCount = 0;

  @override
  Future<V2HealthData> getHealthData(DateTime date) {
    getHealthDataCallCount++;
    return healthDataCompleter.future;
  }

  @override
  Future<V2StressScore> getStressScore(DateTime date) {
    getStressScoreCallCount++;
    return stressScoreCompleter.future;
  }
}