package ru.ulstu.students.service;

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.ulstu.deadline.service.DeadlineService;
import ru.ulstu.students.model.Task;
import ru.ulstu.students.model.TaskDto;
import ru.ulstu.students.model.TaskFilterDto;
import ru.ulstu.students.repository.TaskRepository;
import ru.ulstu.tags.model.Tag;
import ru.ulstu.tags.service.TagService;

import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import static org.springframework.util.ObjectUtils.isEmpty;
import static ru.ulstu.core.util.StreamApiUtils.convert;
import static ru.ulstu.students.model.Task.TaskStatus.IN_WORK;

@Service
public class TaskService {

    private final static int MAX_DISPLAY_SIZE = 40;

    private final TaskRepository taskRepository;
    private final DeadlineService deadlineService;
    private final TagService tagService;

    public TaskService(TaskRepository taskRepository,
                       DeadlineService deadlineService, TagService tagService) {
        this.taskRepository = taskRepository;
        this.deadlineService = deadlineService;
        this.tagService = tagService;
    }

    public List<Task> findAll() {
        return taskRepository.findAll(new Sort(Sort.Direction.DESC, "createDate"));
    }

    public List<TaskDto> findAllDto() {
        List<TaskDto> tasks = convert(findAll(), TaskDto::new);
        tasks.forEach(taskDto -> taskDto.setTitle(StringUtils.abbreviate(taskDto.getTitle(), MAX_DISPLAY_SIZE)));
        return tasks;
    }

    public TaskDto findOneDto(Integer id) {
        return new TaskDto(taskRepository.findOne(id));
    }

    public List<TaskDto> filter(TaskFilterDto filterDto) {
        if (filterDto.getOrder().compareTo("new") == 0) {
            return convert(taskRepository.filterNew(
                    filterDto.getStatus(),
                    filterDto.getTag() == null ? null : tagService.findById(filterDto.getTag())), TaskDto::new);
        } else {
            return convert(taskRepository.filterOld(
                    filterDto.getStatus(),
                    filterDto.getTag() == null ? null : tagService.findById(filterDto.getTag())), TaskDto::new);
        }
    }

    @Transactional
    public Integer create(TaskDto taskDto) throws IOException {
        Task newTask = copyFromDto(new Task(), taskDto);
        newTask = taskRepository.save(newTask);
        return newTask.getId();
    }

    private Task copyFromDto(Task task, TaskDto taskDto) throws IOException {
        task.setTitle(taskDto.getTitle());
        task.setDescription(taskDto.getDescription());
        task.setStatus(taskDto.getStatus() == null ? IN_WORK : taskDto.getStatus());
        task.setDeadlines(deadlineService.saveOrCreate(taskDto.getDeadlines()));
        task.setCreateDate(task.getCreateDate() == null ? new Date() : task.getCreateDate());
        task.setUpdateDate(new Date());
        task.getTags().clear();
        task.setTags(tagService.saveOrCreate(taskDto.getTags()));
        return task;
    }

    @Transactional
    public Integer update(TaskDto taskDto) throws IOException {
        Task task = taskRepository.findOne(taskDto.getId());
        taskRepository.save(copyFromDto(task, taskDto));
        return task.getId();
    }

    @Transactional
    public void delete(Integer taskId) throws IOException {
        if (taskRepository.exists(taskId)) {
            taskRepository.delete(taskId);
        }

    }

    public void save(TaskDto taskDto) throws IOException {
        if (isEmpty(taskDto.getId())) {
            create(taskDto);
        } else {
            update(taskDto);
        }
    }

    public List<Task.TaskStatus> getTaskStatuses() {
        return Arrays.asList(Task.TaskStatus.values());
    }

    public List<Tag> getTags() {
        return tagService.getTags();
    }

}