trainhub-flutter/lib/data/repositories/program_repository_impl.dart

import 'package:drift/drift.dart';
import 'package:trainhub_flutter/core/utils/id_generator.dart';
import 'package:trainhub_flutter/data/database/app_database.dart';
import 'package:trainhub_flutter/data/database/daos/program_dao.dart';
import 'package:trainhub_flutter/data/mappers/program_mapper.dart';
import 'package:trainhub_flutter/domain/entities/program.dart';
import 'package:trainhub_flutter/domain/entities/program_week.dart';
import 'package:trainhub_flutter/domain/entities/program_workout.dart';
import 'package:trainhub_flutter/domain/repositories/program_repository.dart';

class ProgramRepositoryImpl implements ProgramRepository {
  final ProgramDao _dao;

  ProgramRepositoryImpl(this._dao);

  @override
  Future<List<ProgramEntity>> getAllPrograms() async {
    final rows = await _dao.getAllPrograms();
    return rows.map(ProgramMapper.toEntity).toList();
  }

  @override
  Future<ProgramEntity?> getProgram(String id) async {
    final row = await _dao.getProgram(id);
    return row == null ? null : ProgramMapper.toEntity(row);
  }

  @override
  Future<List<ProgramWeekEntity>> getWeeks(String programId) async {
    final rows = await _dao.getWeeks(programId);
    return rows.map(ProgramMapper.weekToEntity).toList();
  }

  @override
  Future<List<ProgramWorkoutEntity>> getWorkouts(String programId) async {
    final rows = await _dao.getWorkouts(programId);
    return rows.map(ProgramMapper.workoutToEntity).toList();
  }

  @override
  Future<ProgramEntity> createProgram(String name) async {
    final String id = IdGenerator.generate();
    await _dao.insertProgram(
      ProgramsCompanion.insert(
        id: id,
        name: name,
        createdAt: DateTime.now().toIso8601String(),
      ),
    );
    final row = await _dao.getProgram(id);
    return ProgramMapper.toEntity(row!);
  }

  @override
  Future<void> deleteProgram(String id) async {
    await _dao.deleteProgram(id);
  }

  @override
  Future<void> duplicateProgram(String sourceId) async {
    final sourceProgram = await _dao.getProgram(sourceId);
    if (sourceProgram == null) return;
    final String newId = IdGenerator.generate();
    await _dao.insertProgram(
      ProgramsCompanion.insert(
        id: newId,
        name: '${sourceProgram.name} (Copy)',
        createdAt: DateTime.now().toIso8601String(),
      ),
    );
    final weeks = await _dao.getWeeks(sourceId);
    final workouts = await _dao.getWorkouts(sourceId);
    for (final week in weeks) {
      final String newWeekId = IdGenerator.generate();
      await _dao.insertWeek(
        ProgramWeeksCompanion.insert(
          id: newWeekId,
          programId: newId,
          position: week.position,
          notes: Value(week.notes),
        ),
      );
      final weekWorkouts = workouts.where((w) => w.weekId == week.id);
      for (final workout in weekWorkouts) {
        await _dao.insertWorkout(
          ProgramWorkoutsCompanion.insert(
            id: IdGenerator.generate(),
            weekId: newWeekId,
            programId: newId,
            day: workout.day,
            type: workout.type,
            refId: Value(workout.refId),
            name: Value(workout.name),
            description: Value(workout.description),
            completed: const Value(false),
          ),
        );
      }
    }
  }

  @override
  Future<ProgramWeekEntity> addWeek(String programId, int position) async {
    final String id = IdGenerator.generate();
    await _dao.insertWeek(
      ProgramWeeksCompanion.insert(
        id: id,
        programId: programId,
        position: position,
      ),
    );
    final weeks = await _dao.getWeeks(programId);
    final week = weeks.firstWhere((w) => w.id == id);
    return ProgramMapper.weekToEntity(week);
  }

  @override
  Future<void> deleteWeek(String id) async {
    await _dao.deleteWeek(id);
  }

  @override
  Future<void> updateWeekNote(String weekId, String note) async {
    await _dao.updateWeekNote(weekId, note);
  }

  @override
  Future<ProgramWorkoutEntity> addWorkout(
      ProgramWorkoutEntity workout) async {
    await _dao.insertWorkout(ProgramMapper.workoutToCompanion(workout));
    return workout;
  }

  @override
  Future<void> updateWorkout(ProgramWorkoutEntity workout) async {
    await _dao.updateWorkout(
      workout.id,
      ProgramMapper.workoutToUpdateCompanion(workout),
    );
  }

  @override
  Future<void> deleteWorkout(String id) async {
    await _dao.deleteWorkout(id);
  }

  @override
  Future<void> toggleWorkoutComplete(String id, bool currentStatus) async {
    await _dao.toggleWorkoutComplete(id, currentStatus);
  }
}