package ru.ulstu.project.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 ru.ulstu.deadline.model.Deadline;
import ru.ulstu.deadline.service.DeadlineService;
import ru.ulstu.file.model.FileData;
import ru.ulstu.file.service.FileService;
import ru.ulstu.grant.model.GrantDto;
import ru.ulstu.grant.service.GrantService;
import ru.ulstu.project.model.Project;
import ru.ulstu.project.model.ProjectDto;
import ru.ulstu.project.repository.ProjectRepository;
import ru.ulstu.timeline.service.EventService;
import ru.ulstu.user.model.User;
import ru.ulstu.user.service.UserService;

import java.io.IOException;
import java.util.*;

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

@RunWith(MockitoJUnitRunner.class)
public class ProjectServiceTest {

    @Mock
    ProjectRepository projectRepository;

    @Mock
    DeadlineService deadlineService;

    @Mock
    EventService eventService;

    @Mock
    FileService fileService;

    @Mock
    UserService userService;

    @Mock
    GrantService grantService;

    @InjectMocks
    ProjectService projectService;

    private final static String TITLE = "title";
    private final static String DESCR = "descr";
    private final static Integer ID = 1;
    private final static Integer INDEX = 0;
    private final static String NAME = "name";

    private List<Project> projects;
    private Project project;
    private ProjectDto projectDto;
    private Deadline deadline;
    private List<Deadline> deadlines;
    private FileData file;
    private List<FileData> files;
    private User user;
    private GrantDto grant;
    private List<GrantDto> grants;

    @Before
    public void setUp() throws Exception {
        projects = new ArrayList<>();
        project = new Project();

        projects.add(project);
        projectDto = new ProjectDto(project);

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

        user = new User();
        user.setFirstName(NAME);

        grants = new ArrayList<>();
        grant = new GrantDto();
        grant.setId(ID);
        grants.add(grant);
    }

    @Test
    public void findAll() {
        when(projectRepository.findAll()).thenReturn(projects);
        assertEquals(projects, projectService.findAll());
    }

    @Test
    public void create() throws IOException {
        when(deadlineService.saveOrCreate(new ArrayList<>())).thenReturn(deadlines);
        when(projectRepository.save(new Project())).thenReturn(project);
        eventService.createFromProject(new Project());

        projectDto.setTitle(TITLE);
        projectDto.setDeadlines(deadlines);

        project.setId(ID);
        project.setTitle(TITLE);
        project.setDescription(DESCR);
        project.setDeadlines(deadlines);
        project.setFiles(files);

        assertEquals(project.getId(), (projectService.create(projectDto)).getId());
    }

    @Test
    public void delete() throws IOException {
        when(projectRepository.exists(ID)).thenReturn(true);
        when(projectRepository.findOne(ID)).thenReturn(project);

        assertTrue(projectService.delete(ID));
    }

    @Test
    public void getProjectExecutors() {
        List<User> executors = Collections.singletonList(user);
        when(userService.findAll()).thenReturn(executors);

        assertEquals(executors, projectService.getProjectExecutors(projectDto));
    }

    @Test
    public void findById() {
        when(projectRepository.findOne(ID)).thenReturn(project);
        assertEquals(project, projectService.findById(ID));
    }

    @Test
    public void removeDeadline() throws IOException {
        ProjectDto newProjectDto = new ProjectDto();
        newProjectDto.getRemovedDeadlineIds().add(INDEX);
        projectDto.getDeadlines().add(deadline);
        ProjectDto result = projectService.removeDeadline(projectDto, INDEX);

        assertEquals(newProjectDto.getDeadlines(), result.getDeadlines());
        assertEquals(newProjectDto.getRemovedDeadlineIds(), result.getRemovedDeadlineIds());
    }
}