package ru.ulstu.conference.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.conference.model.Conference;
import ru.ulstu.conference.model.ConferenceDto;
import ru.ulstu.conference.model.ConferenceFilterDto;
import ru.ulstu.conference.model.ConferenceUser;
import ru.ulstu.conference.repository.ConferenceRepository;
import ru.ulstu.deadline.model.Deadline;
import ru.ulstu.deadline.service.DeadlineService;
import ru.ulstu.paper.model.Paper;
import ru.ulstu.paper.service.PaperService;
import ru.ulstu.ping.model.Ping;
import ru.ulstu.ping.service.PingService;
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.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

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

@RunWith(MockitoJUnitRunner.class)
public class ConferenceServiceTest {

    @Mock
    ConferenceRepository conferenceRepository;

    @Mock
    DeadlineService deadlineService;

    @Mock
    ConferenceUserService conferenceUserService;

    @Mock
    PaperService paperService;

    @Mock
    UserService userService;

    @Mock
    EventService eventService;

    @Mock
    ConferenceNotificationService conferenceNotificationService;

    @Mock
    PingService pingService;

    @InjectMocks
    ConferenceService conferenceService;

    private final static Integer ID = 1;
    private final static Integer INDEX = 0;
    private final static String NAME = "Name";
    private final static String DESCRIPTION = "Desc";
    private final static boolean TRUE = true;
    private final static Integer YEAR = 2019;
    private final static Sort SORT = new Sort(Sort.Direction.DESC, "beginDate");

    private List<Conference> conferences;
    private List<Deadline> deadlines;
    private List<Paper> papers;
    private List<ConferenceUser> conferenceUsers;

    private Conference conferenceWithId;

    private Paper paperWithId;
    private Paper paperWithoutId;

    private ConferenceDto conferenceDto;
    private User user;
    private Deadline deadline;

    @Before
    public void setUp() throws Exception {
        conferences = new ArrayList<>();
        conferenceWithId = new Conference();

        conferenceWithId.setId(ID);
        conferenceWithId.setTitle(NAME);
        conferenceWithId.setDescription(DESCRIPTION);

        paperWithId = new Paper();
        paperWithId.setId(1);
        paperWithId.setTitle(NAME);

        paperWithoutId = new Paper();
        paperWithoutId.setTitle(NAME);

        papers = new ArrayList<>();
        papers.add(paperWithId);
        papers.add(paperWithoutId);

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

        ConferenceUser conferenceUser = new ConferenceUser();
        conferenceUser.setDeposit(ConferenceUser.Deposit.ARTICLE);
        conferenceUser.setParticipation(ConferenceUser.Participation.INTRAMURAL);
        user = new User();
        user.setFirstName(NAME);
        conferenceUser.setUser(user);

        conferenceUsers = new ArrayList<>();
        conferenceUsers.add(conferenceUser);

        conferences.add(conferenceWithId);
        conferenceDto = new ConferenceDto(conferenceWithId);
    }

    @Test
    public void getExistConferenceById() {
        when(conferenceRepository.findOne(ID)).thenReturn(conferenceWithId);
        when(paperService.findAllNotSelect(new ArrayList<>())).thenReturn(papers);
        when(userService.getCurrentUser()).thenReturn(user);

        ConferenceDto newConferenceDto = new ConferenceDto(conferenceWithId);
        newConferenceDto.setNotSelectedPapers(papers);
        newConferenceDto.setDisabledTakePart(!TRUE);
        ConferenceDto result = conferenceService.getExistConferenceById(ID);

        assertEquals(newConferenceDto.getId(), result.getId());
        assertEquals(newConferenceDto.getNotSelectedPapers(), result.getNotSelectedPapers());
        assertEquals(newConferenceDto.isDisabledTakePart(), result.isDisabledTakePart());
    }

    @Test
    public void getNewConference() {
        when(paperService.findAllNotSelect(new ArrayList<>())).thenReturn(papers);

        ConferenceDto newConferenceDto = new ConferenceDto();
        newConferenceDto.setNotSelectedPapers(papers);
        ConferenceDto result = conferenceService.getNewConference();

        assertEquals(newConferenceDto.getId(), result.getId());
        assertEquals(newConferenceDto.getNotSelectedPapers(), result.getNotSelectedPapers());
        assertEquals(newConferenceDto.isDisabledTakePart(), result.isDisabledTakePart());
    }

    @Test
    public void findAll() {
        when(conferenceRepository.findAll(SORT)).thenReturn(conferences);

        assertEquals(Collections.singletonList(conferenceWithId), conferenceService.findAll());
    }

    @Test
    public void create() throws IOException {
        when(paperService.findPaperById(ID)).thenReturn(paperWithId);
        when(paperService.create(new Paper())).thenReturn(paperWithoutId);
        when(deadlineService.saveOrCreate(new ArrayList<>())).thenReturn(deadlines);
        when(conferenceUserService.saveOrCreate(new ArrayList<>())).thenReturn(conferenceUsers);
        when(conferenceRepository.save(new Conference())).thenReturn(conferenceWithId);

        conferenceDto.setPapers(papers);
        conferenceDto.setDeadlines(deadlines);
        conferenceDto.setUsers(conferenceUsers);
        conferenceDto.getPaperIds().add(ID);

        Conference newConference = new Conference();
        newConference.setId(ID);
        newConference.setTitle(NAME);
        newConference.setDescription(DESCRIPTION);
        newConference.setPapers(papers);
        newConference.getPapers().add(paperWithId);
        newConference.setDeadlines(deadlines);
        newConference.setUsers(conferenceUsers);

        assertEquals(newConference, conferenceService.create(conferenceDto));
    }

    @Test
    public void delete() {
        when(conferenceRepository.exists(ID)).thenReturn(true);
        when(conferenceRepository.findOne(ID)).thenReturn(conferenceWithId);
        assertTrue(conferenceService.delete(ID));
    }

    @Test
    public void addDeadline() {
        ConferenceDto newConferenceDto = new ConferenceDto();
        newConferenceDto.getDeadlines().add(new Deadline());
        conferenceDto.getDeadlines().clear();

        assertEquals(newConferenceDto.getDeadlines().get(0), conferenceService.addDeadline(conferenceDto).getDeadlines().get(0));
    }

    @Test
    public void removeDeadline() throws IOException {
        ConferenceDto newConferenceDto = new ConferenceDto();
        newConferenceDto.getRemovedDeadlineIds().add(ID);
        conferenceDto.getDeadlines().add(deadline);
        ConferenceDto result = conferenceService.removeDeadline(conferenceDto, INDEX);

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

    @Test
    public void addPaper() {
        when(userService.getCurrentUser()).thenReturn(user);

        ConferenceDto newConferenceDto = new ConferenceDto();
        newConferenceDto.getPapers().add(paperWithoutId);
        conferenceDto.getPapers().clear();
        ConferenceDto result = conferenceService.addPaper(conferenceDto);
        result.getPapers().get(INDEX).setTitle(NAME); // приходится вручную назначать название, т.е. название зависит от даты

        assertEquals(newConferenceDto.getPapers(), result.getPapers());
    }

    @Test
    public void removePaper() throws IOException {
        ConferenceDto newConferenceDto = new ConferenceDto();
        newConferenceDto.getNotSelectedPapers().add(paperWithId);
        newConferenceDto.getPapers().add(paperWithoutId);
        conferenceDto.getPapers().add(paperWithId);
        conferenceDto.getPapers().add(paperWithoutId);
        ConferenceDto result = conferenceService.removePaper(conferenceDto, INDEX);

        assertEquals(newConferenceDto.getPapers(), result.getPapers());
        assertEquals(newConferenceDto.getNotSelectedPapers(), result.getNotSelectedPapers());
    }

    @Test
    public void takePart() throws IOException {
        when(userService.getCurrentUser()).thenReturn(user);

        ConferenceDto newConferenceDto = new ConferenceDto();
        newConferenceDto.setUsers(conferenceUsers);
        newConferenceDto.setDisabledTakePart(TRUE);
        conferenceDto.getPapers().clear();
        ConferenceDto result = conferenceService.takePart(conferenceDto);

        assertEquals(newConferenceDto.getUsers(), result.getUsers());
        assertEquals(newConferenceDto.isDisabledTakePart(), result.isDisabledTakePart());
    }

    @Test
    public void getAllUsers() {
        List<User> users = Collections.singletonList(user);
        when(userService.findAll()).thenReturn(users);
        assertEquals(users, conferenceService.getAllUsers());
    }

    @Test
    public void filter() {
        when(userService.findById(ID)).thenReturn(user);
        when(conferenceRepository.findByUserAndYear(user, YEAR)).thenReturn(conferences);

        ConferenceFilterDto conferenceFilterDto = new ConferenceFilterDto();
        conferenceFilterDto.setFilterUserId(ID);
        conferenceFilterDto.setYear(YEAR);

        assertEquals(Collections.singletonList(conferenceDto), conferenceService.filter(conferenceFilterDto));
    }

    @Test
    public void isAttachedToConference() {
        when(conferenceRepository.isPaperAttached(ID)).thenReturn(TRUE);

        assertTrue(conferenceService.isAttachedToConference(ID));
    }

    @Test
    public void ping() throws IOException {
        Ping ping = new Ping();
        when(conferenceRepository.findOne(ID)).thenReturn(conferenceWithId);
        when(pingService.addPing(conferenceWithId)).thenReturn(ping);
        when(conferenceRepository.updatePingConference(ID)).thenReturn(INDEX);

        assertEquals(ping, conferenceService.ping(conferenceDto));
    }
}