import 'package:social_app/core/api/i_api_client.dart';
import 'package:social_app/core/cache/cache_invalidator.dart';
import 'package:social_app/core/di/injection.dart';

import '../calendar_api.dart';
import '../models/schedule_item_model.dart';

class CalendarService {
  final IApiClient _apiClient;
  CalendarApi? _calendarApi;

  CalendarService({required IApiClient apiClient}) : _apiClient = apiClient;

  CalendarApi get _api {
    final api = _calendarApi;
    if (api != null) {
      return api;
    }
    final created = CalendarApi(_apiClient);
    _calendarApi = created;
    return created;
  }

  Future<List<ScheduleItemModel>> getEventsForDay(DateTime date) async {
    final start = DateTime(date.year, date.month, date.day);
    final end = DateTime(date.year, date.month, date.day, 23, 59, 59);
    return getEventsForRange(start, end);
  }

  Future<List<ScheduleItemModel>> getEventsForRange(
    DateTime start,
    DateTime end,
  ) async {
    return _api.listByRange(startAt: start, endAt: end);
  }

  Future<ScheduleItemModel?> getEventById(String id) async {
    return _api.getById(id);
  }

  Future<ScheduleItemModel> addEvent(ScheduleItemModel event) async {
    final created = await _api.create(event);
    _invalidateEventCache(created);
    return created;
  }

  Future<ScheduleItemModel> updateEvent(ScheduleItemModel event) async {
    final updated = await _api.update(event);
    _invalidateEventCache(updated);
    return updated;
  }

  Future<ScheduleItemModel?> archiveEvent(String id) async {
    final event = await getEventById(id);
    if (event == null) {
      return null;
    }
    final updatedEvent = await updateEvent(
      event.copyWith(status: ScheduleStatus.archived),
    );
    _invalidateEventCache(updatedEvent);
    return updatedEvent;
  }

  void _invalidateEventCache(ScheduleItemModel event) {
    try {
      final invalidator = sl<CacheInvalidator>();
      var current = DateTime(
        event.startAt.year,
        event.startAt.month,
        event.startAt.day,
      );
      final end = DateTime(
        event.endAt?.year ?? event.startAt.year,
        event.endAt?.month ?? event.startAt.month,
        event.endAt?.day ?? event.startAt.day,
      );
      while (!current.isAfter(end)) {
        invalidator.invalidateCalendarDay(current);
        current = current.add(const Duration(days: 1));
      }
    } catch (_) {}
  }

  Future<void> deleteEvent(String id) async {
    final event = await getEventById(id);
    if (event != null) {
      _invalidateEventCache(event);
    }
    await _api.delete(id);
  }
}