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

import 'package:drift/drift.dart';
import 'package:drift_postgres/drift_postgres.dart';
import '../database.dart';

part 'task_dao.g.dart';

@DriftAccessor()
class TaskDao extends DatabaseAccessor<AppDatabase> with _$TaskDaoMixin {
  TaskDao(super.db);

  // ==================== Tasks ====================

  /// Получить задачу по ID
  Future<Task?> getTaskById(String id) {
    return (select(db.tasks)..where((t) => t.id.equals(id))).getSingleOrNull();
  }

  /// Получить все задачи
  Future<List<Task>> getAllTasks() {
    return select(db.tasks).get();
  }

  /// Создать задачу
  Future<String> createTask(TasksCompanion task) async {
    final inserted = await into(db.tasks).insertReturning(task);
    return inserted.id;
  }

  /// Обновить задачу
  Future<bool> updateTask(Task task) {
    return update(db.tasks).replace(task);
  }

  /// Обновить время последнего выполнения
  Future<void> updateLastExecution(String taskId) {
    final now = PgDateTime(DateTime.now());
    return (update(db.tasks)..where((t) => t.id.equals(taskId))).write(
      TasksCompanion(lastExecution: Value(now), updatedAt: Value(now)),
    );
  }

  // ==================== UserTasks ====================

  /// Получить задачу пользователя по ID
  Future<UserTask?> getUserTaskById(String id) {
    return (select(
      db.userTasks,
    )..where((ut) => ut.id.equals(id))).getSingleOrNull();
  }

  /// Получить все задачи пользователей (для системных задач)
  Future<List<UserTask>> getAllUserTasks() {
    return select(db.userTasks).get();
  }

  /// Получить задачи пользователя
  Future<List<UserTask>> getUserTasks(
    String userId, {
    String? status,
    bool activeOnly = false,
  }) {
    final query = select(db.userTasks);

    // Note: UserTasks table doesn't have userId column, so we can't filter by userId
    // This method may need to be refactored if userId filtering is required

    if (status != null) {
      query.where((ut) => ut.status.equals(status));
    }

    if (activeOnly) {
      final now = PgDateTime(DateTime.now());
      query.where((ut) => ut.expiresAt.isBiggerThanValue(now));
    }

    query.orderBy([(ut) => OrderingTerm.desc(ut.createdAt)]);

    return query.get();
  }

  /// Создать задачу пользователя
  Future<String> createUserTask(UserTasksCompanion task) async {
    final inserted = await into(db.userTasks).insertReturning(task);
    return inserted.id;
  }

  /// Создать задачу пользователя или игнорировать, если уже существует
  /// Возвращает true, если задача была создана, false если уже существовала
  ///
  /// Если task.id.present == true, проверяет существование перед вставкой
  Future<bool> createUserTaskOrIgnore(UserTasksCompanion task) async {
    // Если ID указан, проверяем существование перед вставкой
    if (task.id.present) {
      final existing = await getUserTaskById(task.id.value);
      if (existing != null) {
        return false; // Задача уже существует
      }
    }

    try {
      await into(db.userTasks).insert(task, mode: InsertMode.insertOrIgnore);
      return true; // Задача была создана
    } catch (e) {
      // PostgreSQL error code 23505 = unique_violation (duplicate key)
      // Это может произойти в редких случаях race condition
      final errorString = e.toString();
      if (errorString.contains('23505') ||
          errorString.contains('duplicate key') ||
          errorString.contains('unique constraint')) {
        return false; // Задача уже существует
      }
      // Пробрасываем другие ошибки
      rethrow;
    }
  }

  /// Обновить задачу пользователя
  Future<bool> updateUserTask(UserTask task) {
    return update(db.userTasks).replace(task);
  }

  /// Завершить задачу пользователя
  Future<void> completeUserTask(String taskId) {
    final now = PgDateTime(DateTime.now());
    return (update(db.userTasks)..where((ut) => ut.id.equals(taskId))).write(
      UserTasksCompanion(
        status: const Value('completed'),
        completedAt: Value(now),
        updatedAt: Value(now),
      ),
    );
  }

  /// Подсчитать задачи пользователя
  Future<int> countUserTasks(String userId, {String? status}) async {
    final countExpr = db.userTasks.id.count();
    final query = selectOnly(db.userTasks)..addColumns([countExpr]);

    if (status != null) {
      query.where(db.userTasks.status.equals(status));
    }

    return await query.map((row) => row.read(countExpr)!).getSingle();
  }

  /// Удалить задачу пользователя
  Future<bool> deleteUserTask(String taskId) async {
    final deleted = await (delete(
      db.userTasks,
    )..where((ut) => ut.id.equals(taskId))).go();
    return deleted > 0;
  }

  // ==================== UserTaskProgresses ====================

  /// Получить прогресс задачи пользователя
  Future<UserTaskProgressesData?> getTaskProgress(
    String userId,
    String taskId,
  ) {
    return (select(db.userTaskProgresses)..where(
          (utp) => utp.userId.equals(userId) & utp.taskId.equals(taskId),
        ))
        .getSingleOrNull();
  }

  /// Создать прогресс задачи
  Future<String> createTaskProgress(
    UserTaskProgressesCompanion progress,
  ) async {
    final inserted = await into(
      db.userTaskProgresses,
    ).insertReturning(progress);
    return inserted.id;
  }

  /// Обновить прогресс задачи
  Future<bool> updateTaskProgress(UserTaskProgressesData progress) {
    return update(db.userTaskProgresses).replace(progress);
  }

  // ==================== UserTaskResults ====================

  /// Получить результаты задач пользователя
  Future<List<UserTaskResult>> getTaskResults(String userId) {
    return (select(db.userTaskResults)
          ..where((utr) => utr.userId.equals(userId))
          ..orderBy([(utr) => OrderingTerm.desc(utr.completedAt)]))
        .get();
  }

  /// Создать результат задачи
  Future<String> createTaskResult(UserTaskResultsCompanion result) async {
    final inserted = await into(db.userTaskResults).insertReturning(result);
    return inserted.id;
  }
}