eatvio_app/lib/features/chat/repositories/chat_repository.dart

import 'dart:async';
import 'dart:developer';
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:eatvio_app/core/token_storage.dart';
import 'package:eatvio_app/features/chat/models/chat_message_model.dart';
import 'package:eatvio_app/features/chat/models/chat_messages_model.dart';
import 'package:eatvio_app/features/chat/models/chat_room_model.dart';
import 'package:eatvio_app/features/chat/models/chat_room_pagination_model.dart';
import 'package:eatvio_app/features/chat/models/payment_model.dart';
import 'package:eatvio_app/features/chat/models/plan_complain_model.dart';
import 'package:eatvio_app/features/chat/services/chat_service.dart';
import 'package:eatvio_app/features/plans/models/chosen_plan_model.dart';
import 'package:http_parser/http_parser.dart';
import 'package:sentry_flutter/sentry_flutter.dart';

class ChatRepository {
  final ChatService chatService;

  final _newUserMessagesController = StreamController<ChatMessageModel>();

  Stream<ChatMessageModel> get newUserMessagesStream => _newUserMessagesController.stream;

  ChatRepository({
    required this.chatService,
  });

  void emitNewMessageToChats(ChatMessageModel message) {
    _newUserMessagesController.add(message);
  }

  Future<ChatMessageModel> sendMessage({
    required String slug,
    String? data,
    List<File>? files,
  }) async {
    try {
      final multipartFiles = <MultipartFile>[];

      if (files != null) {
        for (final file in files) {
          final fileBytes = await file.readAsBytes();
          final multipartFile = MultipartFile.fromBytes(
            fileBytes,
            filename: file.path.split('/').last,
            contentType: MediaType('application', 'octet-stream'),
          );
          multipartFiles.add(multipartFile);
        }
      }

      // Если data пустая строка или null, не передаем её вообще
      // Сервер требует либо непустую строку, либо отсутствие поля
      final dataToSend = (data == null || data.trim().isEmpty) ? null : data;

      return await chatService.sendMessage(
        slug: slug,
        data: dataToSend,
        mediaData: multipartFiles.isEmpty ? null : multipartFiles,
        socketId: (await SocketIdStorage.getSocketIdFromStorage())!,
      );
    } catch (e, st) {
      log(e.toString(), stackTrace: st);
      await Sentry.captureException(e, stackTrace: st);
      rethrow;
    }
  }

  Future<ChatRoomModel> getChatRoom(String uuid) async {
    try {
      return (await chatService.getChatRoom(uuid: uuid));
    } catch (e, st) {
      log(e.toString(), stackTrace: st);
      await Sentry.captureException(e, stackTrace: st);
      rethrow;
    }
  }

  Future<ChatRoomPaginationModel> getChatRooms({String? query, int page = 1}) async {
    try {
      return (await chatService.getChatRooms(query: query, page: page));
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<ChatMessagesModel> getChatMessages(String id, int page) async {
    try {
      return (await chatService.getChatMessages(id: id, page: page));
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<ChatRoomModel> getChatRoomIdByUserSlug({required String slug}) async {
    try {
      return (await chatService.getChatRoomIdByUserSlug(user: slug));
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<void> markMessagesAsRead(String id, List<int> messageIds) async {
    try {
      await chatService.markMessagesAsRead(id: id, body: {'messages_ids': messageIds});
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<void> cancelChosenPlan({
    required int id,
  }) async {
    try {
      await chatService.cancelChosenPlan(id: id);
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<void> choseStartPlanDate({required int id, required Map<String, String> date}) async {
    try {
      await chatService.choseStartPlanDate(id: id, date: date);
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<PaymentModel> getPaymentLink({
    required int id,
  }) async {
    try {
      return await chatService.getPaymentLink(id: id);
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<ChosenPlanModel> getChosenPlan({
    required int id,
  }) async {
    try {
      return await chatService.getChosenPlan(id: id);
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<void> finishChosenPlan({
    required int id,
  }) async {
    try {
      await chatService.finishChosenPlan(id: id);
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<void> complainAboutConsultation({
    required int id,
    required PlanComplainModel body,
  }) async {
    try {
      await chatService.complainAboutConsultation(id: id, body: body);
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      rethrow;
    }
  }

  Future<String> getChatByUserSlug(String slug) async {
    try {
      final response = await chatService.getChatByUserSlug(slug: slug);
      if (response.response.statusCode == 404) {
        return '404';
      } else {
        return response.data['id'];
      }
    } catch (e, s) {
      await Sentry.captureException(e, stackTrace: s);
      return 'error';
    }
  }
}