package cn.seecoder.seecoderbokserver.service;

import cn.seecoder.bok.common.dto.CollectDTO;
import cn.seecoder.bok.common.dto.RateDTO;
import cn.seecoder.seecoderbokserver.domain.Interaction;
import cn.seecoder.seecoderbokserver.domain.Question;
import cn.seecoder.seecoderbokserver.repository.InteractionRepository;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import static org.springframework.data.jpa.domain.Specification.where;

/**
 * @author Kunduin
 */
@Service
@Transactional(rollbackOn = RuntimeException.class)
public class UserInteractionService {

    private final InteractionRepository interactionRepository;
    private final QuestionService questionService;

    public UserInteractionService(InteractionRepository collectionInteractionRepository, QuestionService questionService) {
        this.interactionRepository = collectionInteractionRepository;
        this.questionService = questionService;
    }

    public Interaction collectQuestion(String userId, String questionId, CollectDTO collectDTO) {
        return interactionRepository.findByUserIdAndQuestionId(userId, questionId)
                .map(interaction -> {
                    interaction.setCollection(collectDTO.getCollect());
                    return interactionRepository.save(interaction);
                })
                .orElseGet(() -> {
                    Interaction interaction = new Interaction();
                    interaction.setUserId(userId);
                    interaction.setQuestionId(questionId);
                    interaction.setCollection(collectDTO.getCollect());

                    return interactionRepository.save(interaction);
                });
    }

    public Interaction rateQuestion(String userId, String questionId, RateDTO rateDTO) {
        return interactionRepository.findByUserIdAndQuestionId(userId, questionId)
                .map(interaction -> {
                    interaction.setRate(rateDTO.getRate());
                    return interactionRepository.save(interaction);
                })
                .orElseGet(() -> {
                    Interaction interaction = new Interaction();
                    interaction.setUserId(userId);
                    interaction.setQuestionId(questionId);
                    interaction.setRate(rateDTO.getRate());

                    return interactionRepository.save(interaction);
                });
    }

    public Page<Question> getUserInteractiveQuestions(String userId, Boolean collect, Boolean rate, Pageable pageable) {
        Page<Interaction> interactions = interactionRepository.findAll(
                where(interactionRepository.byUser(userId))
                        .and(interactionRepository.hasCollected(collect))
                        .and(interactionRepository.hasRated(rate)), pageable);
        List<String> questionIds = interactions.getContent().stream()
                .map(Interaction::getQuestionId).collect(Collectors.toList());
        Iterable<Question> questions = questionService.findAllById(questionIds);
        List<Question> questionList = StreamSupport.stream(questions.spliterator(), false)
                .collect(Collectors.toList());
        return new PageImpl<>(questionList, pageable, interactions.getTotalElements());
    }

    public Optional<Interaction> getUserInteractiveQuestion(String userId, String questionId) {
        return interactionRepository.findByUserIdAndQuestionId(userId, questionId);
    }

    public List<Interaction> getUserInteractiveQuestionIn(String userId, List<String> questionIdList) {
        return interactionRepository.findAll(where(interactionRepository.byUser(userId))
                .and(interactionRepository.inQuestions(questionIdList)));
    }

    @Transactional(rollbackOn = Exception.class)
    public List<Interaction> saveAll(Collection<Interaction> interactions) {
        return interactionRepository.saveAll(interactions);
    }
}