import 'package:social_app/core/api/i_api_client.dart';

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

class MockCalendarService {
  static final MockCalendarService _instance = MockCalendarService._internal();
  factory MockCalendarService() => _instance;

  final List<ScheduleItemModel> _events = [];

  MockCalendarService._internal();

  List<ScheduleItemModel> get events => List.unmodifiable(_events);

  List<ScheduleItemModel> getEventsForDay(DateTime date) {
    final dateOnly = DateTime(date.year, date.month, date.day);
    return _events.where((event) {
      final eventDate = DateTime(
        event.startAt.year,
        event.startAt.month,
        event.startAt.day,
      );
      return eventDate == dateOnly && event.status == ScheduleStatus.active;
    }).toList()..sort((a, b) => a.startAt.compareTo(b.startAt));
  }

  List<ScheduleItemModel> getEventsForRange(DateTime start, DateTime end) {
    return _events.where((event) {
      return event.startAt.isAfter(start.subtract(const Duration(days: 1))) &&
          event.startAt.isBefore(end.add(const Duration(days: 1))) &&
          event.status == ScheduleStatus.active;
    }).toList()..sort((a, b) => a.startAt.compareTo(b.startAt));
  }

  ScheduleItemModel? getEventById(String id) {
    try {
      return _events.firstWhere((e) => e.id == id);
    } catch (_) {
      return null;
    }
  }

  void addEvent(ScheduleItemModel event) {
    _events.add(event);
  }

  void updateEvent(ScheduleItemModel event) {
    final index = _events.indexWhere((e) => e.id == event.id);
    if (index >= 0) {
      _events[index] = event;
    }
  }

  void deleteEvent(String id) {
    _events.removeWhere((e) => e.id == id);
  }
}

class CalendarService {
  final IApiClient? _apiClient;
  final MockCalendarService _mock = MockCalendarService();
  CalendarApi? _calendarApi;

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

  CalendarApi get _api {
    final api = _calendarApi;
    if (api != null) {
      return api;
    }
    final client = _apiClient;
    if (client == null) {
      throw StateError('Real API client not configured');
    }
    final created = CalendarApi(client);
    _calendarApi = created;
    return created;
  }

  Future<List<ScheduleItemModel>> getEventsForDay(DateTime date) async {
    if (_apiClient == null) {
      return _mock.getEventsForDay(date);
    }
    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 {
    if (_apiClient != null) {
      return _api.listByRange(startAt: start, endAt: end);
    }
    return _mock.getEventsForRange(start, end);
  }

  Future<ScheduleItemModel?> getEventById(String id) async {
    if (_apiClient != null) {
      return _api.getById(id);
    }
    return _mock.getEventById(id);
  }

  Future<ScheduleItemModel> addEvent(ScheduleItemModel event) async {
    if (_apiClient != null) {
      return _api.create(event);
    }
    _mock.addEvent(event);
    return event;
  }

  Future<ScheduleItemModel> updateEvent(ScheduleItemModel event) async {
    if (_apiClient != null) {
      return _api.update(event);
    }
    _mock.updateEvent(event);
    return event;
  }

  Future<void> deleteEvent(String id) async {
    if (_apiClient != null) {
      await _api.delete(id);
      return;
    }
    _mock.deleteEvent(id);
  }
}