import 'package:dio/dio.dart';
import 'package:eatvio_app/features/chat/repositories/chat_repository.dart';
import 'package:eatvio_app/features/diary/entities/diary_future_diet_day_entity.dart';
import 'package:eatvio_app/features/diary/models/diary_day_model.dart';
import 'package:eatvio_app/features/diary/models/nutrition_model.dart';
import 'package:eatvio_app/features/diary/presentation/bloc/diary_cubit.dart';
import 'package:eatvio_app/features/diary/presentation/bloc/diary_state.dart';
import 'package:eatvio_app/features/diary/repositories/diary_repository.dart';
import 'package:eatvio_app/features/diets/repositories/diet_repository.dart';
import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
import 'package:eatvio_app/features/glossary/models/glossary_model.dart';
import 'package:eatvio_app/features/glossary/repositories/glossary_repository.dart';
import 'package:eatvio_app/features/profile/repositories/profile_repository.dart';
import 'package:eatvio_app/features/settings/models/profile_settings_model.dart';
import 'package:eatvio_app/features/settings/repositories/service_repository.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'diary_cubit_test.mocks.dart';

@GenerateNiceMocks([
  MockSpec<DiaryRepository>(),
  MockSpec<GlossaryRepository>(),
  MockSpec<ProfileRepository>(),
  MockSpec<DietRepository>(),
  MockSpec<ChatRepository>(),
  MockSpec<SettingsRepository>(),
])
void main() {
  group('DiaryCubit', () {
    DiaryCubit? diaryCubit;
    late MockDiaryRepository mockDiaryRepository;
    late MockGlossaryRepository mockGlossaryRepository;
    late MockProfileRepository mockProfileRepository;
    late MockDietRepository mockDietRepository;
    late MockChatRepository mockChatRepository;
    late MockSettingsRepository mockSettingsRepository;

    const testDiaryDay = DiaryDayModel(
      id: 1,
      date: '2024-01-15',
      closed: 0,
      comment: '',
      typeOfDiary: TypeOfDiaryModel(
        hasChosenDiet: false,
        hasChosenPlan: false,
        diaryState: null,
      ),
      meals: [],
      chosenPlanId: null,
      dayOfChosenDiet: null,
      diet: null,
    );

    const testNutrition = NutritionDataModel(
      dailyNutritionIntake: NutritionModel(
        energy: 2000.0,
        proteins: 150.0,
        fats: 80.0,
        carbohydrates: 250.0,
      ),
      dailyNutritionRecommendation: NutritionModel(
        energy: 2200.0,
        proteins: 160.0,
        fats: 90.0,
        carbohydrates: 270.0,
      ),
    );

    setUp(() {
      mockDiaryRepository = MockDiaryRepository();
      mockGlossaryRepository = MockGlossaryRepository();
      mockProfileRepository = MockProfileRepository();
      mockDietRepository = MockDietRepository();
      mockChatRepository = MockChatRepository();
      mockSettingsRepository = MockSettingsRepository();
    });

    tearDown(() async {
      if (diaryCubit != null && !diaryCubit!.isClosed) {
        await Future.delayed(const Duration(milliseconds: 100));
        diaryCubit!.close();
        diaryCubit = null;
      }
    });

    test('начальное состояние - loading', () {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      expect(diaryCubit!.state, const DiaryState.loading());
    });

    test('setSelectedDay - успешно меняет выбранный день', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.createDiaryDay(day: anyNamed('day')))
          .thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      final result = await diaryCubit!.setSelectedDay(DateTime(2024, 1, 15));

      expect(result, true);
      await Future.delayed(const Duration(milliseconds: 100));
      expect(diaryCubit!.state, isA<DiaryStateLoaded>());
    });

    test('fetchDiaryV2 - загружает дневник по ID', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.getDiaryDay(any))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      final result = await diaryCubit!.fetchDiaryV2(needLoading: true, diaryId: 1);

      expect(result, true);
      await Future.delayed(const Duration(milliseconds: 100));
      expect(diaryCubit!.state, isA<DiaryStateLoaded>());
    });

    test('fetchDiaryV2 - обрабатывает ошибку 422 при создании дня', () async {
      when(mockDiaryRepository.createDiaryDay(day: anyNamed('day')))
          .thenThrow(DioException(
            requestOptions: RequestOptions(path: ''),
            response: Response(
              requestOptions: RequestOptions(path: ''),
              statusCode: 422,
            ),
          ));
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      final result = await diaryCubit!.fetchDiaryV2(needLoading: true);

      expect(result, true);
      await Future.delayed(const Duration(milliseconds: 100));
      expect(diaryCubit!.state, isA<DiaryStateLoaded>());
    });

    test('setSelectedMeal - меняет выбранный прием пищи', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.createDiaryDay(day: anyNamed('day')))
          .thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      diaryCubit!.setSelectedMeal(2);

      expect(diaryCubit!.selectedMeal, 2);
      expect(diaryCubit!.state, isA<DiaryStateLoaded>());
    });

    test('setDiaryForDietOnly - устанавливает дневник только для диеты', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      const diet = Diet(
        id: 1,
        slug: 'test-diet',
        name: 'Test Diet',
        image: '',
        duration: 7,
        state: DietState.active,
        type: DietType(),
        details: '',
        dailySchedule: {
          1: {
            1: {
              1: DailySchedule(
                name: 'Яблоко',
                portion: Portion.grams,
                quantity: 1,
              ),
            },
          },
        },
        author: Author(
          authorSlug: 'test',
          authorName: 'Test',
          authorProfileIcon: '',
          authorIsMe: false,
        ),
        totalLikes: 0,
        totalViews: 0,
        totalComments: 0,
        wasLikedByMe: false,
        isFavorite: false,
        dailyNutrition: [],
      );

      when(mockDietRepository.getDiet(1))
          .thenAnswer((_) async => diet);

      final result = await diaryCubit!.setDiaryForDietOnly(
        const DiaryFutureDietDayEntity(
          date: '2024-01-15',
          typeOfDiary: TypeOfDiaryModel(
            hasChosenDiet: true,
            hasChosenPlan: false,
            diaryState: null,
          ),
          meals: [],
          dayOfChosenDiet: 1,
          diet: DiaryDietModel(id: 1, duration: 7, name: 'Test Diet'),
        ),
      );

      expect(result, true);
      expect(diaryCubit!.state, isA<DiaryStateLoadedTomorrowWithDiet>());
    });

    test('setDiaryForDietOnly - возвращает false если нет выбранной диеты', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      final result = await diaryCubit!.setDiaryForDietOnly(
        const DiaryFutureDietDayEntity(
          date: '2024-01-15',
          typeOfDiary: TypeOfDiaryModel(
            hasChosenDiet: false,
            hasChosenPlan: false,
            diaryState: null,
          ),
          meals: [],
          dayOfChosenDiet: null,
          diet: null,
        ),
      );

      expect(result, false);
    });

    test('finishDiaryDay - завершает день дневника', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.finishDiaryDay(
        diaryId: anyNamed('diaryId'),
        wakeUp: anyNamed('wakeUp'),
        retire: anyNamed('retire'),
        comment: anyNamed('comment'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.finishDiaryDay(
        diaryId: 1,
        wakeUp: '07:00',
        retire: '23:00',
      );
      await Future.delayed(const Duration(milliseconds: 100));
    });

    test('addProductToMeal - добавляет продукт в прием пищи', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.addPortionToMeal(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        productName: anyNamed('productName'),
        portion: anyNamed('portion'),
        quantity: anyNamed('quantity'),
        productNutritionalValueId: anyNamed('productNutritionalValueId'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.addProductToMeal(
        diaryId: 1,
        mealId: 1,
        productName: 'Яблоко',
        portion: '100г',
        quantity: 2,
      );
      await Future.delayed(const Duration(milliseconds: 100));
    });

    test('markEaten - отмечает продукт как съеденный', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.markEaten(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        portionId: anyNamed('portionId'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.markEaten(diaryId: 1, mealId: 1, portionId: 5);
      await Future.delayed(const Duration(milliseconds: 100));
    });

    test('getGlossaryListByQuery - получает список глоссариев по запросу', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockGlossaryRepository.getGlossaryListByQuery(any))
          .thenAnswer((_) async => [
                const GlossaryModel(
                  id: 1,
                  name: 'Яблоко',
                  grInPortion: 100,
                  energyOn100Gr: 52.0,
                  proteinsOn100Gr: 0.3,
                  fatsOn100Gr: 0.2,
                  carbohydratesOn100Gr: 14.0,
                  energyOnPortion: 52.0,
                  proteinsOnPortion: 0.3,
                  fatsOnPortion: 0.2,
                  carbohydratesOnPortion: 14.0,
                ),
              ]);

      final result = await diaryCubit!.getGlossaryListByQuery('яблоко');

      expect(result, isA<List<GlossaryModel>>());
      expect(result.length, 1);
      expect(result.first.name, 'Яблоко');
    });

    test('fillSatiety - заполняет сытость', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.fillSatiety(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        satiety: anyNamed('satiety'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.fillSatiety(diaryId: 1, satiety: 5);
      await Future.delayed(const Duration(milliseconds: 100));
    });

    test('fillMood - заполняет настроение', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.fillMood(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        mood: anyNamed('mood'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.fillMood(diaryId: 1, mood: 4);
      await Future.delayed(const Duration(milliseconds: 100));
    });

    test('fillComment - заполняет комментарий', () {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      diaryCubit!.fillComment('Хороший день');
      expect(diaryCubit!.comment, 'Хороший день');
    });

    test('updateCurrentDiary - обновляет текущий дневник', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.updateCurrentDiary();
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day'))).called(1);
    });

    test('updateCurrentDiary - обрабатывает ошибку', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenThrow(Exception('Ошибка'));

      await diaryCubit!.updateCurrentDiary();
      await Future.delayed(const Duration(milliseconds: 100));
    });

    test('getNutrition - получает данные о питании', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);

      final result = await diaryCubit!.getNutrition(1);

      expect(result, testNutrition);
      verify(mockDiaryRepository.getNutritionData(1)).called(1);
    });

    test('updateProductInMeal - обновляет продукт в приеме пищи', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.updateProductInMeal(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        portionId: anyNamed('portionId'),
        productName: anyNamed('productName'),
        portion: anyNamed('portion'),
        quantity: anyNamed('quantity'),
        productNutritionalValueId: anyNamed('productNutritionalValueId'),
        portionState: anyNamed('portionState'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.updateProductInMeal(
        diaryId: 1,
        mealId: 1,
        portionId: 5,
        productName: 'Яблоко',
        portion: '150г',
        quantity: 3,
        portionState: PortionState.eaten,
      );
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.updateProductInMeal(
        diaryId: 1,
        mealId: 1,
        portionId: 5,
        productName: 'Яблоко',
        portion: '150г',
        quantity: 3,
        productNutritionalValueId: anyNamed('productNutritionalValueId'),
        portionState: PortionState.eaten,
      )).called(1);
    });

    test('unmarkEaten - снимает отметку о съеденном', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.unmarkEaten(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        portionId: anyNamed('portionId'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.unmarkEaten(diaryId: 1, mealId: 1, portionId: 5);
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.unmarkEaten(diaryId: 1, mealId: 1, portionId: 5)).called(1);
    });

    test('restore - восстанавливает продукт', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.restore(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        portionId: anyNamed('portionId'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.restore(diaryId: 1, mealId: 1, portionId: 5);
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.restore(diaryId: 1, mealId: 1, portionId: 5)).called(1);
    });

    test('deleteProductFromMeal - удаляет продукт из приема пищи', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.deleteProductFromMeal(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        portionId: anyNamed('portionId'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.deleteProductFromMeal(diaryId: 1, mealId: 1, portionId: 5);
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.deleteProductFromMeal(diaryId: 1, mealId: 1, portionId: 5)).called(1);
    });

    test('sendProductToModeration - отправляет продукт на модерацию', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      const moderationModel = GlossaryModerationModel(
        glossary: GlossaryModel(
          id: 1,
          name: 'Новый продукт',
          grInPortion: 100,
          energyOn100Gr: 100.0,
          proteinsOn100Gr: 10.0,
          fatsOn100Gr: 5.0,
          carbohydratesOn100Gr: 15.0,
          energyOnPortion: 100.0,
          proteinsOnPortion: 10.0,
          fatsOnPortion: 5.0,
          carbohydratesOnPortion: 15.0,
        ),
      );
      when(mockDiaryRepository.sendProductToModeration(
        name: anyNamed('name'),
        energy: anyNamed('energy'),
        proteins: anyNamed('proteins'),
        fats: anyNamed('fats'),
        carbohydrates: anyNamed('carbohydrates'),
      )).thenAnswer((_) async => moderationModel);

      final result = await diaryCubit!.sendProductToModeration(
        name: 'Новый продукт',
        energy: 100.0,
        proteins: 10.0,
        fats: 5.0,
        carbohydrates: 15.0,
      );

      expect(result, moderationModel);
      verify(mockDiaryRepository.sendProductToModeration(
        name: 'Новый продукт',
        energy: 100.0,
        proteins: 10.0,
        fats: 5.0,
        carbohydrates: 15.0,
      )).called(1);
    });

    test('sendProductToModeration - возвращает null при ошибке', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.sendProductToModeration(
        name: anyNamed('name'),
        energy: anyNamed('energy'),
        proteins: anyNamed('proteins'),
        fats: anyNamed('fats'),
        carbohydrates: anyNamed('carbohydrates'),
      )).thenThrow(Exception('Ошибка'));

      final result = await diaryCubit!.sendProductToModeration(
        name: 'Новый продукт',
        energy: 100.0,
        proteins: 10.0,
        fats: 5.0,
        carbohydrates: 15.0,
      );

      expect(result, isNull);
    });

    test('fillTime - заполняет время приема пищи', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.fillTime(
        diaryId: anyNamed('diaryId'),
        mealId: anyNamed('mealId'),
        time: anyNamed('time'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.fillTime(diaryId: 1, time: '12:00');
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.fillTime(diaryId: 1, mealId: 1, time: '12:00')).called(1);
    });

    test('fillWakeup - заполняет время пробуждения', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.fillWakeup(
        diaryId: anyNamed('diaryId'),
        time: anyNamed('time'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.fillWakeup(diaryId: 1, time: '07:00');
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.fillWakeup(diaryId: 1, time: '07:00')).called(1);
    });

    test('fillRetire - заполняет время отхода ко сну', () async {
      diaryCubit = DiaryCubit(
        diaryRepository: mockDiaryRepository,
        glossaryRepository: mockGlossaryRepository,
        profileRepository: mockProfileRepository,
        dietRepository: mockDietRepository,
        chatRepository: mockChatRepository,
        settingsRepository: mockSettingsRepository,
      );
      when(mockDiaryRepository.fillRetire(
        diaryId: anyNamed('diaryId'),
        time: anyNamed('time'),
      )).thenAnswer((_) async => Future.value());
      when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
          .thenAnswer((_) async => testDiaryDay);
      when(mockDiaryRepository.getNutritionData(any))
          .thenAnswer((_) async => testNutrition);
      when(mockSettingsRepository.getProfileSettings())
          .thenAnswer((_) async => const ProfileSettingsModel(
                isMoodFillable: true,
                isBedtimeFillable: true,
                isPublicProfile: true,
                newUpdatesNotifications: null,
                diaryReminderNotifications: null,
              ));

      await diaryCubit!.fetchDiaryV2(needLoading: true);
      await Future.delayed(const Duration(milliseconds: 100));
      await diaryCubit!.fillRetire(diaryId: 1, time: '23:00');
      await Future.delayed(const Duration(milliseconds: 100));
      verify(mockDiaryRepository.fillRetire(diaryId: 1, time: '23:00')).called(1);
    });
  });
}