730 lines
24 KiB
Dart
730 lines
24 KiB
Dart
import 'dart:convert';
|
||
import 'dart:math';
|
||
import '../../../core/network/api_client.dart';
|
||
import '../../../core/services/storage_service.dart';
|
||
import '../models/learning_stats_model.dart';
|
||
|
||
/// 学习统计服务
|
||
class LearningStatsService {
|
||
final ApiClient _apiClient;
|
||
final StorageService _storageService;
|
||
|
||
static const String _statsKey = 'learning_stats';
|
||
static const String _achievementsKey = 'achievements';
|
||
static const String _dailyRecordsKey = 'daily_records';
|
||
|
||
LearningStatsService({
|
||
required ApiClient apiClient,
|
||
required StorageService storageService,
|
||
}) : _apiClient = apiClient,
|
||
_storageService = storageService;
|
||
|
||
/// 获取用户学习统计
|
||
Future<LearningStats> getUserStats() async {
|
||
try {
|
||
// 1. 从后端API获取每日、每周、每月统计数据
|
||
final today = DateTime.now();
|
||
final sevenDaysAgo = today.subtract(const Duration(days: 7));
|
||
final thirtyDaysAgo = today.subtract(const Duration(days: 30));
|
||
|
||
final startDateStr = thirtyDaysAgo.toIso8601String().split('T')[0];
|
||
final endDateStr = today.toIso8601String().split('T')[0];
|
||
|
||
print('🔍 开始获取学习统计: startDate=$startDateStr, endDate=$endDateStr');
|
||
print('🔍 请求路径: /vocabulary/study/statistics/history');
|
||
|
||
// 获取历史统计数据
|
||
final response = await _apiClient.get(
|
||
'/vocabulary/study/statistics/history',
|
||
queryParameters: {
|
||
'startDate': startDateStr,
|
||
'endDate': endDateStr,
|
||
},
|
||
);
|
||
|
||
print('✅ API响应成功: statusCode=${response.statusCode}');
|
||
|
||
final List<dynamic> historyData = response.data['data'] ?? [];
|
||
final dailyRecords = historyData.map((item) => DailyStudyRecord.fromJson(item)).toList();
|
||
|
||
print('📊 获取到 ${dailyRecords.length} 天的学习记录');
|
||
|
||
// 2. 计算总体统计
|
||
final totalWordsLearned = dailyRecords.fold(0, (sum, record) => sum + record.wordsLearned);
|
||
final totalWordsReviewed = dailyRecords.fold(0, (sum, record) => sum + record.wordsReviewed);
|
||
final totalStudyTimeMinutes = dailyRecords.fold(0, (sum, record) => sum + record.studyTimeMinutes);
|
||
final totalExp = dailyRecords.fold(0, (sum, record) => sum + record.expGained);
|
||
|
||
// 3. 计算连续学习天数
|
||
final currentStreak = _calculateCurrentStreak(dailyRecords);
|
||
final maxStreak = _calculateMaxStreak(dailyRecords);
|
||
|
||
// 4. 计算周统计（使用最近7天的记录）
|
||
final weeklyRecords = dailyRecords.where((record) {
|
||
return record.date.isAfter(sevenDaysAgo.subtract(const Duration(days: 1)));
|
||
}).toList();
|
||
final weeklyStats = _calculateWeeklyStats(weeklyRecords);
|
||
|
||
print('📅 本周学习记录: ${weeklyRecords.length} 天, 学习 ${weeklyStats.wordsLearned} 个单词');
|
||
|
||
// 5. 计算月统计（使用最近30天的记录）
|
||
final monthlyRecords = dailyRecords;
|
||
|
||
// 计算本月的周统计记录（用于柱状图）
|
||
final weeklyStatsList = <WeeklyStats>[];
|
||
final firstDayOfMonth = DateTime(today.year, today.month, 1);
|
||
DateTime currentWeekStart = firstDayOfMonth;
|
||
|
||
while (currentWeekStart.isBefore(today)) {
|
||
final weekEnd = currentWeekStart.add(const Duration(days: 6));
|
||
final weekRecords = dailyRecords.where((record) {
|
||
return record.date.isAfter(currentWeekStart.subtract(const Duration(days: 1))) &&
|
||
record.date.isBefore(weekEnd.add(const Duration(days: 1)));
|
||
}).toList();
|
||
|
||
if (weekRecords.isNotEmpty || currentWeekStart.isBefore(today)) {
|
||
weeklyStatsList.add(_calculateWeeklyStats(weekRecords));
|
||
}
|
||
|
||
currentWeekStart = currentWeekStart.add(const Duration(days: 7));
|
||
}
|
||
|
||
final monthlyStats = _calculateMonthlyStats(monthlyRecords, weeklyStatsList);
|
||
|
||
print('📆 本月学习记录: ${monthlyRecords.length} 天, 学习 ${monthlyStats.wordsLearned} 个单词, ${weeklyStatsList.length} 周数据');
|
||
|
||
// 6. 计算等级和经验值
|
||
final level = calculateLevel(totalExp);
|
||
final nextLevelExp = calculateNextLevelExp(level);
|
||
final currentExp = calculateCurrentLevelExp(totalExp, level);
|
||
|
||
// 7. 计算平均值
|
||
final studyDays = dailyRecords.length;
|
||
final averageDailyWords = studyDays > 0 ? totalWordsLearned / studyDays : 0.0;
|
||
final averageDailyMinutes = studyDays > 0 ? totalStudyTimeMinutes / studyDays : 0.0;
|
||
|
||
// 8. 计算准确率
|
||
final totalTests = dailyRecords.fold(0, (sum, record) => sum + record.testsCompleted);
|
||
final averageAccuracy = totalTests > 0
|
||
? dailyRecords.fold(0.0, (sum, record) => sum + record.accuracyRate) / totalTests
|
||
: 0.0;
|
||
|
||
final stats = LearningStats(
|
||
userId: 'current_user',
|
||
totalStudyDays: studyDays,
|
||
currentStreak: currentStreak,
|
||
maxStreak: maxStreak,
|
||
totalWordsLearned: totalWordsLearned,
|
||
totalWordsReviewed: totalWordsReviewed,
|
||
totalStudyTimeMinutes: totalStudyTimeMinutes,
|
||
averageDailyWords: averageDailyWords,
|
||
averageDailyMinutes: averageDailyMinutes,
|
||
accuracyRate: averageAccuracy,
|
||
completedBooks: 0,
|
||
currentBooks: 0,
|
||
masteredWords: 0,
|
||
learningWords: 0,
|
||
reviewWords: 0,
|
||
weeklyStats: weeklyStats,
|
||
monthlyStats: monthlyStats,
|
||
level: level,
|
||
currentExp: currentExp,
|
||
nextLevelExp: nextLevelExp,
|
||
lastStudyTime: dailyRecords.isNotEmpty ? dailyRecords.last.date : null,
|
||
createdAt: DateTime.now(),
|
||
updatedAt: DateTime.now(),
|
||
dailyRecords: dailyRecords,
|
||
achievements: [],
|
||
leaderboard: null,
|
||
);
|
||
|
||
// 保存到本地缓存
|
||
await _saveStatsToLocal(stats);
|
||
|
||
return stats;
|
||
} catch (e, stackTrace) {
|
||
print('❌ 从API获取学习统计失败: $e');
|
||
print('❌ 错误堆栈: $stackTrace');
|
||
|
||
// 如果API失败，尝试从本地缓存加载
|
||
final localData = await _storageService.getString(_statsKey);
|
||
if (localData != null) {
|
||
print('💾 从本地缓存加载数据');
|
||
return LearningStats.fromJson(json.decode(localData));
|
||
}
|
||
// 如果本地也没有，返回默认数据
|
||
print('⚠️ 返回默认数据');
|
||
return _createDefaultStats();
|
||
}
|
||
}
|
||
|
||
/// 更新学习统计
|
||
Future<LearningStats> updateStats({
|
||
required int wordsLearned,
|
||
required int wordsReviewed,
|
||
required int studyTimeMinutes,
|
||
required double accuracyRate,
|
||
List<String> vocabularyBookIds = const [],
|
||
}) async {
|
||
try {
|
||
final currentStats = await getUserStats();
|
||
final today = DateTime.now();
|
||
|
||
// 更新每日记录
|
||
await _updateDailyRecord(
|
||
date: today,
|
||
wordsLearned: wordsLearned,
|
||
wordsReviewed: wordsReviewed,
|
||
studyTimeMinutes: studyTimeMinutes,
|
||
accuracyRate: accuracyRate,
|
||
vocabularyBookIds: vocabularyBookIds,
|
||
);
|
||
|
||
// 计算新的统计数据
|
||
final updatedStats = await _calculateUpdatedStats(currentStats);
|
||
|
||
// 保存到本地
|
||
await _saveStatsToLocal(updatedStats);
|
||
|
||
return updatedStats;
|
||
} catch (e) {
|
||
throw Exception('更新学习统计失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 获取每日学习记录
|
||
Future<List<DailyStudyRecord>> getDailyRecords({
|
||
DateTime? startDate,
|
||
DateTime? endDate,
|
||
}) async {
|
||
try {
|
||
final localData = await _storageService.getString(_dailyRecordsKey);
|
||
if (localData == null) {
|
||
return [];
|
||
}
|
||
|
||
final Map<String, dynamic> recordsMap = json.decode(localData);
|
||
final records = recordsMap.values
|
||
.map((json) => DailyStudyRecord.fromJson(json))
|
||
.toList();
|
||
|
||
// 按日期过滤
|
||
if (startDate != null || endDate != null) {
|
||
return records.where((record) {
|
||
if (startDate != null && record.date.isBefore(startDate)) {
|
||
return false;
|
||
}
|
||
if (endDate != null && record.date.isAfter(endDate)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}).toList();
|
||
}
|
||
|
||
return records;
|
||
} catch (e) {
|
||
throw Exception('获取每日记录失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 获取周统计
|
||
Future<WeeklyStats> getWeeklyStats([DateTime? weekStart]) async {
|
||
try {
|
||
final startDate = weekStart ?? _getWeekStart(DateTime.now());
|
||
final endDate = startDate.add(const Duration(days: 6));
|
||
|
||
final dailyRecords = await getDailyRecords(
|
||
startDate: startDate,
|
||
endDate: endDate,
|
||
);
|
||
|
||
return _calculateWeeklyStats(dailyRecords);
|
||
} catch (e) {
|
||
throw Exception('获取周统计失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 获取月统计
|
||
Future<MonthlyStats> getMonthlyStats([DateTime? month]) async {
|
||
try {
|
||
final targetMonth = month ?? DateTime.now();
|
||
final startDate = DateTime(targetMonth.year, targetMonth.month, 1);
|
||
final endDate = DateTime(targetMonth.year, targetMonth.month + 1, 0);
|
||
|
||
final dailyRecords = await getDailyRecords(
|
||
startDate: startDate,
|
||
endDate: endDate,
|
||
);
|
||
|
||
// 计算周统计
|
||
final weeklyRecords = <WeeklyStats>[];
|
||
DateTime currentWeekStart = startDate;
|
||
|
||
while (currentWeekStart.isBefore(endDate)) {
|
||
final weekEnd = currentWeekStart.add(const Duration(days: 6));
|
||
final weekRecords = dailyRecords.where((record) {
|
||
return record.date.isAfter(currentWeekStart.subtract(const Duration(days: 1))) &&
|
||
record.date.isBefore(weekEnd.add(const Duration(days: 1)));
|
||
}).toList();
|
||
|
||
weeklyRecords.add(_calculateWeeklyStats(weekRecords));
|
||
currentWeekStart = currentWeekStart.add(const Duration(days: 7));
|
||
}
|
||
|
||
return _calculateMonthlyStats(dailyRecords, weeklyRecords);
|
||
} catch (e) {
|
||
throw Exception('获取月统计失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 获取用户成就
|
||
Future<List<Achievement>> getUserAchievements() async {
|
||
try {
|
||
final localData = await _storageService.getString(_achievementsKey);
|
||
if (localData != null) {
|
||
final List<dynamic> jsonList = json.decode(localData);
|
||
return jsonList.map((json) => Achievement.fromJson(json)).toList();
|
||
}
|
||
|
||
// 返回默认成就列表
|
||
return _createDefaultAchievements();
|
||
} catch (e) {
|
||
throw Exception('获取成就失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 检查并解锁成就
|
||
Future<List<Achievement>> checkAndUnlockAchievements() async {
|
||
try {
|
||
final stats = await getUserStats();
|
||
final achievements = await getUserAchievements();
|
||
final unlockedAchievements = <Achievement>[];
|
||
|
||
for (final achievement in achievements) {
|
||
if (!achievement.isUnlocked) {
|
||
final shouldUnlock = _checkAchievementCondition(achievement, stats);
|
||
if (shouldUnlock) {
|
||
final unlockedAchievement = achievement.copyWith(
|
||
isUnlocked: true,
|
||
unlockedAt: DateTime.now(),
|
||
);
|
||
unlockedAchievements.add(unlockedAchievement);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (unlockedAchievements.isNotEmpty) {
|
||
// 更新成就列表
|
||
final updatedAchievements = achievements.map((achievement) {
|
||
final unlocked = unlockedAchievements
|
||
.where((a) => a.id == achievement.id)
|
||
.firstOrNull;
|
||
return unlocked ?? achievement;
|
||
}).toList();
|
||
|
||
await _saveAchievementsToLocal(updatedAchievements);
|
||
}
|
||
|
||
return unlockedAchievements;
|
||
} catch (e) {
|
||
throw Exception('检查成就失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 获取排行榜
|
||
Future<Leaderboard> getLeaderboard({
|
||
required LeaderboardType type,
|
||
required LeaderboardPeriod period,
|
||
}) async {
|
||
try {
|
||
// 模拟排行榜数据
|
||
final entries = _generateMockLeaderboardEntries(type);
|
||
|
||
return Leaderboard(
|
||
type: type,
|
||
period: period,
|
||
entries: entries,
|
||
userRank: Random().nextInt(100) + 1,
|
||
updatedAt: DateTime.now(),
|
||
);
|
||
} catch (e) {
|
||
throw Exception('获取排行榜失败: $e');
|
||
}
|
||
}
|
||
|
||
/// 计算用户等级
|
||
int calculateLevel(int totalExp) {
|
||
// 等级计算公式：level = floor(sqrt(totalExp / 100))
|
||
return (sqrt(totalExp / 100)).floor() + 1;
|
||
}
|
||
|
||
/// 计算升级所需经验值
|
||
int calculateNextLevelExp(int level) {
|
||
// 下一级所需总经验值：(level^2) * 100
|
||
return level * level * 100;
|
||
}
|
||
|
||
/// 计算当前等级经验值
|
||
int calculateCurrentLevelExp(int totalExp, int level) {
|
||
final currentLevelTotalExp = (level - 1) * (level - 1) * 100;
|
||
return totalExp - currentLevelTotalExp;
|
||
}
|
||
|
||
/// 更新每日记录
|
||
Future<void> _updateDailyRecord({
|
||
required DateTime date,
|
||
required int wordsLearned,
|
||
required int wordsReviewed,
|
||
required int studyTimeMinutes,
|
||
required double accuracyRate,
|
||
required List<String> vocabularyBookIds,
|
||
}) async {
|
||
final dateKey = _formatDateKey(date);
|
||
final recordsData = await _storageService.getString(_dailyRecordsKey);
|
||
|
||
Map<String, dynamic> records = {};
|
||
if (recordsData != null) {
|
||
records = json.decode(recordsData);
|
||
}
|
||
|
||
// 获取现有记录或创建新记录
|
||
DailyStudyRecord existingRecord;
|
||
if (records.containsKey(dateKey)) {
|
||
existingRecord = DailyStudyRecord.fromJson(records[dateKey]);
|
||
} else {
|
||
existingRecord = DailyStudyRecord(
|
||
date: DateTime(date.year, date.month, date.day),
|
||
wordsLearned: 0,
|
||
wordsReviewed: 0,
|
||
studyTimeMinutes: 0,
|
||
accuracyRate: 0.0,
|
||
testsCompleted: 0,
|
||
expGained: 0,
|
||
vocabularyBookIds: [],
|
||
);
|
||
}
|
||
|
||
// 更新记录
|
||
final updatedRecord = DailyStudyRecord(
|
||
date: existingRecord.date,
|
||
wordsLearned: existingRecord.wordsLearned + wordsLearned,
|
||
wordsReviewed: existingRecord.wordsReviewed + wordsReviewed,
|
||
studyTimeMinutes: existingRecord.studyTimeMinutes + studyTimeMinutes,
|
||
accuracyRate: (existingRecord.accuracyRate + accuracyRate) / 2,
|
||
testsCompleted: existingRecord.testsCompleted + 1,
|
||
expGained: existingRecord.expGained + _calculateExpGained(wordsLearned, wordsReviewed, accuracyRate),
|
||
vocabularyBookIds: [...existingRecord.vocabularyBookIds, ...vocabularyBookIds].toSet().toList(),
|
||
);
|
||
|
||
records[dateKey] = updatedRecord.toJson();
|
||
await _storageService.setString(_dailyRecordsKey, json.encode(records));
|
||
}
|
||
|
||
/// 计算更新后的统计数据
|
||
Future<LearningStats> _calculateUpdatedStats(LearningStats currentStats) async {
|
||
final allRecords = await getDailyRecords();
|
||
|
||
// 计算总数据
|
||
final totalWordsLearned = allRecords.fold(0, (sum, record) => sum + record.wordsLearned);
|
||
final totalWordsReviewed = allRecords.fold(0, (sum, record) => sum + record.wordsReviewed);
|
||
final totalStudyTimeMinutes = allRecords.fold(0, (sum, record) => sum + record.studyTimeMinutes);
|
||
final totalExp = allRecords.fold(0, (sum, record) => sum + record.expGained);
|
||
|
||
// 计算连续学习天数
|
||
final currentStreak = _calculateCurrentStreak(allRecords);
|
||
final maxStreak = _calculateMaxStreak(allRecords);
|
||
|
||
// 计算平均值
|
||
final studyDays = allRecords.length;
|
||
final averageDailyWords = studyDays > 0 ? totalWordsLearned / studyDays : 0.0;
|
||
final averageDailyMinutes = studyDays > 0 ? totalStudyTimeMinutes / studyDays : 0.0;
|
||
|
||
// 计算准确率
|
||
final totalTests = allRecords.fold(0, (sum, record) => sum + record.testsCompleted);
|
||
final averageAccuracy = totalTests > 0
|
||
? allRecords.fold(0.0, (sum, record) => sum + record.accuracyRate) / totalTests
|
||
: 0.0;
|
||
|
||
// 计算等级
|
||
final level = calculateLevel(totalExp);
|
||
final nextLevelExp = calculateNextLevelExp(level);
|
||
final currentExp = calculateCurrentLevelExp(totalExp, level);
|
||
|
||
// 获取周月统计
|
||
final weeklyStats = await getWeeklyStats();
|
||
final monthlyStats = await getMonthlyStats();
|
||
|
||
return currentStats.copyWith(
|
||
totalStudyDays: studyDays,
|
||
currentStreak: currentStreak,
|
||
maxStreak: maxStreak > currentStats.maxStreak ? maxStreak : currentStats.maxStreak,
|
||
totalWordsLearned: totalWordsLearned,
|
||
totalWordsReviewed: totalWordsReviewed,
|
||
totalStudyTimeMinutes: totalStudyTimeMinutes,
|
||
averageDailyWords: averageDailyWords,
|
||
averageDailyMinutes: averageDailyMinutes,
|
||
accuracyRate: averageAccuracy,
|
||
weeklyStats: weeklyStats,
|
||
monthlyStats: monthlyStats,
|
||
level: level,
|
||
currentExp: currentExp,
|
||
nextLevelExp: nextLevelExp,
|
||
lastStudyTime: DateTime.now(),
|
||
updatedAt: DateTime.now(),
|
||
);
|
||
}
|
||
|
||
/// 创建默认统计数据
|
||
LearningStats _createDefaultStats() {
|
||
final now = DateTime.now();
|
||
return LearningStats(
|
||
userId: 'current_user',
|
||
totalStudyDays: 0,
|
||
currentStreak: 0,
|
||
maxStreak: 0,
|
||
totalWordsLearned: 0,
|
||
totalWordsReviewed: 0,
|
||
totalStudyTimeMinutes: 0,
|
||
averageDailyWords: 0.0,
|
||
averageDailyMinutes: 0.0,
|
||
accuracyRate: 0.0,
|
||
completedBooks: 0,
|
||
currentBooks: 0,
|
||
masteredWords: 0,
|
||
learningWords: 0,
|
||
reviewWords: 0,
|
||
weeklyStats: WeeklyStats(
|
||
studyDays: 0,
|
||
wordsLearned: 0,
|
||
wordsReviewed: 0,
|
||
studyTimeMinutes: 0,
|
||
accuracyRate: 0.0,
|
||
dailyRecords: [],
|
||
),
|
||
monthlyStats: MonthlyStats(
|
||
studyDays: 0,
|
||
wordsLearned: 0,
|
||
wordsReviewed: 0,
|
||
studyTimeMinutes: 0,
|
||
accuracyRate: 0.0,
|
||
completedBooks: 0,
|
||
weeklyRecords: [],
|
||
),
|
||
level: 1,
|
||
currentExp: 0,
|
||
nextLevelExp: 100,
|
||
lastStudyTime: null,
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
dailyRecords: [],
|
||
achievements: [],
|
||
leaderboard: null,
|
||
);
|
||
}
|
||
|
||
/// 创建默认成就列表
|
||
List<Achievement> _createDefaultAchievements() {
|
||
return [
|
||
Achievement(
|
||
id: 'first_word',
|
||
name: '初学者',
|
||
description: '学习第一个单词',
|
||
icon: '🌱',
|
||
type: AchievementType.wordsLearned,
|
||
isUnlocked: false,
|
||
progress: 0,
|
||
target: 1,
|
||
rewardExp: 10,
|
||
),
|
||
Achievement(
|
||
id: 'hundred_words',
|
||
name: '百词斩',
|
||
description: '累计学习100个单词',
|
||
icon: '💯',
|
||
type: AchievementType.wordsLearned,
|
||
isUnlocked: false,
|
||
progress: 0,
|
||
target: 100,
|
||
rewardExp: 100,
|
||
),
|
||
Achievement(
|
||
id: 'first_streak',
|
||
name: '坚持不懈',
|
||
description: '连续学习7天',
|
||
icon: '🔥',
|
||
type: AchievementType.streak,
|
||
isUnlocked: false,
|
||
progress: 0,
|
||
target: 7,
|
||
rewardExp: 50,
|
||
),
|
||
Achievement(
|
||
id: 'month_streak',
|
||
name: '月度达人',
|
||
description: '连续学习30天',
|
||
icon: '🏆',
|
||
type: AchievementType.streak,
|
||
isUnlocked: false,
|
||
progress: 0,
|
||
target: 30,
|
||
rewardExp: 300,
|
||
),
|
||
];
|
||
}
|
||
|
||
/// 计算周统计
|
||
WeeklyStats _calculateWeeklyStats(List<DailyStudyRecord> dailyRecords) {
|
||
final studyDays = dailyRecords.length;
|
||
final wordsLearned = dailyRecords.fold(0, (sum, record) => sum + record.wordsLearned);
|
||
final wordsReviewed = dailyRecords.fold(0, (sum, record) => sum + record.wordsReviewed);
|
||
final studyTimeMinutes = dailyRecords.fold(0, (sum, record) => sum + record.studyTimeMinutes);
|
||
final totalTests = dailyRecords.fold(0, (sum, record) => sum + record.testsCompleted);
|
||
final accuracyRate = totalTests > 0
|
||
? dailyRecords.fold(0.0, (sum, record) => sum + record.accuracyRate) / totalTests
|
||
: 0.0;
|
||
|
||
return WeeklyStats(
|
||
studyDays: studyDays,
|
||
wordsLearned: wordsLearned,
|
||
wordsReviewed: wordsReviewed,
|
||
studyTimeMinutes: studyTimeMinutes,
|
||
accuracyRate: accuracyRate,
|
||
dailyRecords: dailyRecords,
|
||
);
|
||
}
|
||
|
||
/// 计算月统计
|
||
MonthlyStats _calculateMonthlyStats(
|
||
List<DailyStudyRecord> dailyRecords,
|
||
List<WeeklyStats> weeklyRecords,
|
||
) {
|
||
final studyDays = dailyRecords.length;
|
||
final wordsLearned = dailyRecords.fold(0, (sum, record) => sum + record.wordsLearned);
|
||
final wordsReviewed = dailyRecords.fold(0, (sum, record) => sum + record.wordsReviewed);
|
||
final studyTimeMinutes = dailyRecords.fold(0, (sum, record) => sum + record.studyTimeMinutes);
|
||
final totalTests = dailyRecords.fold(0, (sum, record) => sum + record.testsCompleted);
|
||
final accuracyRate = totalTests > 0
|
||
? dailyRecords.fold(0.0, (sum, record) => sum + record.accuracyRate) / totalTests
|
||
: 0.0;
|
||
|
||
return MonthlyStats(
|
||
studyDays: studyDays,
|
||
wordsLearned: wordsLearned,
|
||
wordsReviewed: wordsReviewed,
|
||
studyTimeMinutes: studyTimeMinutes,
|
||
accuracyRate: accuracyRate,
|
||
completedBooks: 0, // TODO: 从实际数据计算
|
||
weeklyRecords: weeklyRecords,
|
||
);
|
||
}
|
||
|
||
/// 计算当前连续学习天数
|
||
int _calculateCurrentStreak(List<DailyStudyRecord> records) {
|
||
if (records.isEmpty) return 0;
|
||
|
||
records.sort((a, b) => b.date.compareTo(a.date));
|
||
|
||
int streak = 0;
|
||
DateTime currentDate = DateTime.now();
|
||
|
||
for (final record in records) {
|
||
final daysDiff = currentDate.difference(record.date).inDays;
|
||
|
||
if (daysDiff == streak) {
|
||
streak++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return streak;
|
||
}
|
||
|
||
/// 计算最大连续学习天数
|
||
int _calculateMaxStreak(List<DailyStudyRecord> records) {
|
||
if (records.isEmpty) return 0;
|
||
|
||
records.sort((a, b) => a.date.compareTo(b.date));
|
||
|
||
int maxStreak = 1;
|
||
int currentStreak = 1;
|
||
|
||
for (int i = 1; i < records.length; i++) {
|
||
final daysDiff = records[i].date.difference(records[i - 1].date).inDays;
|
||
|
||
if (daysDiff == 1) {
|
||
currentStreak++;
|
||
maxStreak = maxStreak > currentStreak ? maxStreak : currentStreak;
|
||
} else {
|
||
currentStreak = 1;
|
||
}
|
||
}
|
||
|
||
return maxStreak;
|
||
}
|
||
|
||
/// 计算获得的经验值
|
||
int _calculateExpGained(int wordsLearned, int wordsReviewed, double accuracyRate) {
|
||
final baseExp = wordsLearned * 2 + wordsReviewed * 1;
|
||
final accuracyBonus = (accuracyRate * baseExp * 0.5).round();
|
||
return baseExp + accuracyBonus;
|
||
}
|
||
|
||
/// 检查成就条件
|
||
bool _checkAchievementCondition(Achievement achievement, LearningStats stats) {
|
||
switch (achievement.type) {
|
||
case AchievementType.wordsLearned:
|
||
return stats.totalWordsLearned >= achievement.target;
|
||
case AchievementType.streak:
|
||
return stats.currentStreak >= achievement.target;
|
||
case AchievementType.studyDays:
|
||
return stats.totalStudyDays >= achievement.target;
|
||
case AchievementType.booksCompleted:
|
||
return stats.completedBooks >= achievement.target;
|
||
case AchievementType.studyTime:
|
||
return stats.totalStudyTimeMinutes >= achievement.target;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// 生成模拟排行榜数据
|
||
List<LeaderboardEntry> _generateMockLeaderboardEntries(LeaderboardType type) {
|
||
final random = Random();
|
||
final entries = <LeaderboardEntry>[];
|
||
|
||
for (int i = 1; i <= 50; i++) {
|
||
entries.add(LeaderboardEntry(
|
||
rank: i,
|
||
userId: 'user_$i',
|
||
username: '用户$i',
|
||
score: random.nextInt(1000) + 100,
|
||
level: random.nextInt(20) + 1,
|
||
));
|
||
}
|
||
|
||
return entries;
|
||
}
|
||
|
||
/// 获取周开始日期
|
||
DateTime _getWeekStart(DateTime date) {
|
||
final weekday = date.weekday;
|
||
return date.subtract(Duration(days: weekday - 1));
|
||
}
|
||
|
||
/// 格式化日期键
|
||
String _formatDateKey(DateTime date) {
|
||
return '${date.year}-${date.month.toString().padLeft(2, '0')}-${date.day.toString().padLeft(2, '0')}';
|
||
}
|
||
|
||
/// 保存统计数据到本地
|
||
Future<void> _saveStatsToLocal(LearningStats stats) async {
|
||
await _storageService.setString(_statsKey, json.encode(stats.toJson()));
|
||
}
|
||
|
||
/// 保存成就到本地
|
||
Future<void> _saveAchievementsToLocal(List<Achievement> achievements) async {
|
||
final jsonList = achievements.map((achievement) => achievement.toJson()).toList();
|
||
await _storageService.setString(_achievementsKey, json.encode(jsonList));
|
||
}
|
||
} |