package ru.ulstu.timeline.service;

import org.apache.commons.lang3.time.DateUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.ulstu.conference.model.Conference;
import ru.ulstu.deadline.model.Deadline;
import ru.ulstu.grant.model.Grant;
import ru.ulstu.paper.model.Paper;
import ru.ulstu.students.model.Task;
import ru.ulstu.timeline.model.Event;
import ru.ulstu.timeline.model.EventDto;
import ru.ulstu.timeline.model.Timeline;
import ru.ulstu.timeline.repository.EventRepository;
import ru.ulstu.user.model.UserDto;
import ru.ulstu.user.service.UserService;

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

import static ru.ulstu.core.util.StreamApiUtils.convert;

@Service
public class EventService {

    private final EventRepository eventRepository;
    private final TimelineService timelineService;
    private final UserService userService;

    public EventService(EventRepository eventRepository,
                        @Lazy TimelineService timelineService,
                        UserService userService) {
        this.eventRepository = eventRepository;
        this.timelineService = timelineService;
        this.userService = userService;
    }

    public List<EventDto> findAllDto() {
        return convert(findAll(), EventDto::new);
    }

    public List<Event> findAll() {
        return eventRepository.findAll();
    }

    @Transactional
    public int create(EventDto eventDto) {
        return eventRepository.save(copyFromDto(new Event(), eventDto)).getId();
    }

    private Event copyFromDto(Event event, EventDto eventDto) {
        event.setExecuteDate(eventDto.getExecuteDate());
        event.setCreateDate(eventDto.getId() == null ? new Date() : eventDto.getCreateDate());
        event.setDescription(eventDto.getDescription());
        event.setRecipients(userService.findByIds(convert(eventDto.getRecipients(), UserDto::getId)));
        event.setTitle(eventDto.getTitle());
        event.setPeriod(eventDto.getPeriod());
        event.setStatus(eventDto.getStatus());
        event.setUpdateDate(new Date());
        return event;
    }

    @Transactional
    public Integer update(EventDto eventDto) {
        Event event = eventRepository.getOne(eventDto.getId());
        return eventRepository.save(copyFromDto(event, eventDto)).getId();
    }

    @Transactional
    public Event save(Event event) {
        return eventRepository.save(event);
    }

    @Transactional
    public void delete(Integer eventId) {
        Event event = eventRepository.getOne(eventId);
        event.setParents(null);
        eventRepository.delete(event);
    }

    public List<Event> findByIds(List<Integer> ids) {
        return eventRepository.findAllById(ids);
    }

    public void createBasedOn(Event event, Date executeDate) {
        //backup event id
        Integer parentEventId = event.getId();

        event.setId(null);
        event.setStatus(Event.EventStatus.POSSIBLE);
        event.setExecuteDate(executeDate);
        event.setCreateDate(new Date());
        event.setUpdateDate(new Date());
        event = eventRepository.save(event);

        //set child to parent
        Event parentEvent = eventRepository.getOne(parentEventId);
        parentEvent.setChild(event);
        eventRepository.save(parentEvent);
    }

    public void createFromPaper(Paper newPaper) {
        List<Timeline> timelines = timelineService.findAll();
        Timeline timeline = timelines.isEmpty() ? new Timeline() : timelines.get(0);

        for (Deadline deadline : newPaper.getDeadlines()
                .stream()
                .filter(d -> d.getDate().after(new Date()) || DateUtils.isSameDay(d.getDate(), new Date()))
                .collect(Collectors.toList())) {
            Event newEvent = new Event();
            newEvent.setTitle("Дедлайн статьи");
            newEvent.setStatus(Event.EventStatus.NEW);
            newEvent.setExecuteDate(deadline.getDate());
            newEvent.setCreateDate(new Date());
            newEvent.setUpdateDate(new Date());
            newEvent.setDescription("Дедлайн '" + deadline.getDescription() + "' cтатьи '" + newPaper.getTitle() + "'");
            newEvent.setRecipients(new ArrayList(newPaper.getAuthors()));
            newEvent.setPaper(newPaper);
            eventRepository.save(newEvent);

            timeline.getEvents().add(newEvent);
            timelineService.save(timeline);
        }
    }

    public void updatePaperDeadlines(Paper paper) {
        eventRepository.deleteAll(eventRepository.findAllByPaper(paper));

        createFromPaper(paper);
    }

    public List<Event> findByCurrentDate() {
        return eventRepository.findByCurrentDate();
    }

    public List<Event> findAllFuture() {
        return eventRepository.findAllFuture();
    }

    public List<EventDto> findAllFutureDto() {
        return convert(findAllFuture(), EventDto::new);
    }

    public void createFromConference(Conference newConference) {
        List<Timeline> timelines = timelineService.findAll();
        Timeline timeline = timelines.isEmpty() ? new Timeline() : timelines.get(0);

        for (Deadline deadline : newConference.getDeadlines()
                .stream()
                .filter(d -> d.getDate().after(new Date()) || DateUtils.isSameDay(d.getDate(), new Date()))
                .collect(Collectors.toList())) {
            Event newEvent = new Event();
            newEvent.setTitle("Дедлайн конференции");
            newEvent.setStatus(Event.EventStatus.NEW);
            newEvent.setExecuteDate(deadline.getDate());
            newEvent.setCreateDate(new Date());
            newEvent.setUpdateDate(new Date());
            newEvent.setDescription("Дедлайн '" + deadline.getDescription() + "' конференции '" + newConference.getTitle() + "'");
            newConference.getUsers().forEach(conferenceUser -> newEvent.getRecipients().add(conferenceUser.getUser()));
            newEvent.setConference(newConference);
            save(newEvent);

            timeline.getEvents().add(newEvent);
            timelineService.save(timeline);
        }
    }

    public void updateConferenceDeadlines(Conference conference) {
        eventRepository.delete(eventRepository.findAllByConference(conference));
        createFromConference(conference);
    }

    public void createFromGrant(Grant newGrant) {
        List<Timeline> timelines = timelineService.findAll();
        Timeline timeline = timelines.isEmpty() ? new Timeline() : timelines.get(0);

        for (Deadline deadline : newGrant.getDeadlines()
                .stream()
                .filter(d -> d.getDate().after(new Date()) || DateUtils.isSameDay(d.getDate(), new Date()))
                .collect(Collectors.toList())) {
            Event newEvent = new Event();
            newEvent.setTitle("Дедлайн гранта");
            newEvent.setStatus(Event.EventStatus.NEW);
            newEvent.setExecuteDate(deadline.getDate());
            newEvent.setCreateDate(new Date());
            newEvent.setUpdateDate(new Date());
            newEvent.setDescription("Дедлайн '" + deadline.getDescription() + "' гранта '" + newGrant.getTitle() + "'");
            if (newGrant.getAuthors() != null) {
                newEvent.setRecipients(new ArrayList(newGrant.getAuthors()));
            }
            newEvent.getRecipients().add(newGrant.getLeader());
            newEvent.setGrant(newGrant);
            eventRepository.save(newEvent);

            timeline.getEvents().add(newEvent);
            timelineService.save(timeline);
        }
    }

    public void updateGrantDeadlines(Grant grant) {
        eventRepository.delete(eventRepository.findAllByGrant(grant));
        createFromGrant(grant);
    }

    public void removeConferencesEvent(Conference conference) {
        List<Event> eventList = eventRepository.findAllByConference(conference);
        eventList.forEach(event -> eventRepository.delete(event.getId()));
    }

    public void createFromTask(Task newTask) {
        List<Timeline> timelines = timelineService.findAll();
        Timeline timeline = timelines.isEmpty() ? new Timeline() : timelines.get(0);

        for (Deadline deadline : newTask.getDeadlines()
                .stream()
                .filter(d -> d.getDate().after(new Date()) || DateUtils.isSameDay(d.getDate(), new Date()))
                .collect(Collectors.toList())) {
            Event newEvent = new Event();
            newEvent.setTitle("Дедлайн задачи");
            newEvent.setStatus(Event.EventStatus.NEW);
            newEvent.setExecuteDate(deadline.getDate());
            newEvent.setCreateDate(new Date());
            newEvent.setUpdateDate(new Date());
            newEvent.setDescription("Дедлайн '" + deadline.getDescription() + "' задачи '" + newTask.getTitle() + "'");
            newEvent.getRecipients().add(userService.getCurrentUser());
            newEvent.setTask(newTask);
            eventRepository.save(newEvent);

            timeline.getEvents().add(newEvent);
            timelineService.save(timeline);
        }
    }

    public void updateTaskDeadlines(Task task) {
        eventRepository.delete(eventRepository.findAllByTask(task));
        createFromTask(task);
    }
}