Chepuhagram/lib/data/datasources/ws_client.dart

import 'dart:async';
import 'dart:convert';
import 'package:chepuhagram/domain/services/api_service.dart';
import 'package:web_socket_channel/web_socket_channel.dart';
import 'package:web_socket_channel/status.dart' as status;
import 'package:web_socket_channel/io.dart';
import 'package:chepuhagram/core/constants.dart';
import 'package:flutter/widgets.dart';
import 'package:chepuhagram/domain/services/webrtc_service.dart';

class SocketService with WidgetsBindingObserver {
  static final SocketService _instance = SocketService._internal();
  factory SocketService() => _instance;

  SocketService._internal() {
    WidgetsBinding.instance.addObserver(this);
  }

  WebSocketChannel? _channel;
  final StreamController<Map<String, dynamic>> _messageController =
      StreamController<Map<String, dynamic>>.broadcast();

  // Поток, который будут слушать провайдеры
  Stream<Map<String, dynamic>> get messages => _messageController.stream;

  Timer? _connectTimer;

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.resumed) {
      sendSetOnline();
    } else {
      sendSetOffline();
    }
  }

  void _initMessageListener() {
    messages.listen((data) {
      if (data['type'] == 'call_accepted') {
        WebRTCService().handleOffer(data['call_id'], data['sdp']);
      }
    });
  }

  Future<void> startConnect(ApiService apiService) async {
    if (_connectTimer != null && _connectTimer!.isActive)
      return; // Уже запущено
    _connectTimer = Timer.periodic(const Duration(seconds: 15), (_) {
      connect(apiService);
    });
  }

  Future<void> connect(ApiService apiService) async {
    final token = await apiService.getAccessToken();
    if (_channel != null) return; // Уже подключены
    if (token == null || token.isEmpty) {
      throw Exception('Нет токена доступа. Пожалуйста, войдите в систему.');
    }

    // print("✅ Токен получен, устанавливаем WebSocket соединение...");

    startConnect(
      apiService,
    ); // Запускаем таймер на случай, если соединение не установится

    try {
      // В FastAPI эндпоинт ожидает токен в URL-параметре
      final uri = Uri.parse("${AppConstants.wsUrl}/ws?token=$token");

      _channel = IOWebSocketChannel.connect(
        uri,
        connectTimeout: Duration(seconds: 10),
      );
      if (_channel == null) return;
      await _channel!.ready;
      _channel!.stream.listen(
        (data) {
          final decoded = jsonDecode(data);
          print("🚀 СООБЩЕНИЕ ПОЛУЧЕНО ИЗ SINK: $decoded");

          _messageController.add(decoded);
        },
        onError: (error) => _reconnect(apiService),
        onDone: () => _reconnect(apiService),
      );
    } on TimeoutException catch (_) {
      _channel = null;
      throw Exception(
        'Превышено время ожидания. Пожалуйста, попробуйте позже.',
      );
    } catch (e) {
      _channel = null;
      throw Exception('Ошибка при подключении к WebSocket: $e');
    }
  }

  Future<void> _reconnect(ApiService apiService) async {
    _channel = null;
    Future.delayed(const Duration(seconds: 5), () => connect(apiService));
  }

  bool sendMessage(Map<String, dynamic> data, {int retryCnt = 0}) {
    const maxRetries = 5;
    if (_channel == null) {
      if (retryCnt < maxRetries) {
        // Schedule retry with exponential backoff
        Future.delayed(
          Duration(seconds: 1 << retryCnt),
          () => sendMessage(data, retryCnt: retryCnt + 1),
        );
      }
      print("❌ ОШИБКА: WebSocket не подключен. Сообщение не отправлено: $data. Попытка ${retryCnt + 1}/$maxRetries");
      return false;
    }
    try {
      final encodedData = jsonEncode(data);

      // 1. Проверяем, не закрыт ли sink (у некоторых провайдеров это доступно)
      _channel!.sink.add(encodedData);

      // 2. Добавляем принт подтверждения
      print("🚀 СООБЩЕНИЕ ОТПРАВЛЕНО В SINK: $encodedData");
      return true;
    } catch (e) {
      print("❌ КРИТИЧЕСКАЯ ОШИБКА ПРИ ОТПРАВКЕ: $e");
      return false;
    }
  }

  bool sendReadReceipt(int messageId) {
    return sendMessage({'type': 'read_receipt', 'message_id': messageId});
  }

  bool sendReadAllChat(int contactId) {
    return sendMessage({'type': 'read_all_chat', 'contact_id': contactId});
  }

  void sendSetOnline() {
    sendMessage({'type': 'set_online'});
  }

  void sendSetOffline() {
    sendMessage({'type': 'set_offline'});
  }

  bool isConnected() {
    return _channel != null;
  }

  void disconnect() {
    _channel?.sink.close(status.normalClosure);
    _channel = null;
    _connectTimer?.cancel();
    _connectTimer = null;
  }
}