package ru.ulstu.students.service;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.springframework.data.domain.Sort;
import ru.ulstu.core.util.DateUtils;
import ru.ulstu.deadline.model.Deadline;
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.SchedulerRepository;
import ru.ulstu.students.repository.TaskRepository;
import ru.ulstu.tags.model.Tag;
import ru.ulstu.tags.service.TagService;
import ru.ulstu.timeline.service.EventService;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class TaskServiceTest {

    @Mock
    TaskRepository taskRepository;

    @Mock
    SchedulerRepository schedulerRepository;

    @Mock
    private TagService tagService;

    @Mock
    DeadlineService deadlineService;

    @Mock
    EventService eventService;

    @InjectMocks
    TaskService taskService;

    private final static Sort SORT = new Sort(Sort.Direction.DESC, "createDate");
    private final static Integer ID = 1;
    private final static Task.TaskStatus STATUS = Task.TaskStatus.IN_WORK;
    private final static String TITLE = "title";
    private final static String DESCR = "descr";
    private final static String TAG = "tag";
    private final static Date YEAR = DateUtils.clearTime(DateUtils.addYears(new Date(), 0));

    private List<Task> tasks;
    private List<Tag> tags;
    private Task task;
    private TaskFilterDto filterDto;
    private TaskDto taskDto;
    private List<TaskDto> tasksDto;
    private Tag tag;
    private Tag tagNull;
    private Deadline deadline;
    private List<Deadline> deadlines;
    private Set<Tag> repeatingTags;


    @Before
    public void setUp() throws Exception {

        tasks = new ArrayList<>();
        task = new Task();

        task.setId(ID);
        task.setTitle(TITLE);
        task.setDescription(DESCR);


        tag = new Tag();
        tag.setId(ID);
        tag.setTagName(TAG);

        deadlines = new ArrayList<>();
        deadline = new Deadline(new Date(), DESCR);
        deadline.setId(ID);
        deadlines.add(deadline);

        task.setDeadlines(deadlines);

        tags = new ArrayList<>();
        tags.add(tag);

        tasks.add(task);
        taskDto = new TaskDto(task);

        repeatingTags = new HashSet<>();
        repeatingTags.add(tag);

    }

    @Test
    public void findAll() {

        when(taskRepository.findAll(SORT)).thenReturn(tasks);
        assertEquals(Collections.singletonList(task), taskService.findAll());
    }

    @Test
    public void filter() {
        when(tagService.findById(ID)).thenReturn(tag);
        when(taskRepository.filterNew(STATUS, tag)).thenReturn(tasks);

        TaskFilterDto taskFilterDto = new TaskFilterDto();
        taskFilterDto.setTag(ID);
        taskFilterDto.setOrder("new");
        taskFilterDto.setStatus(STATUS);

        assertEquals(Collections.singletonList(taskDto), taskService.filter(taskFilterDto));
    }

    @Test
    public void create() throws IOException {
        when(tagService.saveOrCreate(new ArrayList<>())).thenReturn(tags);
        when(deadlineService.saveOrCreate(new ArrayList<>())).thenReturn(deadlines);
        when(taskRepository.save(new Task())).thenReturn(task);
        eventService.createFromTask(new Task());

        taskDto.setTags(tags);
        taskDto.setDeadlines(deadlines);

        Task newTask = new Task();
        task.setId(ID);
        task.setTitle(TITLE);
        task.setDescription(DESCR);
        task.setTags(tags);
        task.setDeadlines(deadlines);

        assertEquals(task.getId(), taskService.create(taskDto));
    }

    @Test
    public void delete() throws IOException {
        when(taskRepository.exists(ID)).thenReturn(true);
        when(taskRepository.findOne(ID)).thenReturn(task);
        when(schedulerRepository.findOneByTask(task)).thenReturn(null);

        assertTrue(taskService.delete(ID));
    }

    @Test
    public void generateYearTasks() {
        when(tagService.getTags()).thenReturn(tags);
        tasks.get(0).setTags(tags);
        when(taskRepository.findAllYear(DateUtils.clearTime(DateUtils.addYears(new Date(), -1)))).thenReturn(tasks);
        tasks.get(0).setCreateDate(DateUtils.clearTime(DateUtils.addYears(new Date(), -1)));
        when(taskRepository.findByTag(tag)).thenReturn(tasks);

        Task newTask = new Task();
        newTask.setTitle(tasks.get(0).getTitle());
        newTask.setTags(tasks.get(0).getTags());
        newTask.setCreateDate(new Date());
        newTask.setStatus(Task.TaskStatus.LOADED_FROM_KIAS);

        Deadline newDeadline = new Deadline();
        newDeadline.setDescription(deadline.getDescription());
        newDeadline.setDate(DateUtils.addYears(deadline.getDate(), 1));
        newTask.setDeadlines(Arrays.asList(newDeadline));

        when(taskRepository.save(newTask)).thenReturn(task);

        assertEquals(Arrays.asList(task), taskService.generateYearTasks());
    }

    @Test
    public void checkRepeatingTags() {
        when(tagService.getTags()).thenReturn(tags);
        tasks.get(0).setTags(tags);
        when(taskRepository.findAllYear(DateUtils.clearTime(DateUtils.addYears(new Date(), -1)))).thenReturn(tasks);

        assertEquals(new HashSet<Tag>(Arrays.asList(tag)), taskService.checkRepeatingTags(false));
    }

    @Test
    public void getTaskStatuses() {
    }

    @Test
    public void getTags() {
    }

    @Test
    public void findTasksByTag() {
    }

    @Test
    public void createPeriodTask() {
    }
}