package com.release11.klaus.service;

import com.release11.klaus.mappers.MockedMessageMapper;
import com.release11.klaus.mappers.MockedMessageMapperImpl;
import com.release11.klaus.model.MockedMessage;
import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.repository.MockedResponseRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.ws.rs.core.MediaType;
import java.util.*;

import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {MockedMessageMapperImpl.class})
class KlausServiceImplTest {

    @Mock
    MockedResponseRepository mockedResponseRepository;

    @Mock    private MockedMessageMapper mockedMessageMapper;

    @InjectMocks
    KlausServiceImpl klausService;

    UUID uuid;
    MockedMessage mockedMessage1;
    Map<String, String> httpHeaders;
    MockedMessageDto mockedMessageDto1;
    MockedMessageDto mockedMessageDto2;
    MockedMessageDto mockedMessageDto3;
    List<MockedMessage> mockedMessageList = new ArrayList<>();

    @BeforeEach
    void setUp() {
        uuid = UUID.randomUUID();
        httpHeaders = new HashMap<>();
        mockedMessageDto1 = MockedMessageDto.builder()
                .clientUUID(uuid)
                .mockedResponseId(323)
                .mediaType(MediaType.APPLICATION_JSON)
                .messageBody("it's okey to be gey")
                .httpHeaders(httpHeaders)
                .httpStatus(200)
                .build();

        mockedMessageDto2 = MockedMessageDto.builder()
                .clientUUID(uuid)
                .mockedResponseId(3123)
                .mediaType(MediaType.APPLICATION_JSON)
                .messageBody("some random message")
                .httpHeaders(httpHeaders)
                .httpStatus(404)
                .build();

        mockedMessageDto3 = MockedMessageDto.builder()
                .clientUUID(uuid)
                .mockedResponseId(3233)
                .mediaType(MediaType.APPLICATION_XML)
                .messageBody("loooking good")
                .httpHeaders(httpHeaders)
                .httpStatus(205)
                .build();

        mockedMessage1 = new MockedMessage();
        mockedMessageList.add(mockedMessage1);
        mockedMessageList.add(mockedMessage1);
        mockedMessageList.add(mockedMessage1);
    }

    @Test
    void deleteMockedResponse() {
        klausService.deleteMockedResponse(uuid, 323);
        verify(mockedResponseRepository).deleteById(any());
    }

    @Test
    void getAllMockedResponses() {
        when(mockedResponseRepository.findAllByClientUUID(any()))
                .thenReturn(mockedMessageList);

        assertThat(klausService.getAllMockedResponses(uuid), hasSize(3));
        verify(mockedResponseRepository).findAllByClientUUID(any());
    }

    @Test
    void getMockedResponse() {
        when(mockedResponseRepository.getByCompositePrimaryKey(any()))
                .thenReturn(mockedMessage1);

        assertThat(klausService.getMockedResponse(uuid, 323)).isNotNull();
        verify(mockedResponseRepository).findById(any());
    }

    @Test
    void setMockedResponse() {
        klausService.setMockedResponse(mockedMessageDto1);

        verify(mockedResponseRepository).save(any());
    }


    @AfterEach
    void tearDown() { reset(mockedResponseRepository); }

}