Mangarr/src/Controller/MangaController.php

<?php

namespace App\Controller;

use App\Entity\Manga;
use App\Message\DownloadChapter;
use App\Repository\ChapterRepository;
use App\Repository\MangaRepository;
use App\Service\MangaExportService;
use App\Service\LelScansProviderService;
use App\Service\MangaScraperServiceOld;
use App\Service\MangaUpdatesMetadataProvider;
use Doctrine\ORM\NonUniqueResultException;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\String\Slugger\AsciiSlugger;

class MangaController extends AbstractController
{
    public function __construct(
        private readonly MangaScraperServiceOld  $mangaScraperService,
        private readonly MangaExportService      $mangaExportService,
        private readonly LelScansProviderService $mangaProviderService,
        private readonly MangaRepository         $mangaRepository,
        private ChapterRepository                $chapterRepository,
        private MangaUpdatesMetadataProvider     $mangaUpdatesDbProvider,
        private MessageBusInterface              $bus
    )
    {
    }

    #[Route('/manga', name: 'app_manga')]
    public function index(): Response
    {
        $mangas = $this->mangaRepository->findAll();
        return $this->render('manga/index.html.twig', [
            'controller_name' => 'MangaController',
            'mangas' => $mangas,
        ]);
    }

    /**
     * @throws NonUniqueResultException
     */
    #[Route('/manga/{mangaSlug}', name: 'manga_show')]
    public function showChapters(string $mangaSlug): Response
    {
//        $manga = $this->mangaRepository->findOneWithChapterBy(['slug' => $mangaSlug]);
        $manga = $this->mangaRepository->findOneBy(['slug' => $mangaSlug]);

        if (!$manga) {
            throw new NotFoundHttpException("Le manga demandé n'existe pas.");
        }

        $chaptersByVolume = [];
        foreach ($manga->getChapters() as $chapter) {
            $volume = $chapter->getVolume() ?? 'Not Found';
            $chaptersByVolume[$volume][] = $chapter;
        }

        foreach ($chaptersByVolume as $volume => &$chapters) {
            usort($chapters, function ($a, $b) {
                return $b->getNumber() <=> $a->getNumber();
            });
        }
        unset($chapters);

        uksort($chaptersByVolume, function ($a, $b) {
            if ($a == 0) {
                return -1;
            }
            if ($b == 0) {
                return 1;
            }
            return $b <=> $a;
        });

        return $this->render('manga/show_chapters.html.twig', [
            'chapters_by_volume' => $chaptersByVolume,
            'manga' => $manga,
        ]);
    }

    #[Route('/manga/{mangaSlug}/{chapterNumber}/{pageNumber}', name: 'read_chapter_page')]
    public function readChapterPage(string $mangaSlug, float $chapterNumber, int $pageNumber = 0): Response
    {
        $manga = $this->mangaRepository->findOneBy(['slug' => $mangaSlug]);
        if (!$manga) {
            throw $this->createNotFoundException("Le manga demandé n'existe pas.");
        }

        $chapter = $manga->getChapterByNumber($chapterNumber);
        if (!$chapter) {
            throw $this->createNotFoundException("Le chapitre demandé n'existe pas.");
        }

        $currentPage = $chapter->getPageByNumber($pageNumber);
        if (!$currentPage) {
            throw $this->createNotFoundException("La page demandée n'existe pas.");
        }

        return $this->render('manga/manga_reader.html.twig', [
            'manga' => $manga,
            'chapter' => $chapter,
            'pages' => $chapter->getPagesLink(),
            'currentPage' => $currentPage,
        ]);
    }

    #[Route('/addNew/{query}', name: 'add_new_manga')]
    public function addNew(string $query = ''): Response
    {
        return $this->render('manga/add_new.html.twig', [
            'query' => $query,
        ]);
    }

    public function search(string $title): Response
    {
        $mangas = $this->mangaUpdatesDbProvider->search($title);

        return $this->render('manga/add_new.html.twig', [
            'mangas' => $mangas,
        ]);
    }

    #[Route('/addChapter/{id}', name: 'add_chapter')]
    public function addChapterMessenger(int $id): JsonResponse
    {
        $chapter = $this->chapterRepository->find($id);
        if (!$chapter) {
            return new JsonResponse(['error' => 'Chapter Not Found.'], 400);
        } elseif ($chapter->getLocalPath() !== null) {
            return new JsonResponse(['error' => 'Chapter already scraped.'], 400);
        }

        $this->bus->dispatch(new DownloadChapter($id));

        return new JsonResponse(['success' => 'Scrapping started...'], 200);
    }

    #[Route('/download-cbz/{chapterId}', name: 'download_cbz')]
    public function downloadChapter(int $chapterId): BinaryFileResponse
    {
        $chapter = $this->chapterRepository->find($chapterId);
        $response = $this->mangaExportService->downloadCbz($chapter->getManga()->getTitle(), $chapter->getNumber());

        if ($response === false) {
            throw $this->createNotFoundException("Le chapitre demandé n'existe pas.");
        }

        // Définir les en-têtes pour le téléchargement
        $response->headers->set('Content-Type', 'application/x-cbz');
        $response->setContentDisposition(
            ResponseHeaderBag::DISPOSITION_ATTACHMENT,
            "{$chapter->getManga()->getSlug()}_{$chapter->getNumber()}.cbz"
        );

        return $response;
    }

    #[Route('/scrape', name: 'manga_scrape', methods: 'POST')]
    public function scrapeByMangaAndChapter(Request $request): Response
    {
        $mangaSlug = $request->request->get('mangaSlug');
        $chapterNumber = $request->request->get('chapterNumber');

        $response = $this->scrapeChapter($mangaSlug, $chapterNumber);

        $manga = $this->mangaRepository->findOneBy(['slug' => $mangaSlug]);

        $availableChapters = $this->mangaProviderService->getChapterList($mangaSlug);

        return $this->render('manga/show_chapters.html.twig', [
            'controller_name' => 'MangaController',
            'manga' => $manga,
            'availableChapters' => $availableChapters,
        ]);
    }

    #[Route('/scrapeFrom', name: 'manga_scrape_from_chapter', methods: 'POST')]
    public function scrapeByMangaFromChapter(Request $request): Response
    {
        $mangaSlug = $request->request->get('mangaSlug');
        $chapterNumber = $request->request->get('chapterNumber');

        do {
            $response = $this->scrapeChapter($mangaSlug, $chapterNumber);
            $chapterNumber++;
        } while ($response !== false);

        $availableChapters = $this->mangaProviderService->getChapterList($mangaSlug);

        return $this->redirectToRoute('manga_show', ['mangaSlug' => $mangaSlug, 'availableChapters' => $availableChapters]);
    }

    #[Route('/manga/exportFrom/{mangaSlug}/{chapterNumber}', name: 'manga_export')]
    public function exportMangaCbz(string $mangaSlug, float $chapterNumber)
    {
        $response = $this->exportCbz($this->slugToTitle($mangaSlug), $chapterNumber);

        dd($response);
    }

    #[Route('/getList', name: 'get_manga_list')]
    public function getMangaList()
    {
        $list = $this->mangaProviderService->getMangaList();

    }

    private function scrapeChapter(string $mangaSlug, float $chapterNumber): array|bool
    {
        $url = 'https://lelscans.net/scan-' . $mangaSlug . '/' . $chapterNumber;

        $manga = $this->mangaRepository->findOneBy(['slug' => $mangaSlug]);

        if (!is_null($manga)) {
            $scrapedManga = $this->mangaScraperService->scrapeMangaChapter($url, $manga->getTitle(), $chapterNumber);
        } else {
            $title = $this->slugToTitle($mangaSlug);
            $manga = new Manga();
            $manga->setTitle($title);
            $manga->setSlug($mangaSlug);
            $this->mangaRepository->save($manga);
            $scrapedManga = $this->mangaScraperService->scrapeMangaChapter($url, $title, $chapterNumber);
        }

        return $scrapedManga;
    }

    private function exportCbz(string $mangaSlug, float $chapterNumber): array
    {
        $exported = [];
        do {
            $response = $this->mangaExportService->exportMangaChapter($mangaSlug, $chapterNumber);

            if ($response === 'already_exported') {
                $exported[] = $mangaSlug . ' - ' . $chapterNumber . ' ' . $response;
            } elseif ($response === true) {
                $exported[] = $mangaSlug . ' - ' . $chapterNumber . ' exported';
            } else {
                $exported[] = $mangaSlug . ' - ' . $chapterNumber . ' something went wrong';
            }

            $chapterNumber++;
        } while ($response !== false);

        return $exported;
    }

    private function slugToTitle(string $slug): string
    {
        $slugger = new AsciiSlugger();
        $title = $slugger->slug($slug)->replace('-', ' ')->title(true)->toString();

        return $title;
    }

    private function titleToSlug(string $title): string
    {
        $slugger = new AsciiSlugger();
        return $slugger->slug($title)->lower()->toString();
    }
}