daily_logs (top-level collection)
  ├── documentId: "userId_date" (e.g., "user123_20231025")
  │   ├── userId: string (reference to user document)
  │   ├── companyId: string (reference to company document)
  │   ├── logDate: timestamp
  │   ├── status: string
  │   ├── isDayOff: boolean
  │   ├── dayOffDetails: map
  │   ├── activities: subcollection
  │   └── clockEvents: subcollection

class DailyLogCache {
  final Map<String, DailyLog> _dailyLogCache = {}; // Key: "userId_date"
  final Map<String, Map<DateTime, DailyLog>> _weeklyLogCache = {}; // Key: "userId_weekStart"
  final Map<String, Map<DateTime, DayLogType>> _statusCache = {}; // Key: "userId_weekStart"
  
  // Cache duration settings
  static const Duration dailyLogCacheDuration = Duration(hours: 1);
  static const Duration weeklyLogCacheDuration = Duration(hours: 6);
  
  // Methods for cache management
  void addToDailyCache(String userId, DateTime date, DailyLog log) {
    final key = _generateDailyKey(userId, date);
    _dailyLogCache[key] = log;
  }
  
  DailyLog? getFromDailyCache(String userId, DateTime date) {
    final key = _generateDailyKey(userId, date);
    return _dailyLogCache[key];
  }
  
  // Similar methods for weekly cache and status cache
  // ...
}

// New method to get daily log with caching
Future<DailyLog> getDailyLogWithCache(String userId, DateTime date) async {
  // Check memory cache first
  final cachedLog = _cache.getFromDailyCache(userId, date);
  if (cachedLog != null) return cachedLog;
  
  // Check local database
  final localLog = await _localDb.getDailyLog(userId, date);
  if (localLog != null) {
    _cache.addToDailyCache(userId, date, localLog);
    return localLog;
  }
  
  // Fetch from Firestore
  final compositeId = DailyLog.generateId(userId, date);
  final doc = await fireStore.collection('daily_logs').doc(compositeId).get();
  
  if (doc.exists) {
    final dailyLog = await _fetchDailyLogWithSubcollections(doc);
    _cache.addToDailyCache(userId, date, dailyLog);
    await _localDb.saveDailyLog(userId, date, dailyLog);
    return dailyLog;
  }
  
  // Return empty log if not found
  return CreateDayLogService.empty(logDate: date);
}

Future<void> getStatusPerDayWithCache({required DateTime monday}) async {
  final userId = authProvider.currentUser?.firebaseUid;
  if (userId == null) return;
  
  final cacheKey = '${userId}_${monday.toIso8601String()}';
  
  // Check cache first
  if (_statusCache.containsKey(cacheKey)) {
    _statusPerDay = _statusCache[cacheKey]!;
    notifyListeners();
    return;
  }
  
  // Proceed with network request if not in cache
  final weekLogs = await fireStore.collection('daily_logs')
      .where('userId', isEqualTo: userId)
      .where('logDate', '>=', Timestamp.fromDate(monday))
      .where('logDate', '<=', Timestamp.fromDate(monday.add(Duration(days: 6))))
      .get();
  
  // Process and cache results
  _statusCache[cacheKey] = _processWeekStatus(weekLogs);
  _statusPerDay = _statusCache[cacheKey]!;
  notifyListeners();
}

Future<void> saveDailyLogWithCache(DailyLog log) async {
  // Save to Firestore
  await _saveToFirestore(log);
  
  // Update cache
  _cache.addToDailyCache(log.userId, log.logDate, log);
  
  // Update local database
  await _localDb.saveDailyLog(log.userId, log.logDate, log);
  
  // Invalidate weekly cache for this week
  final monday = getMondayOfCurrentWeek(log.logDate);
  final cacheKey = '${log.userId}_${monday.toIso8601String()}';
  _statusCache.remove(cacheKey);
  _weeklyLogCache.remove(cacheKey);
}

void clearCache() {
  _dailyLogCache.clear();
  _weeklyLogCache.clear();
  _statusCache.clear();
}

void removeFromCache(String userId, DateTime date) {
  final dailyKey = _generateDailyKey(userId, date);
  _dailyLogCache.remove(dailyKey);
  
  final monday = getMondayOfCurrentWeek(date);
  final weeklyKey = '${userId}_${monday.toIso8601String()}';
  _weeklyLogCache.remove(weeklyKey);
  _statusCache.remove(weeklyKey);
}