package de.oaa.xxx.social;

import de.oaa.xxx.feed.entity.FeedPostLikeEntity;
import de.oaa.xxx.feed.repository.FeedPostLikeRepository;
import de.oaa.xxx.gruppe.entity.GruppenbeitragLikeEntity;
import de.oaa.xxx.gruppe.repository.GruppenbeitragLikeRepository;
import de.oaa.xxx.social.entity.KommentarLikeEntity;
import de.oaa.xxx.social.entity.PinnwandLikeEntity;
import de.oaa.xxx.social.entity.ProfileImageLikeEntity;
import de.oaa.xxx.social.repository.KommentarLikeRepository;
import de.oaa.xxx.social.repository.PinnwandLikeRepository;
import de.oaa.xxx.social.repository.ProfileImageLikeRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.UUID;

@Service
public class LikeService {

    private static final Logger LOGGER = LoggerFactory.getLogger(LikeService.class);

    private final PinnwandLikeRepository pinnwandLikeRepository;
    private final KommentarLikeRepository kommentarLikeRepository;
    private final ProfileImageLikeRepository profileImageLikeRepository;
    private final FeedPostLikeRepository feedPostLikeRepository;
    private final GruppenbeitragLikeRepository gruppenbeitragLikeRepository;

    public LikeService(PinnwandLikeRepository pinnwandLikeRepository,
                       KommentarLikeRepository kommentarLikeRepository,
                       ProfileImageLikeRepository profileImageLikeRepository,
                       FeedPostLikeRepository feedPostLikeRepository,
                       GruppenbeitragLikeRepository gruppenbeitragLikeRepository) {
        this.pinnwandLikeRepository = pinnwandLikeRepository;
        this.kommentarLikeRepository = kommentarLikeRepository;
        this.profileImageLikeRepository = profileImageLikeRepository;
        this.feedPostLikeRepository = feedPostLikeRepository;
        this.gruppenbeitragLikeRepository = gruppenbeitragLikeRepository;
    }

    public void togglePinnwandLike(UUID eintragId, UUID userId) {
        var existing = pinnwandLikeRepository.findByEintragIdAndUserId(eintragId, userId);
        if (existing.isPresent()) {
            pinnwandLikeRepository.delete(existing.get());
            LOGGER.debug("User {} hat Like auf Pinnwand-Eintrag {} entfernt", userId, eintragId);
        } else {
            PinnwandLikeEntity like = new PinnwandLikeEntity();
            like.setLikeId(UUID.randomUUID());
            like.setEintragId(eintragId);
            like.setUserId(userId);
            like.setLikedAt(LocalDateTime.now());
            pinnwandLikeRepository.save(like);
            LOGGER.debug("User {} hat Pinnwand-Eintrag {} geliked", userId, eintragId);
        }
    }

    public void toggleKommentarLike(UUID kommentarId, UUID userId) {
        var existing = kommentarLikeRepository.findByKommentarIdAndUserId(kommentarId, userId);
        if (existing.isPresent()) {
            kommentarLikeRepository.delete(existing.get());
            LOGGER.debug("User {} hat Like auf Kommentar {} entfernt", userId, kommentarId);
        } else {
            KommentarLikeEntity like = new KommentarLikeEntity();
            like.setLikeId(UUID.randomUUID());
            like.setKommentarId(kommentarId);
            like.setUserId(userId);
            like.setLikedAt(LocalDateTime.now());
            kommentarLikeRepository.save(like);
            LOGGER.debug("User {} hat Kommentar {} geliked", userId, kommentarId);
        }
    }

    public void toggleProfileImageLike(UUID imageId, UUID userId) {
        var existing = profileImageLikeRepository.findByImageIdAndUserId(imageId, userId);
        if (existing.isPresent()) {
            profileImageLikeRepository.delete(existing.get());
            LOGGER.debug("User {} hat Like auf Profilbild {} entfernt", userId, imageId);
        } else {
            ProfileImageLikeEntity like = new ProfileImageLikeEntity();
            like.setLikeId(UUID.randomUUID());
            like.setImageId(imageId);
            like.setUserId(userId);
            like.setLikedAt(LocalDateTime.now());
            profileImageLikeRepository.save(like);
            LOGGER.debug("User {} hat Profilbild {} geliked", userId, imageId);
        }
    }

    public void toggleFeedPostLike(UUID postId, UUID userId) {
        var existing = feedPostLikeRepository.findByPostIdAndUserId(postId, userId);
        if (existing.isPresent()) {
            feedPostLikeRepository.delete(existing.get());
            LOGGER.debug("User {} hat Like auf Feed-Post {} entfernt", userId, postId);
        } else {
            FeedPostLikeEntity like = new FeedPostLikeEntity();
            like.setLikeId(UUID.randomUUID());
            like.setPostId(postId);
            like.setUserId(userId);
            like.setLikedAt(LocalDateTime.now());
            feedPostLikeRepository.save(like);
            LOGGER.debug("User {} hat Feed-Post {} geliked", userId, postId);
        }
    }

    public void toggleGruppenbeitragLike(UUID beitragId, UUID userId) {
        var existing = gruppenbeitragLikeRepository.findByBeitragIdAndUserId(beitragId, userId);
        if (existing.isPresent()) {
            gruppenbeitragLikeRepository.delete(existing.get());
            LOGGER.debug("User {} hat Like auf Beitrag {} entfernt", userId, beitragId);
        } else {
            GruppenbeitragLikeEntity like = new GruppenbeitragLikeEntity();
            like.setLikeId(UUID.randomUUID());
            like.setBeitragId(beitragId);
            like.setUserId(userId);
            like.setLikedAt(LocalDateTime.now());
            gruppenbeitragLikeRepository.save(like);
            LOGGER.debug("User {} hat Beitrag {} geliked", userId, beitragId);
        }
    }
}
