<?php

namespace App\Controller;

use App\Dto\AlbumSearchCriteria;
use App\Entity\Album;
use App\Entity\Review;
use App\Entity\User;
use App\Form\ReviewType;
use App\Form\AlbumType;
use App\Repository\AlbumRepository;
use App\Repository\AlbumTrackRepository;
use App\Repository\ReviewRepository;
use App\Service\AlbumSearchService;
use App\Service\UploadStorage;
use App\Service\SpotifyClient;
use App\Service\SpotifyGenreResolver;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;

/**
 * AlbumController orchestrates search, CRUD, and review entry on albums.
 */
class AlbumController extends AbstractController
{
    public function __construct(
        private readonly UploadStorage $uploadStorage,
        private readonly AlbumSearchService $albumSearch,
        private readonly SpotifyGenreResolver $genreResolver,
        private readonly int $searchLimit = 20
    ) {
    }

    /**
     * Searches Spotify plus local albums and decorates results with review stats.
     */
    #[Route('/', name: 'album_search', methods: ['GET'])]
    public function search(Request $request): Response
    {
        $criteria = AlbumSearchCriteria::fromRequest($request, $this->searchLimit);
        $result = $this->albumSearch->search($criteria);

        return $this->render('album/search.html.twig', [
            'query' => $criteria->query,
            'album' => $criteria->albumName,
            'artist' => $criteria->artist,
            'genre' => $criteria->genre,
            'year_from' => $criteria->yearFrom ?? '',
            'year_to' => $criteria->yearTo ?? '',
            'albums' => $result->albums,
            'stats' => $result->stats,
            'savedIds' => $result->savedIds,
            'source' => $criteria->source,
            'spotifyConfigured' => $this->albumSearch->isSpotifyConfigured(),
        ]);
    }

    /**
     * Creates a user-authored album entry.
     */
    #[IsGranted('ROLE_USER')]
    #[Route('/albums/new', name: 'album_new', methods: ['GET', 'POST'])]
    public function create(Request $request, AlbumRepository $albumRepo, EntityManagerInterface $em): Response
    {
        $album = new Album();
        $album->setSource('user');
        $form = $this->createForm(AlbumType::class, $album);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $this->normalizeAlbumFormData($album);
            $user = $this->getUser();
            if ($user instanceof User) {
                $album->setCreatedBy($user);
            }
            $this->handleAlbumCoverUpload($album, $form);
            $album->setLocalId($this->generateLocalId($albumRepo));
            $em->persist($album);
            $em->flush();
            $this->addFlash('success', 'Album created.');
            return $this->redirectToRoute('album_show', ['id' => $album->getLocalId()]);
        }
        return $this->render('album/new.html.twig', [
            'form' => $form->createView(),
        ]);
    }

    /**
     * Renders a detailed album view plus inline review form.
     */
    #[Route('/albums/{id}', name: 'album_show', methods: ['GET', 'POST'])]
    public function show(string $id, Request $request, SpotifyClient $spotify, ReviewRepository $reviewRepo, AlbumRepository $albumRepo, AlbumTrackRepository $trackRepo, EntityManagerInterface $em): Response
    {
        $albumEntity = $this->findAlbum($id, $albumRepo);
        $isSaved = $albumEntity !== null;
        if (!$albumEntity) {
            // Album has never been saved locally, so hydrate it via Spotify before rendering.
            $spotifyAlbum = $spotify->getAlbumWithTracks($id);
            if ($spotifyAlbum === null) {
                throw $this->createNotFoundException('Album not found');
            }
            $albumEntity = $this->persistSpotifyAlbumPayload($spotifyAlbum, $albumRepo, $trackRepo);
            $em->flush();
        } else {
            if ($this->syncSpotifyTracklistIfNeeded($albumEntity, $albumRepo, $trackRepo, $spotify)) {
                // Track sync mutated the entity: persist before we build template arrays.
                $em->flush();
            }
        }
        $albumCard = $albumEntity->toTemplateArray();
        $canManage = $this->canManageAlbum($albumEntity);
        $trackRows = array_map(static fn($track) => $track->toTemplateArray(), $albumEntity->getTracks()->toArray());

        $existing = $reviewRepo->findBy(['album' => $albumEntity], ['createdAt' => 'DESC']);
        $count = count($existing);
        $avg = 0.0;
        if ($count > 0) {
            $sum = 0;
            foreach ($existing as $rev) { $sum += (int) $rev->getRating(); }
            $avg = round($sum / $count, 1);
        }

        $review = new Review();
        $review->setAlbum($albumEntity);

        $form = $this->createForm(ReviewType::class, $review);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $this->denyAccessUnlessGranted('ROLE_USER');
            $review->setAuthor($this->getUser());
            $em->persist($review);
            $em->flush();
            $this->addFlash('success', 'Review added.');
            return $this->redirectToRoute('album_show', ['id' => $id]);
        }

        return $this->render('album/show.html.twig', [
            'album' => $albumCard,
            'albumId' => $id,
            'isSaved' => $isSaved,
            'allowedEdit' => $canManage,
            'allowedDelete' => $canManage,
            'reviews' => $existing,
            'avg' => $avg,
            'count' => $count,
            'form' => $form->createView(),
            'albumOwner' => $albumEntity->getCreatedBy(),
            'albumCreatedAt' => $albumEntity->getCreatedAt(),
            'tracks' => $trackRows,
        ]);
    }

    /**
     * Saves a Spotify album locally for quicker access.
     */
    #[IsGranted('ROLE_USER')]
    #[Route('/albums/{id}/save', name: 'album_save', methods: ['POST'])]
    public function save(string $id, Request $request, SpotifyClient $spotify, AlbumRepository $albumRepo, AlbumTrackRepository $trackRepo, EntityManagerInterface $em): Response
    {
        $token = (string) $request->request->get('_token');
        if (!$this->isCsrfTokenValid('save-album-' . $id, $token)) {
            throw $this->createAccessDeniedException('Invalid CSRF token.');
        }
        $existing = $albumRepo->findOneBySpotifyId($id);
        if (!$existing) {
            $spotifyAlbum = $spotify->getAlbumWithTracks($id);
            if ($spotifyAlbum === null) {
                throw $this->createNotFoundException('Album not found');
            }
            $this->persistSpotifyAlbumPayload($spotifyAlbum, $albumRepo, $trackRepo);
            $em->flush();
            $this->addFlash('success', 'Album saved.');
        } else {
            $this->addFlash('info', 'Album already saved.');
        }
        return $this->redirectToRoute('album_show', ['id' => $id]);
    }

    /**
     * Deletes a user-created album when authorized.
     */
    #[IsGranted('ROLE_USER')]
    #[Route('/albums/{id}/delete', name: 'album_delete', methods: ['POST'])]
    public function delete(string $id, Request $request, AlbumRepository $albumRepo, EntityManagerInterface $em): Response
    {
        $token = (string) $request->request->get('_token');
        if (!$this->isCsrfTokenValid('delete-album-' . $id, $token)) {
            throw $this->createAccessDeniedException('Invalid CSRF token.');
        }
        $album = $this->findAlbum($id, $albumRepo);
        if ($album) {
            $this->ensureCanManageAlbum($album);
            if ($album->getSource() === 'user') {
                $this->uploadStorage->remove($album->getCoverImagePath());
            }
            $em->remove($album);
            $em->flush();
            $this->addFlash('success', 'Album deleted.');
        } else {
            $this->addFlash('info', 'Album not found.');
        }
        return $this->redirectToRoute('album_search');
    }

    /**
     * Generates a unique user album identifier.
     */
    private function generateLocalId(AlbumRepository $albumRepo): string
    {
        do {
            $id = 'u_' . bin2hex(random_bytes(6));
        } while ($albumRepo->findOneByLocalId($id) !== null);
        return $id;
    }

    /**
     * Normalizes a human-entered release date (YYYY[-MM[-DD]]).
     */
    private function normalizeReleaseDate(?string $input): ?string
    {
        if ($input === null || trim($input) === '') {
            return null;
        }
        $s = trim($input);
        // YYYY
        if (preg_match('/^\d{4}$/', $s)) {
            return $s . '-01-01';
        }
        // YYYY-MM
        if (preg_match('/^\d{4}-\d{2}$/', $s)) {
            return $s . '-01';
        }
        // YYYY-MM-DD
        if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $s)) {
            return $s;
        }
        // Fallback: attempt to parse
        try {
            // Trust PHP's parser only as a last resort (it accepts many human formats).
            $dt = new \DateTimeImmutable($s);
            return $dt->format('Y-m-d');
        } catch (\Throwable) {
            return null;
        }
    }

    /**
     * Edits a saved album when the current user may manage it.
     */
    #[IsGranted('ROLE_USER')]
    #[Route('/albums/{id}/edit', name: 'album_edit', methods: ['GET', 'POST'])]
    public function edit(string $id, Request $request, AlbumRepository $albumRepo, EntityManagerInterface $em): Response
    {
        $album = $this->findAlbum($id, $albumRepo);
        if (!$album) {
            throw $this->createNotFoundException('Album not found');
        }
        $this->ensureCanManageAlbum($album);

        $form = $this->createForm(AlbumType::class, $album);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $this->normalizeAlbumFormData($album);
            $this->handleAlbumCoverUpload($album, $form);
            $em->flush();
            $this->addFlash('success', 'Album updated.');
            return $this->redirectToRoute('album_show', ['id' => $id]);
        }
        return $this->render('album/edit.html.twig', [
            'form' => $form->createView(),
            'albumId' => $id,
        ]);
    }

    /**
     * Looks up an album by either local or Spotify identifier.
     */
    private function findAlbum(string $id, AlbumRepository $albumRepo): ?Album
    {
        $local = $albumRepo->findOneByLocalId($id);
        if ($local instanceof Album) {
            return $local;
        }

        return $albumRepo->findOneBySpotifyId($id);
    }

    /**
     * Returns true when the authenticated user can manage the album.
     */
    private function canManageAlbum(Album $album): bool
    {
        if ($this->isGranted('ROLE_MODERATOR')) {
            return true;
        }
        return $album->getSource() === 'user' && $this->isAlbumOwner($album);
    }

    /**
     * Throws if the authenticated user cannot manage the album.
     */
    private function ensureCanManageAlbum(Album $album): void
    {
        if (!$this->canManageAlbum($album)) {
            throw $this->createAccessDeniedException();
        }
    }

    /**
     * Checks whether the current user created the album.
     */
    private function isAlbumOwner(Album $album): bool
    {
        $user = $this->getUser();
        return $user instanceof User && $album->getCreatedBy()?->getId() === $user->getId();
    }

    private function normalizeAlbumFormData(Album $album): void
    {
        $album->setReleaseDate($this->normalizeReleaseDate($album->getReleaseDate()));
    }

    private function handleAlbumCoverUpload(Album $album, FormInterface $form): void
    {
        if ($album->getSource() !== 'user' || !$form->has('coverUpload')) {
            return;
        }
        $file = $form->get('coverUpload')->getData();
        if ($file instanceof UploadedFile) {
            $this->uploadStorage->remove($album->getCoverImagePath());
            $album->setCoverImagePath($this->uploadStorage->storeAlbumCover($file));
        }
    }

    /**
     * @param array<string,mixed> $spotifyAlbum
     */
    private function persistSpotifyAlbumPayload(array $spotifyAlbum, AlbumRepository $albumRepo, AlbumTrackRepository $trackRepo): Album
    {
        // Bring genres along when we persist Spotify albums so templates can display them immediately.
        $genresMap = $this->genreResolver->resolveGenresForAlbums([$spotifyAlbum]);
        $albumId = (string) ($spotifyAlbum['id'] ?? '');
        $album = $albumRepo->upsertFromSpotifyAlbum(
            $spotifyAlbum,
            $albumId !== '' ? ($genresMap[$albumId] ?? []) : []
        );
        $tracks = $spotifyAlbum['tracks']['items'] ?? [];
        if (is_array($tracks) && $tracks !== []) {
            $trackRepo->replaceAlbumTracks($album, $tracks);
            $album->setTotalTracks(count($tracks));
        }
        return $album;
    }

    private function syncSpotifyTracklistIfNeeded(Album $album, AlbumRepository $albumRepo, AlbumTrackRepository $trackRepo, SpotifyClient $spotify): bool
    {
        if ($album->getSource() !== 'spotify') {
            return false;
        }
        $spotifyId = $album->getSpotifyId();
        if ($spotifyId === null) {
            return false;
        }
        $storedCount = $album->getTracks()->count();
        $needsSync = $storedCount === 0;
        if (!$needsSync && $album->getTotalTracks() > 0 && $storedCount !== $album->getTotalTracks()) {
            // Spotify track counts do not match what we have stored; re-sync to avoid stale data.
            $needsSync = true;
        }
        if (!$needsSync) {
            return false;
        }
        $spotifyAlbum = $spotify->getAlbumWithTracks($spotifyId);
        if ($spotifyAlbum === null) {
            return false;
        }
        // Rehydrate genres during syncs as well, in case Spotify has updated the metadata.
        $genresMap = $this->genreResolver->resolveGenresForAlbums([$spotifyAlbum]);
        $albumGenres = $genresMap[$spotifyId] ?? [];
        $albumRepo->upsertFromSpotifyAlbum($spotifyAlbum, $albumGenres);
        $tracks = $spotifyAlbum['tracks']['items'] ?? [];
        if (!is_array($tracks) || $tracks === []) {
            return false;
        }
        $trackRepo->replaceAlbumTracks($album, $tracks);
        $album->setTotalTracks(count($tracks));
        return true;
    }

}