import 'package:drift_postgres/drift_postgres.dart';
import 'package:injectable/injectable.dart';
import 'package:drift/drift.dart' as drift;
import 'package:mnemo_cards_backend/database/database.dart';
import 'package:mnemo_cards_backend/repository/export.dart';

@lazySingleton
class TaskManager {
  final TaskRepository _taskRepository;
  final AppDatabase _db;

  TaskManager(this._taskRepository, this._db);

  /// Получить все доступные задачи пользователя
  Future<List<UserTask>> getUserTasks(
    String userId, {
    String? type,
    String? difficulty,
    String? status,
    List<String>? tags,
    int? limit,
    int? offset,
  }) async {
    return await _taskRepository.getUserTasks(
      userId,
      status: status,
      activeOnly: status == 'available',
    );
  }

  /// Получить задачу по ID
  Future<UserTask?> getUserTask(String userId, String taskId) async {
    final tasks = await _taskRepository.getUserTasks(userId);
    return tasks.where((task) => task.id == taskId).firstOrNull;
  }

  /// Начать выполнение задачи
  Future<void> startTask(String userId, String taskId) async {
    await _db.transaction(() async {
      // Проверить, что задача доступна
      final task = await getUserTask(userId, taskId);
      if (task == null || task.status != 'available') {
        throw Exception('Task not available');
      }

      // Обновить статус задачи
      await _taskRepository.updateUserTask(
        task.copyWith(status: 'in_progress'),
      );

      // Создать запись прогресса
      await _taskRepository.createTaskProgress(
        UserTaskProgressesCompanion.insert(
          userId: userId,
          taskId: taskId,
          progress: drift.Value({'started': true} as Map<String, dynamic>),
        ),
      );
    });
  }

  /// Завершить задачу
  Future<void> completeTask(String userId, String taskId) async {
    await _db.transaction(() async {
      // Проверить, что задача в процессе выполнения
      final task = await getUserTask(userId, taskId);
      if (task == null || task.status != 'in_progress') {
        throw Exception('Task not in progress');
      }

      // Обновить статус задачи
      final now = PgDateTime(DateTime.now());
      await _taskRepository.updateUserTask(
        task.copyWith(status: 'completed', completedAt: drift.Value(now)),
      );

      // Создать запись результата
      await _taskRepository.createTaskResult(
        UserTaskResultsCompanion.insert(
          userId: userId,
          taskId: taskId,
          results: drift.Value({
            'completed': true,
            'completedAt': now.dateTime.toIso8601String(),
          }),
        ),
      );
    });
  }

  /// Получить прогресс выполнения задач пользователя
  Future<List<UserTaskProgressesData>> getUserTaskProgress(
    String userId,
  ) async {
    final tasks = await _taskRepository.getUserTasks(userId);
    final progresses = <UserTaskProgressesData>[];

    for (final task in tasks) {
      final progress = await _taskRepository.getTaskProgress(userId, task.id);
      if (progress != null) {
        progresses.add(progress);
      }
    }

    return progresses;
  }

  /// Получить категории задач
  Future<List<String>> getTaskCategories() async {
    final tasks = await _taskRepository.getAllUserTasks();
    final categories = <String>{};

    for (final task in tasks) {
      if (task.type.isNotEmpty) {
        categories.add(task.type);
      }
    }

    return categories.toList();
  }

  /// Создать новую задачу для пользователя
  Future<String> createUserTask(UserTasksCompanion task) async {
    return await _taskRepository.createUserTask(task);
  }

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

  /// Подсчитать задачи пользователя
  Future<int> countUserTasks(String userId, {String? status}) async {
    return await _taskRepository.countUserTasks(userId, status: status);
  }
}