// lib/model/activity/activity_grouping.dart
import 'package:aves/model/activity/activity_entry.dart';

class ActivitySportGroup {
  final String displayName;
  final String? sportFilter;
  final bool withoutSport;
  final int count;
  final ActivityEntry? coverEntry;

  const ActivitySportGroup({
    required this.displayName,
    required this.sportFilter,
    required this.withoutSport,
    required this.count,
    required this.coverEntry,
  });
}

class ActivityAlbumGroup {
  final String displayName;
  final String? directoryFilter;
  final int count;
  final ActivityEntry? coverEntry;

  const ActivityAlbumGroup({
    required this.displayName,
    required this.directoryFilter,
    required this.count,
    required this.coverEntry,
  });
}

class ActivityGrouping {
  const ActivityGrouping._();

  static List<ActivitySportGroup> buildSportGroups(
    Iterable<ActivityEntry> activities,
  ) {
    final grouped = <String, List<ActivityEntry>>{};

    for (final entry in activities) {
      final rawSport = entry.sport?.trim();
      final key = rawSport == null || rawSport.isEmpty ? '' : rawSport;

      grouped.putIfAbsent(key, () => []).add(entry);
    }

    final groups =
        grouped.entries.map((entry) {
          final sortedEntries = [...entry.value]
            ..sort((a, b) {
              final aDate = a.startTimeMillis ?? a.dateModifiedMillis;
              final bDate = b.startTimeMillis ?? b.dateModifiedMillis;
              return bDate.compareTo(aDate);
            });

          final isWithoutSport = entry.key.isEmpty;

          return ActivitySportGroup(
            displayName: isWithoutSport ? 'Senza sport' : entry.key,
            sportFilter: isWithoutSport ? null : entry.key,
            withoutSport: isWithoutSport,
            count: sortedEntries.length,
            coverEntry: sortedEntries.isEmpty ? null : sortedEntries.first,
          );
        }).toList()..sort(
          (a, b) => a.displayName.toLowerCase().compareTo(
            b.displayName.toLowerCase(),
          ),
        );

    return groups;
  }

  static List<ActivityAlbumGroup> buildAlbumGroups(
    Iterable<ActivityEntry> activities,
  ) {
    final grouped = <String, List<ActivityEntry>>{};

    for (final entry in activities) {
      final rawDirectory = entry.directoryName?.trim();
      final rawRelativePath = entry.relativePath?.trim();

      final key = rawDirectory != null && rawDirectory.isNotEmpty
          ? rawDirectory
          : rawRelativePath != null && rawRelativePath.isNotEmpty
          ? rawRelativePath
          : 'Activity';

      grouped.putIfAbsent(key, () => []).add(entry);
    }

    final groups =
        grouped.entries.map((entry) {
          final sortedEntries = [...entry.value]
            ..sort((a, b) {
              final aDate = a.startTimeMillis ?? a.dateModifiedMillis;
              final bDate = b.startTimeMillis ?? b.dateModifiedMillis;
              return bDate.compareTo(aDate);
            });

          return ActivityAlbumGroup(
            displayName: entry.key,
            directoryFilter: entry.key,
            count: sortedEntries.length,
            coverEntry: sortedEntries.isEmpty ? null : sortedEntries.first,
          );
        }).toList()..sort(
          (a, b) => a.displayName.toLowerCase().compareTo(
            b.displayName.toLowerCase(),
          ),
        );

    return groups;
  }
}