import 'dart:async';
import 'dart:developer';

import 'package:dio/dio.dart';
import 'package:eatvio_app/core/locator_service.dart';
import 'package:eatvio_app/core/utils/date_time_utils.dart';
import 'package:eatvio_app/features/chat/services/chat_service.dart';
import 'package:eatvio_app/features/create_recipe/models/recipe_model.dart';
import 'package:eatvio_app/features/create_recipe/models/step.dart';
import 'package:eatvio_app/features/create_recipe/reporitories/recipe_repository.dart';
import 'package:eatvio_app/features/diets/services/diet_service.dart';
import 'package:eatvio_app/features/feed/services/feed_service.dart';
import 'package:eatvio_app/features/profile/services/profile_service.dart';
import 'package:eatvio_app/features/create_recipe/services/recipe_service.dart';

sealed class TestCases {
  String get name => throw UnimplementedError();

  Future<bool> run({required String baseUrl}) async => throw UnimplementedError();
}

class CreateRecipeTask implements TestCases {
  @override
  String get name => 'api/recipes/create';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final recipeRepository = RecipeRepository(recipeService: CreateRecipeService(dio, baseUrl: baseUrl));
      await recipeRepository.publishRecipe(
        const RecipeModel(
          title: 'Title',
          state: 'active',
          activeCookTime: 10,
          image: null,
          description: 'desc',
          type: 'first_meals',
          servings: 10,
          energyPerServing: 10,
          steps: [Step(description: 'desc')],
        ),
      );
    } catch (e) {
      return false;
    }
    return true;
  }
}

class Test850task implements TestCases {
  @override
  String get name => 'task #850';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      // get all of needed services
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final profileService = ProfileService(dio, baseUrl: baseUrl);
      final dietsService = DietService(dio, baseUrl: baseUrl);

      // get all of needed data
      final dietsPaginationModel = await feedService.getDiets(page: 1);
      final chosenDietsPaginationModel = await profileService.getChosenDiets();
      final lastChosenDiet = chosenDietsPaginationModel.diets.firstOrNull;
      final today = DateTime.now();
      final yesterday = today.subtract(const Duration(days: 1));
      final tomorrow = today.add(const Duration(days: 1));

      // run test case
      for (final diet in dietsPaginationModel.data) {
        if (!diet.author.authorIsMe) {
          if (lastChosenDiet?.state == 'started' || lastChosenDiet?.state == 'inited') {
            try {
              await dietsService.cancelDiet(id: lastChosenDiet?.dietId ?? 0);
            } catch (e) {
              log('unexpected error7: $e');
              return false;
            }
            await Future.delayed(const Duration(seconds: 3));
          }
          try {
            await dietsService.startDiet(id: diet.id, body: {'date': yesterday.format('yyyy-MM-dd')});

            return false;
          } catch (e) {
            log('expect ot have error: $e');
          }

          // test start diet with correct date
          try {
            await dietsService.startDiet(id: diet.id, body: {'date': today.format('yyyy-MM-dd')});
          } catch (e) {
            log('unexpected error2: $e');
            return false;
          }

          // test cancelation of diet
          try {
            await dietsService.cancelDiet(id: diet.id);
          } catch (e) {
            log('unexpected error3: $e');
            return false;
          }

          await Future.delayed(const Duration(seconds: 3));

          // test start diet with correct date
          try {
            await dietsService.startDiet(id: diet.id, body: {'date': tomorrow.format('yyyy-MM-dd')});
          } catch (e) {
            log('unexpected error4: $e');
            return false;
          }

          // test cancelation of diet
          try {
            await dietsService.cancelDiet(id: diet.id);
          } catch (e) {
            log('unexpected error5: $e');
          }
          break;
        }
      }

      return true;
    } catch (e) {
      log('unexpected error6: $e');
      return false;
    }
  }
}

// ChatService
class GetChatRoomPreviews implements TestCases {
  @override
  String get name => '/api/chat/index';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      // get all of needed services
      // final dio = sl<Dio>();
      // final chatService = ChatService(dio, baseUrl: baseUrl);

      // await chatService.getChatRooms();
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetChatRoom implements TestCases {
  @override
  String get name => '/api/chat/show/{id}';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      // final dio = sl<Dio>();
      // final chatService = ChatService(dio, baseUrl: baseUrl);

      // final chatRoomsModels = await chatService.getChatRoomPreviews();
      // await chatService.getChatRoom(id: chatRoomsModels.chatRooms.firstOrNull?.id ?? '');
      return true;
    } catch (e) {
      return false;
    }
  }
}

class SendMessage implements TestCases {
  @override
  String get name => '/api/chat/{id}/message/send';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      // final dio = sl<Dio>();
      // final chatService = ChatService(dio, baseUrl: baseUrl);

      // final chatRoomsModels = await chatService.getChatRoomPreviews();
      // await chatService.sendMessage(id: chatRoomsModels.chatRooms.firstOrNull?.id ?? '', data: 'test message');
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetChatMessages implements TestCases {
  @override
  String get name => '/api/chat/show/{id}/messages?page={page}';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      // final dio = sl<Dio>();
      // final chatService = ChatService(dio, baseUrl: baseUrl);

      // final chatRoomsModels = await chatService.getChatRoomPreviews();
      // await chatService.getChatMessages(id: chatRoomsModels.chatRooms.firstOrNull?.id ?? '', page: 1);
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetChatRoomIdByUserSlug implements TestCases {
  @override
  String get name => '/api/chat/get_by_user/{user}';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final chatService = ChatService(dio, baseUrl: baseUrl);
      final consultantService = FeedService(dio, baseUrl: baseUrl);
      final profileService = ProfileService(dio, baseUrl: baseUrl);
      final myProfile = await profileService.getMyProfile();
      final consultantsModel = await consultantService.getConsultants();

      for (var consultant in consultantsModel.data) {
        if (consultant.slug != myProfile.slug) {
          await chatService.getChatRoomIdByUserSlug(user: consultant.slug);
          break;
        }
      }
      return true;
    } catch (e) {
      return false;
    }
  }
}

// FeedService
class GetBlogPostList implements TestCases {
  @override
  String get name => '/api/blogPosts/index';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      await feedService.getBlogPostList(page: 1);
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetRecipes implements TestCases {
  @override
  String get name => '/api/recipes/index';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final recipeService = CreateRecipeService(dio, baseUrl: baseUrl);
      final tagsModel = await recipeService.getTags();
      final tags = tagsModel.data;
      final tagsIds = tags.map((e) => e.id).toList();
      await feedService.getRecipes(page: 1, tags: tagsIds, query: null);
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetDiets implements TestCases {
  @override
  String get name => '/api/diets/index';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      await feedService.getDiets(page: 1, query: null);
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetPlans implements TestCases {
  @override
  String get name => '/api/plans/index';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      await feedService.getPlans(page: 1, query: null);
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetBlogPostComments implements TestCases {
  @override
  String get name => '/api/blogPosts/{id}/comments/show';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final blogPostsModel = await feedService.getBlogPostList(page: 1, query: null);
      final blogPosts = blogPostsModel.feedBlogPostList;
      await feedService.getBlogPostComments(id: blogPosts.first.id.toString());
      return true;
    } catch (e) {
      return false;
    }
  }
}

class SendBlogPostComment implements TestCases {
  @override
  String get name => '/api/blogPosts/{id}/comment/create';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final blogPostsModel = await feedService.getBlogPostList(page: 1, query: null);
      final blogPosts = blogPostsModel.feedBlogPostList;
      await feedService.sendBlogPostComment(id: blogPosts.first.id.toString(), body: 'auto test message');
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetDietsComments implements TestCases {
  @override
  String get name => '/api/diets/{id}/comments/show';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final dietsModel = await feedService.getDiets(page: 1, query: null);
      final diets = dietsModel.data;
      await feedService.getDietsComments(id: diets.first.id.toString());
      return true;
    } catch (e) {
      return false;
    }
  }
}

class SendDietsComment implements TestCases {
  @override
  String get name => '/api/diets/{id}/comment/create';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final dietsModel = await feedService.getDiets(page: 1, query: null);
      final diets = dietsModel.data;
      await feedService.sendDietsComment(id: diets.first.id.toString(), body: 'auto test message');
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetPlansComments implements TestCases {
  @override
  String get name => '/api/plans/{slug}/comments/show';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final plansModel = await feedService.getPlans(page: 1, query: null);
      final plans = plansModel.data;
      await feedService.getPlansComments(slug: plans.first.slug);
      return true;
    } catch (e) {
      return false;
    }
  }
}

class SendPlansComment implements TestCases {
  @override
  String get name => '/api/plans/{slug}/comment/create';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final plansModel = await feedService.getPlans(page: 1, query: null);
      final plans = plansModel.data;
      await feedService.sendPlansComment(slug: plans.first.slug, body: 'auto test message');
      return true;
    } catch (e) {
      return false;
    }
  }
}

class GetRecipesComments implements TestCases {
  @override
  String get name => '/api/recipes/{id}/comments/show';

  @override
  Future<bool> run({required String baseUrl}) async {
    try {
      final dio = sl<Dio>();
      final feedService = FeedService(dio, baseUrl: baseUrl);
      final recipeService = CreateRecipeService(dio, baseUrl: baseUrl);
      final tagsModel = await recipeService.getTags();
      final tags = tagsModel.data;
      final tagsIds = tags.map((e) => e.id).toList();
      final recipesModel = await feedService.getRecipes(page: 1, tags: tagsIds, query: null);
      final recipes = recipesModel.recipesList;
      await feedService.getRecipesComments(id: recipes.first.id.toString());
      return true;
    } catch (e) {
      return false;
    }
  }
}