/**
 * 
 */
package de.bstly.board.businesslogic;

import java.time.Instant;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Order;
import org.springframework.stereotype.Component;

import de.bstly.board.model.Entry;
import de.bstly.board.model.QEntry;
import de.bstly.board.model.QVote;
import de.bstly.board.model.RankedEntry;
import de.bstly.board.model.Types;
import de.bstly.board.model.VoteType;
import de.bstly.board.repository.EntryRepository;
import de.bstly.board.repository.VoteRepository;

/**
 * @author Lurkars
 *
 */
@Component
public class EntryManager {

	@Autowired
	private EntryRepository entryRepository;
	@Autowired
	private CommentManager commentManager;
	@Autowired
	private VoteManager voteManager;
	@Autowired
	private VoteRepository voteRepository;
	private QEntry qEntry = QEntry.entry;
	private QVote qVote = QVote.vote;

	@Value("${bstly.board.ranking.gravity:1.8}")
	private double GRAVITY;

	/**
	 * 
	 * @param page
	 * @param size
	 * @return
	 */
	public Page<Entry> fetchByRanking(int page, int size) {
		return entryRepository.findAll(
				PageRequest.of(page, size, Sort.by(Order.desc("ranking"), Order.desc("created"))));
	}

	/**
	 * 
	 * @param page
	 * @param size
	 * @param order
	 * @return
	 */
	public Page<Entry> fetchByDate(Instant date, int page, int size) {
		return entryRepository.findAll(qEntry.created.before(date),
				PageRequest.of(page, size, Sort.by(Order.desc("created"))));
	}

	/**
	 * 
	 * @param page
	 * @param size
	 * @return
	 */
	public Page<RankedEntry> directFetchByRanking(Instant date, double gravity, int page,
			int size) {
		return entryRepository.findAllByRanking(date, gravity, PageRequest.of(page, size));
	}

	/**
	 * 
	 * @param entry
	 */
	public void applyMetadata(String username, Entry entry) {
		if (!entry.getMetadata().containsKey("comments")) {
			entry.getMetadata().put("comments", commentManager.count(entry.getId()));
		}
		if (!entry.getMetadata().containsKey("points")) {
			entry.getMetadata().put("points", voteManager.getPoints(entry.getId(), Types.entry));
		}
		
		if (!entry.getMetadata().containsKey("upvoted")) {
			entry.getMetadata().put("upvoted",
					voteRepository.exists(qVote.target.eq(entry.getId())
							.and(qVote.targetType.eq(Types.entry)).and(qVote.type.eq(VoteType.up))
							.and(qVote.author.eq(username))));
		}
		
		if (!entry.getMetadata().containsKey("downvoted")) {
			entry.getMetadata().put("downvoted",
					voteRepository.exists(qVote.target.eq(entry.getId())
							.and(qVote.targetType.eq(Types.entry))
							.and(qVote.type.eq(VoteType.down)).and(qVote.author.eq(username))));
		}
		
		if (!entry.getMetadata().containsKey("unvote")) {
			entry.getMetadata().put("unvote",
					voteRepository.exists(
							qVote.target.eq(entry.getId()).and(qVote.targetType.eq(Types.entry))
									.and(qVote.author.eq(username))));
		}
	}

	/**
	 * 
	 * @param entries
	 */
	public void applyMetadata(String username, List<Entry> entries) {
		for (Entry entry : entries) {
			applyMetadata(username, entry);
		}
	}

	/**
	 * @param id
	 * @return
	 */
	public boolean exists(Long id) {
		return entryRepository.existsById(id);
	}

	/**
	 * @param id
	 * @return
	 */
	public Entry get(Long id) {
		return entryRepository.findById(id).orElse(null);
	}

	/**
	 * @param entry
	 * @return
	 */
	public Entry save(Entry entry) {
		return entryRepository.save(entry);
	}

	/**
	 * 
	 * @param entry
	 */
	public void delete(Entry entry) {
		commentManager.deleteByTarget(entry.getId());
		voteManager.deleteByTarget(entry.getId(), Types.entry);
		entryRepository.delete(entry);
	}

	/**
	 * 
	 * @param entryId
	 * @return
	 */
	public long getPoints(Long entryId) {
		long upvotes = voteRepository.count(qVote.targetType.eq(Types.entry)
				.and(qVote.type.eq(VoteType.up)).and(qVote.target.eq(entryId)));
		long downvotes = voteRepository.count(qVote.targetType.eq(Types.entry)
				.and(qVote.type.eq(VoteType.down)).and(qVote.target.eq(entryId)));
		return upvotes - downvotes;
	}

}