package com.adrian.reservapp.

model;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Optional;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mapstruct.factory.Mappers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import com.adrian.reservapp.model.dto.ReservationDTO;
import com.adrian.reservapp.model.dto.ReservationFullDTO;
import com.adrian.reservapp.model.entities.ReservationTableEntity;
import com.adrian.reservapp.model.entities.ReservationTimeEntity;
import com.adrian.reservapp.model.entities.ReservationsEntity;
import com.adrian.reservapp.model.entities.TableEntity;
import com.adrian.reservapp.model.mapper.Mapeador;
import com.adrian.reservapp.model.repositories.ReservationsRepository;
import com.adrian.reservapp.model.repositories.ReservationsTableRepository;
import com.adrian.reservapp.model.repositories.ReservationsTimeRepository;
import com.adrian.reservapp.model.repositories.TableRepository;
import com.adrian.reservapp.model.serviceImpl.ReservationsServiceImpl;
import com.adrian.reservapp.model.test.utils.CommonLibTestUtils;
import com.adrian.reservapp.model.utils.CommonLibUtils;
import com.adrian.reservapp.model.utils.ConstantsUtils;
import com.adrian.reservapp.model.utils.ReservationTimeUtilsService;

@ExtendWith(MockitoExtension.class)
public class ReservationServiceUnitTest {

@Mock
private ReservationsRepository repo;

@Mock
private ReservationsTableRepository reservationTableRepo;
@Mock
private TableRepository tableRepository;

@Mock
private ReservationsTimeRepository reservationTimeRepository;

@Mock
private ReservationTimeUtilsService reservationTimeService;

@InjectMocks
private ReservationsServiceImpl reservationsService;

private Mapeador mapper = Mappers.getMapper(Mapeador.class);

 @Test
public void recuperarAllReservations() throws Exception {
List<ReservationsEntity> listaReservas = listaReservas();
when(repo.findAll()).thenReturn(listaReservas);

List<ReservationDTO> reservas = reservationsService.listAll();

for (int i = 0; i < reservas.size(); i++) {

Assertions.assertEquals(reservas.get(i), reservas.get(i));
}
}

@Test
public void recuperarReservaByReservationNumber() {
ReservationsEntity reserva = crearReservaTest();

when(repo.findByReservationNumber(reserva.getReservationNumber())).thenReturn(Optio
nal.of(reserva));

ReservationFullDTO reservaResponse =
reservationsService.buscarReserva(reserva.getReservationNumber());

CommonLibTestUtils.comprobarDatosReservationsFull2Entity(reservaResponse,
reserva);
}

@Test
public void altaReserva() throws Exception {
ReservationTimeEntity mockReservationTime = new ReservationTimeEntity();
mockReservationTime.setTime("20:00");

List<TableEntity> mockTableEntity = createListTableEntity();

ReservationsEntity reserva = crearReservaTest();

ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

when(reservationTimeService.getReservationTime(reserva.getReservationTime().getTime
())).thenReturn(mockReservationTime);

when(tableRepository.getTotalCapacity()).thenReturn(36);
when(repo.findByReservationDateAndReservationTime(any(),
any())).thenReturn(Collections.emptyList());
when(repo.existsByReservationNumber(any())).thenReturn(false);
when(tableRepository.findAll()).thenReturn(mockTableEntity);

when(tableRepository.findByIdTableIn(any())).thenReturn(mockTableEntity);
when(repo.save(any(ReservationsEntity.class))).thenAnswer(invocation ->
invocation.getArgument(0));

when(reservationTableRepo.save(any(ReservationTableEntity.class))).thenAnswer(invoc
ation -> invocation.getArgument(0));

ReservationFullDTO reservaGuardada =
reservationsService.altaReserva(nuevaReserva);
 CommonLibTestUtils.comprobarDatosReservationsFull2Entity(reservaGuardada,
reserva);
}

private List<TableEntity> createListTableEntity() {

List<TableEntity> tables = new ArrayList<>();

int[] capacities = {4, 4, 4, 6, 6, 8, 8};

for (int capacity : capacities) {

TableEntity table = new TableEntity();
table.setCapacity(capacity);
tables.add(table);
}

return tables;
}

@Test
public void altaReserva_ThrowsExceptionEmailNull() {
ReservationsEntity reserva = CommonLibUtils.crearReservaEntity(23, null,
"Raul", "123", "lactosa", "info", 4,
"2024-08-03", "20:00", "ABCD1234EFGH5678IJKL");
ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

Exception exception = Assertions.assertThrows(Exception.class, () -> {

reservationsService.altaReserva(nuevaReserva);
});

String expectedMessage = ConstantsUtils.EMAIL_CANNOT_BE_NULL;

String actualMessage = exception.getMessage();

Assertions.assertTrue(actualMessage.contains(expectedMessage));
}

@Test
public void altaReserva_ThrowsExceptionNumberClientsNull() {
ReservationsEntity reserva = CommonLibUtils.crearReservaEntity(23,
"email1", "Raul", "123", "lactosa", "info",
null, "2024-08-03", "20:00", "ABCD1234EFGH5678IJKL");
ReservationTimeEntity mockReservationTime =
mock(ReservationTimeEntity.class);
when(mockReservationTime.getTime()).thenReturn("20:00");
reserva.setReservationTime(mockReservationTime);
ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

Exception exception = Assertions.assertThrows(Exception.class, () -> {

reservationsService.altaReserva(nuevaReserva);
});

String expectedMessage = ConstantsUtils.NUMBER_CLIENTS_CANNOT_BE_NULL;

String actualMessage = exception.getMessage();

Assertions.assertTrue(actualMessage.contains(expectedMessage));
}
 @Test
public void altaReserva_ThrowsExceptionPhoneNumberNull() {
ReservationsEntity reserva = createEntityAndSetTime(23, "email1", "Raul",
null, "lactosa", "info", 4,
"2024-08-03", "20:00", "ABCD1234EFGH5678IJKL");
ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

Exception exception = Assertions.assertThrows(Exception.class, () -> {

reservationsService.altaReserva(nuevaReserva);
});

String expectedMessage = ConstantsUtils.PHONE_NUMBER_CANNOT_BE_NULL;

String actualMessage = exception.getMessage();

Assertions.assertTrue(actualMessage.contains(expectedMessage));
}

@Test
public void altaReserva_ThrowsExceptionReservationDateNull() {
ReservationsEntity reserva = createEntityAndSetTime(23, "email1", "Raul",
"123", "lactosa", "info", 4, null,
"20:00", "ABCD1234EFGH5678IJKL");
ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

Exception exception = Assertions.assertThrows(Exception.class, () -> {

reservationsService.altaReserva(nuevaReserva);
});

String expectedMessage = ConstantsUtils.RESERVATION_DATE_CANNOT_BE_NULL;

String actualMessage = exception.getMessage();

Assertions.assertTrue(actualMessage.contains(expectedMessage));
}

@Test
public void altaReserva_ThrowsExceptionReservationTimeNull() {
ReservationsEntity reserva = createEntityAndSetTime(23, "email1", "Raul",
"123", "lactosa", "info", 4,
"2024-08-03", null, "ABCD1234EFGH5678IJKL");
ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

Exception exception = Assertions.assertThrows(Exception.class, () -> {

reservationsService.altaReserva(nuevaReserva);
});

String expectedMessage = ConstantsUtils.RESERVATION_TIME_CANNOT_BE_NULL;

String actualMessage = exception.getMessage();

Assertions.assertTrue(actualMessage.contains(expectedMessage));
}

@Test
public void altaReserva_ThrowsExceptionReservationTimeNotValid() {
ReservationsEntity reserva = createEntityAndSetTime(23, "email1", "Raul",
"123", "lactosa", "info", 4,
 "2024-08-03", "17:28", "ABCD1234EFGH5678IJKL");
ReservationDTO nuevaReserva =
mapper.reservationEntity2ReservationDTO(reserva);

when(reservationTimeService.getReservationTime(reserva.getReservationTime().getTime
())).thenThrow(new
IllegalArgumentException(ConstantsUtils.INVALID_RESERVATION_TIME));

Exception exception =
Assertions.assertThrows(IllegalArgumentException.class, () -> {
reservationsService.altaReserva(nuevaReserva);
});

String expectedMessage = ConstantsUtils.INVALID_RESERVATION_TIME;

String actualMessage = exception.getMessage();

Assertions.assertTrue(actualMessage.contains(expectedMessage));
}

private ReservationsEntity createEntityAndSetTime(Integer idReservation, String

email, String name,
String phoneNumber, String
intolerances, String reservationInfo, Integer numberClients,
String reservationDate,
String reservationTime, String reservationNumber) {

ReservationsEntity reserva =
CommonLibUtils.crearReservaEntity(idReservation, email, name, phoneNumber,
intolerances, reservationInfo, numberClients, reservationDate,
reservationTime, reservationNumber);
ReservationTimeEntity mockReservationTime =
mock(ReservationTimeEntity.class);
when(mockReservationTime.getTime()).thenReturn(reservationTime);
reserva.setReservationTime(mockReservationTime);
return reserva;
}

private ReservationsEntity crearReservaTest() {

return createEntityAndSetTime(23, "email1", "Raul", "123", "lactosa",
"info", 4, "2024-08-03",
"20:00", "ABCD1234EFGH5678IJKL");
}
private List<ReservationsEntity> listaReservas() {
return Arrays.asList(crearReservaTest(),
createEntityAndSetTime(24, "email2", "Raul", "123",
"lactosa", "info", 4, "2024-08-13",
"12:30", "ABCD1234EFGH5699IJKL"),
createEntityAndSetTime(25, "email3", "Alejandro", "7777",
"gluten", "info", 5, "2024-08-05",
"14:00", "YZAB1234CDEF5678GHIJ"));
}
}