import '../../core/exceptions.dart';
import '../api/tasks_api.dart';
import '../local/database.dart';
import '../models/task.dart';

/// Tasks repository with read-through caching for Tier 2 offline support.
/// Mirrors the pattern in NotesRepository — see that file for full notes.
class TasksRepository {
  final TasksApi _api;
  final FabledDatabase _db;

  const TasksRepository(this._api, this._db);

  Future<List<Task>> getAll() async {
    try {
      final tasks = await _api.getAll();
      await _db.replaceAllTasks(tasks);
      return tasks;
    } on NetworkException {
      final cached = await _db.getAllTasks();
      if (cached.isEmpty) rethrow;
      return cached;
    }
  }

  Future<Task> getOne(int id) async {
    try {
      final task = await _api.getOne(id);
      await _db.upsertTask(task);
      return task;
    } on NetworkException {
      final cached = await _db.getTask(id);
      if (cached == null) rethrow;
      return cached;
    }
  }

  Future<List<Task>> getByProject(int projectId) async {
    try {
      final tasks = await _api.getByProject(projectId);
      for (final t in tasks) {
        await _db.upsertTask(t);
      }
      return tasks;
    } on NetworkException {
      return _db.getTasksByProject(projectId);
    }
  }

  Future<List<Task>> getSubTasks(int parentId) async {
    try {
      final tasks = await _api.getSubTasks(parentId);
      for (final t in tasks) {
        await _db.upsertTask(t);
      }
      return tasks;
    } on NetworkException {
      return _db.getSubTasks(parentId);
    }
  }

  Future<Task> create({
    required String title,
    String? description,
    required TaskStatus status,
    required TaskPriority priority,
    DateTime? dueDate,
    int? projectId,
    int? parentId,
  }) async {
    final task = await _api.create(
      title: title,
      description: description,
      status: status,
      priority: priority,
      dueDate: dueDate,
      projectId: projectId,
      parentId: parentId,
    );
    await _db.upsertTask(task);
    return task;
  }

  Future<Task> update(int id, Map<String, dynamic> fields) async {
    final updated = await _api.update(id, fields);
    await _db.upsertTask(updated);
    return updated;
  }

  Future<void> delete(int id) async {
    await _api.delete(id);
    await _db.deleteTask(id);
  }
}