package ru.ulstu.students.service;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.ulstu.students.model.Scheduler;
import ru.ulstu.students.model.Task;
import ru.ulstu.students.repository.SchedulerRepository;
import ru.ulstu.tags.model.Tag;

import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class SchedulerService {

    private final TaskService taskService;
    private final SchedulerRepository schedulerRepository;

    public SchedulerService(TaskService taskService, SchedulerRepository schedulerRepository) {
        this.taskService = taskService;
        this.schedulerRepository = schedulerRepository;
    }


    private void save(Tag tag) {
        List<Task> taskList = taskService.findTasksByTag(tag);
        create(taskList.get(0));
    }


    @Transactional
    private Scheduler create(Task task) {
        Scheduler scheduler = new Scheduler(task, task.getDeadlines().get(task.getDeadlines().size() - 1).getDate());
        return schedulerRepository.save(scheduler);
    }

    @Transactional
    private void delete(Integer schedulerId) {
        if (schedulerRepository.exists(schedulerId)) {
            schedulerRepository.delete(schedulerId);
        }
    }

    public void checkPlanToday() {
        List<Scheduler> schedulerList = schedulerRepository.findAll();
        if (!schedulerList.isEmpty()) {
            doTodayPlanIfNeed(schedulerList);
            schedulerList = schedulerRepository.findAll();
        }
        checkNewPlan(schedulerList);
    }

    private void checkNewPlan(List<Scheduler> schedulerList) {
        Set<Tag> tags = taskService.checkRepeatingTags(true);
        Set<Tag> newTags = null;
        if (!schedulerList.isEmpty()) {
            newTags = checkNewTags(tags, schedulerList);
        } else {
            if (!tags.isEmpty()) {
                newTags = tags;
            }
        }

        if (newTags != null) {
            newTags.forEach(tag -> {
                if (!hasNewTag(tag, schedulerList)) {
                    save(tag);
                    Task task = taskService.findTasksByTag(tag).get(0);
                    schedulerList.add(new Scheduler(task, task.getDeadlines().get(task.getDeadlines().size() - 1).getDate()));
                }
            });
        }
    }

    private boolean hasNewTag(Tag tag, List<Scheduler> schedulerList) {

        return schedulerList
                .stream()
                .anyMatch(scheduler -> scheduler.getTask().getTags().contains(tag));

    }


    private Set<Tag> checkNewTags(Set<Tag> tags, List<Scheduler> schedulerList) {
        Set<Tag> newTags = tags
                .stream()
                .filter(tag -> schedulerList
                        .stream()
                        .anyMatch(scheduler ->
                                !scheduler.getTask().getTags().contains(tag)))
                .collect(Collectors.toSet());
        if (!newTags.isEmpty()) {
            return newTags;
        }
        return null;
    }

    private void doTodayPlanIfNeed(List<Scheduler> schedulerList) {
        List<Scheduler> plan = schedulerList
                .stream()
                .filter(scheduler -> scheduler.getDate().before(new Date()))
                .collect(Collectors.toList());
        doToday(plan);
    }

    private void doToday(List<Scheduler> plan) {
        plan.forEach(scheduler -> {
            taskService.createPeriodTask(scheduler);
            delete(scheduler.getId());
        });
    }


}