import 'package:appwrite/appwrite.dart';
import 'package:baupro/repositories/models/appwrite_exception_model.dart';
import 'package:baupro/repositories/models/appwrite_response_model.dart';
import 'package:get_it/get_it.dart';
import 'package:talker_flutter/talker_flutter.dart';

class AppwriteRepositorySingleton {
  static const String appwriteProjectId = '';
  static const String appwriteProjectName = '';
  static const String appwritePublicEndpoint = '';

  final Client client = Client()
      .setProject(appwriteProjectId)
      .setEndpoint(appwritePublicEndpoint)
      .setLocale('de');

  /// Appwrite account instance
  late final Account account;

  /// Appwrite databases instance
  late final Databases databases;

  /// Appwrite realtime instance
  late final Realtime realtime;

  /// Appwrite teams instance
  late final Teams teams;

  /// Supscription
  late RealtimeSubscription realtimeSubscription;

  AppwriteRepositorySingleton._internal() {
    account = Account(client);
    databases = Databases(client);
    realtime = Realtime(client);
    teams = Teams(client);

    realtimeSubscription = realtime.subscribe(['documents']);
    _listenToRealtimeEvents();
  }

  void renewRealtimeSubscription() {
    try {
      realtimeSubscription.close();
    } catch (e, stack) {
      _talker.warning(
        'Error when closing the old real-time subscription: $e',
        e,
        stack,
      );
    }
  }

  /// Closes the realtime subscription on dispose
  void dispose() {
    realtimeSubscription.close();
    _talker.info('Realtime subscription closed on dispose.');
  }

  static final AppwriteRepositorySingleton _instance =
      AppwriteRepositorySingleton._internal();

  /// Singleton instance getter
  factory AppwriteRepositorySingleton() => _instance;

  /////////////////////////////////////
  // Realtime events
  /////////////////////////////////////
  /// Timeout for reconnecting to Realtime
  int get _reconnectTimeout => 5;

  /// Listens to realtime events and handles errors.
  void _listenToRealtimeEvents() {
    realtimeSubscription.stream.listen(
      (data) {
        _talker.debug('Realtime event: ${data.payload}');
      },
      onError: (error, stackTrace) {
        _talker.error('Realtime error: $error', error, stackTrace);
        Future.delayed(Duration(seconds: _reconnectTimeout), () {
          _talker.info('Attempting to resubscribe to Realtime...');
          realtimeSubscription.close();
          realtimeSubscription = realtime.subscribe(['documents']);
          _listenToRealtimeEvents();
        });
      },
      onDone: () {
        _talker.info(
          'Realtime subscription closed. Attempting to resubscribe...',
        );
        Future.delayed(Duration(seconds: 1), () {
          realtimeSubscription = realtime.subscribe(['documents']);
          _listenToRealtimeEvents();
        });
      },
      cancelOnError: false,
    );
  }

  /////////////////////////////////////
  // Logging section
  /////////////////////////////////////
  /// Get the talker instance
  Talker get _talker => GetIt.instance.get<Talker>();

  /// Handles exceptions and displays an error notification.
  void handleAppwriteException(
    Object e,
    StackTrace? stackTrace, {
    String? messagePrefix,
  }) {
    final prefix = messagePrefix != null ? '$messagePrefix: ' : '';
    if (e is AppwriteException) {
      _talker.error(
        '${prefix}AppwriteException caught in AppwriteRepository: ${e.message} (Code: ${e.code}, Type: ${e.type})',
        e,
        stackTrace,
      );
    } else {
      _talker.error(
        '${prefix}Exception caught in AppwriteRepository',
        e,
        stackTrace,
      );
    }
    // TODO: Füge hier ggf. weitere Fehlerbehandlung hinzu (z.B. Benachrichtigungen)
  }

  /// Wraps an Appwrite request in a try-catch block and logs the result.
  Future<AppwriteResponseModel<T>> safeAppwriteRequest<T>(
    Future<T> Function() requestFunction, {
    String? operationName,
  }) async {
    final opName = operationName ?? 'Appwrite Operation';
    try {
      _talker.info('$opName started.');
      final result = await requestFunction();
      _talker.info('$opName successful.');
      return AppwriteResponseModel(response: result, exception: null);
    } catch (e, stack) {
      handleAppwriteException(e, stack, messagePrefix: '$opName failed');
      return AppwriteResponseModel(
        response: null,
        exception: AppwriteExceptionModel(
          message: e is AppwriteException ? e.message : e.toString(),
          code: e is AppwriteException ? e.code : null,
          type: e is AppwriteException ? e.type : null,
        ),
      );
    }
  }

  /////////////////////////////////////
  // Get Methods
  /////////////////////////////////////
  /// Pings the Appwrite server and captures the response.
  Future<AppwriteResponseModel<bool>> checkConnection() async =>
      await safeAppwriteRequest(() async {
        final response = await client.ping();
        return response.isNotEmpty;
      }, operationName: 'Check Connection');
}