mnemo_cards/mnemo_cards_backend/lib/database/daos/task_dao.dart

import 'package:drift/drift.dart';
import '../database.dart';
// import '../tables/tasks.dart'; // Causes conflict, using database.dart instead
import '../tables/users.dart';

part 'task_dao.g.dart';

@DriftAccessor()
class TaskDao extends DatabaseAccessor<AppDatabase> with _$TaskDaoMixin {
  TaskDao(super.db);
  
  // ==================== Tasks ====================
  
  /// Получить задачу по ID
  Future<Task?> getTaskById(int id) {
    return (select(db.tasks)..where((t) => t.id.equals(id))).getSingleOrNull();
  }
  
  /// Получить все задачи
  Future<List<Task>> getAllTasks() {
    return select(db.tasks).get();
  }
  
  /// Создать задачу
  Future<int> createTask(TasksCompanion task) {
    return into(db.tasks).insert(task);
  }
  
  /// Обновить задачу
  Future<bool> updateTask(Task task) {
    return update(db.tasks).replace(task);
  }
  
  /// Обновить время последнего выполнения
  Future<void> updateLastExecution(int taskId) {
    return (update(db.tasks)..where((t) => t.id.equals(taskId)))
        .write(TasksCompanion(
          lastExecution: Value(DateTime.now()),
          updatedAt: Value(DateTime.now()),
        ));
  }
  
  // ==================== UserTasks ====================
  
  /// Получить задачу пользователя по ID
  Future<UserTask?> getUserTaskById(int id) {
    return (select(db.userTasks)..where((ut) => ut.id.equals(id))).getSingleOrNull();
  }
  
  /// Получить задачи пользователя
  /// Note: UserTasks table doesn't have userId column directly
  /// This method needs to be implemented based on actual schema
  Future<List<UserTask>> getUserTasks(int userId, {
    String? status,
    bool activeOnly = false,
  }) {
    // TODO: Implement based on actual UserTasks schema
    // For now, return all tasks
    final query = select(db.userTasks);
    
    if (status != null) {
      query.where((ut) => ut.status.equals(status));
    }
    
    if (activeOnly) {
      final now = DateTime.now();
      query.where((ut) => ut.expiresAt.isBiggerThanValue(now));
    }
    
    query.orderBy([(ut) => OrderingTerm.desc(ut.createdAt)]);
    
    return query.get();
  }
  
  /// Создать задачу пользователя
  Future<int> createUserTask(UserTasksCompanion task) {
    return into(db.userTasks).insert(task);
  }
  
  /// Обновить задачу пользователя
  Future<bool> updateUserTask(UserTask task) {
    return update(db.userTasks).replace(task);
  }
  
  /// Завершить задачу пользователя
  Future<void> completeUserTask(int taskId) {
    return (update(db.userTasks)..where((ut) => ut.id.equals(taskId)))
        .write(UserTasksCompanion(
          status: const Value('completed'),
          completedAt: Value(DateTime.now()),
          updatedAt: Value(DateTime.now()),
        ));
  }
  
  // ==================== UserTaskProgresses ====================
  
  /// Получить прогресс задачи пользователя
  Future<UserTaskProgresses?> getTaskProgress(int userId, int taskId) {
    return (select(db.userTaskProgresses)
      ..where((utp) => utp.userId.equals(userId) & utp.taskId.equals(taskId))
    ).getSingleOrNull();
  }
  
  /// Создать прогресс задачи
  Future<int> createTaskProgress(UserTaskProgressesCompanion progress) {
    return into(db.userTaskProgresses).insert(progress);
  }
  
  /// Обновить прогресс задачи
  Future<bool> updateTaskProgress(UserTaskProgresses progress) {
    return update(db.userTaskProgresses).replace(progress);
  }
  
  // ==================== UserTaskResults ====================
  
  /// Получить результаты задач пользователя
  Future<List<UserTaskResult>> getTaskResults(int userId) {
    return (select(db.userTaskResults)
      ..where((utr) => utr.userId.equals(userId))
      ..orderBy([(utr) => OrderingTerm.desc(utr.completedAt)])
    ).get();
  }
  
  /// Создать результат задачи
  Future<int> createTaskResult(UserTaskResultsCompanion result) {
    return into(db.userTaskResults).insert(result);
  }
}