package com.magamochi.service;

import com.magamochi.catalog.model.entity.Manga;
import com.magamochi.catalog.model.entity.MangaContentProvider;
import com.magamochi.catalog.model.repository.MangaContentProviderRepository;
import com.magamochi.catalog.model.repository.MangaRepository;
import com.magamochi.client.NtfyClient;
import com.magamochi.common.exception.NotFoundException;
import com.magamochi.content.model.entity.MangaContent;
import com.magamochi.content.model.repository.MangaContentRepository;
import com.magamochi.ingestion.providers.ContentProviderFactory;
import com.magamochi.model.dto.*;
import com.magamochi.model.entity.UserMangaFollow;
import com.magamochi.model.repository.*;
import com.magamochi.queue.MangaChapterDownloadProducer;
import com.magamochi.user.service.UserService;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Log4j2
@Service
@RequiredArgsConstructor
public class OldMangaService {
  private final UserService userService;
  private final MangaRepository mangaRepository;
  private final MangaContentProviderRepository mangaContentProviderRepository;

  private final ContentProviderFactory contentProviderFactory;

  private final UserMangaFollowRepository userMangaFollowRepository;

  private final MangaChapterDownloadProducer mangaChapterDownloadProducer;
  private final MangaContentRepository mangaContentRepository;

  private final NtfyClient ntfyClient;

  public void fetchAllNotDownloadedChapters(Long mangaProviderId) {
    var mangaProvider =
        mangaContentProviderRepository
            .findById(mangaProviderId)
            .orElseThrow(
                () -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));

    var chapterIds =
        mangaProvider.getMangaContents().stream()
            .filter(mangaChapter -> !mangaChapter.getDownloaded())
            .map(MangaContent::getId)
            .collect(Collectors.toSet());

    chapterIds.forEach(
        chapterId ->
            mangaChapterDownloadProducer.sendMangaChapterDownloadCommand(
                new MangaChapterDownloadCommand(chapterId)));
  }

  //  public void fetchFollowedMangaChapters(Long mangaProviderId) {
  //    var mangaProvider =
  //        mangaContentProviderRepository
  //            .findById(mangaProviderId)
  //            .orElseThrow(
  //                () -> new NotFoundException("Manga Provider not found for ID: " +
  // mangaProviderId));
  //
  //    var currentAvailableChapterCount =
  //        mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
  //
  //    fetchMangaChapters(mangaProviderId);
  //    mangaChapterRepository.flush();
  //
  //    var availableChapterCount =
  //        mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
  //
  //    if (availableChapterCount <= currentAvailableChapterCount) {
  //      return;
  //    }
  //
  //    log.info("New chapters found for Manga Provider {}", mangaProviderId);
  //
  //    var userMangaFollows = userMangaFollowRepository.findByManga(mangaProvider.getManga());
  //    userMangaFollows.forEach(
  //        umf ->
  //            ntfyClient.notify(
  //                new NtfyClient.Request(
  //                    "mangamochi-" + umf.getUser().getId().toString(),
  //                    umf.getManga().getTitle(),
  //                    "New chapter available on " +
  // mangaProvider.getContentProvider().getName())));
  //  }

  public Manga findMangaByIdThrowIfNotFound(Long mangaId) {
    return mangaRepository
        .findById(mangaId)
        .orElseThrow(() -> new NotFoundException("Manga not found for ID: " + mangaId));
  }

  private MangaContentProvider getMangaProviderThrowIfNotFound(Long mangaProviderId) {
    return mangaContentProviderRepository
        .findById(mangaProviderId)
        .orElseThrow(
            () -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));
  }

  @Transactional
  public void follow(Long mangaId) {
    var user = userService.getLoggedUserThrowIfNotFound();

    var manga = findMangaByIdThrowIfNotFound(mangaId);
    manga.setFollow(true);

    if (userMangaFollowRepository.existsByUserAndManga(user, manga)) {
      return;
    }

    userMangaFollowRepository.save(UserMangaFollow.builder().user(user).manga(manga).build());
  }

  @Transactional
  public void unfollow(Long mangaId) {
    var user = userService.getLoggedUserThrowIfNotFound();
    var manga = findMangaByIdThrowIfNotFound(mangaId);

    var userMangaFollow = userMangaFollowRepository.findByUserAndManga(user, manga);
    userMangaFollow.ifPresent(userMangaFollowRepository::delete);

    if (!userMangaFollowRepository.existsByManga(manga)) {
      manga.setFollow(false);
    }
  }
}