package projekt.test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasItems;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;

import projekt.dummy.ClientFaker;
import projekt.dummy.OrderFaker;
import projekt.model.Client;
import projekt.model.ShopOrder;
import projekt.repository.ClientRepository;
import projekt.repository.ItemRepository;
import projekt.repository.OrderRepository;

@RunWith(MockitoJUnitRunner.class)
public class OrderMockTest {

	@Mock
	private ClientRepository clientRepository;

	@Mock
	private ItemRepository itemRepository;

	@Mock
	private OrderRepository orderRepository;

	@Before
	public void setup() {
		MockitoAnnotations.initMocks(this);
	}

	@Test
	public void testMockFindAll() {
		List<Client> clients = new ArrayList<>();
		clients.add(ClientFaker.createClient1());
		clients.add(ClientFaker.createClient3());

		when(clientRepository.findAll()).thenReturn(clients);
		assertThat(clients, equalTo(clientRepository.findAll()));
	}

	@Test
	public void testMockingEquals() {
		Comparable<Client> c = mock(Client.class);
		// -2 normalnie nie mogloby byc zwrocone
		when(c.compareTo(new Client("Seba", "Testowy"))).thenReturn(-2);

		assertEquals(-2, c.compareTo(new Client("Seba", "Testowy")));
	}

	@Test
	public void testIfClientsExist() {

		when(orderRepository.findById(1)).thenReturn(OrderFaker.createOrder1());

		List<Client> mockClients = new LinkedList<>();
		mockClients.add(ClientFaker.createClient1());
		mockClients.add(ClientFaker.createClient3());
		when(clientRepository.findAll()).thenReturn(mockClients);

		assertThat(mockClients, hasItems(orderRepository.findById(1).getClient()));

	}

	@Test
	public void testIfClientHasMoreThanOneOrder() {

		List<ShopOrder> mockOrders = new ArrayList<>();
		mockOrders.add(OrderFaker.createOrder1());
		mockOrders.add(OrderFaker.createOrder3());

		when(orderRepository.findByClientId(1)).thenReturn(mockOrders);

		assertThat(2, is(orderRepository.findByClientId(1).size()));
	}

	@Test
	public void testHowManyItemsClientBought() {

		List<ShopOrder> mockOrders = new ArrayList<>();
		mockOrders.add(OrderFaker.createOrder1());
		mockOrders.add(OrderFaker.createOrder3());
		when(orderRepository.findByClientId(1)).thenReturn(mockOrders);

		int sum = orderRepository.findByClientId(1).stream().mapToInt(x -> x.getItems().size()).sum();
		assertThat(4, is(sum));
	}

	@Test
	public void testItemsOfOrder() {
		when(orderRepository.findById(3)).thenReturn(OrderFaker.createOrder2());

		assertThat(3, is(orderRepository.findById(3).getItems().size()));
	}

	@Test
	public void testCostOfOrders() {
		List<ShopOrder> mockOrders = new ArrayList<>();
		mockOrders.add(OrderFaker.createOrder1());
		mockOrders.add(OrderFaker.createOrder3());
		when(orderRepository.findByClientId(4)).thenReturn(mockOrders);

		assertThat(100, not(orderRepository.findByClientId(4).stream().mapToLong(x -> x.getCost()).sum()));
	}

}