package de.aikiit.bilanzanalyser.upload;
   
   import de.aikiit.bilanzanalyser.entity.BilanzRow;
   import de.aikiit.bilanzanalyser.entity.database.BilanzRowEntity;
   import de.aikiit.bilanzanalyser.entity.database.CategoryEntity;
   import de.aikiit.bilanzanalyser.entity.database.PaymentEntity;
   import de.aikiit.bilanzanalyser.entity.database.ShopEntity;
   import de.aikiit.bilanzanalyser.entity.database.SourceEntity;
   import de.aikiit.bilanzanalyser.entity.database.repository.BilanzRowRepository;
  import de.aikiit.bilanzanalyser.entity.database.repository.CategoryRepository;
  import de.aikiit.bilanzanalyser.entity.database.repository.PaymentRepository;
  import de.aikiit.bilanzanalyser.entity.database.repository.ShopRepository;
  import de.aikiit.bilanzanalyser.entity.database.repository.SourceRepository;
  import de.aikiit.bilanzanalyser.reader.BilanzRowParserResult;
  import org.junit.jupiter.api.Test;
  import org.junit.jupiter.api.extension.ExtendWith;
  import org.mockito.InjectMocks;
  import org.mockito.Mock;
  import org.mockito.junit.jupiter.MockitoExtension;
  import org.springframework.dao.DataIntegrityViolationException;
  
  import java.math.BigDecimal;
  import java.time.LocalDate;
  import java.util.List;
  import java.util.Optional;
  
  import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  @ExtendWith(MockitoExtension.class)
  class UploadAnalysisServiceTest {
  
      @Mock
      private BilanzRowRepository bilanzRowRepository;
      @Mock
      private ShopRepository shopRepository;
      @Mock
      private PaymentRepository paymentRepository;
      @Mock
      private CategoryRepository categoryRepository;
      @Mock
      private SourceRepository sourceRepository;
  
      @InjectMocks
      private UploadAnalysisService service;
  
      @Test
      void getOrCreatePayment_shouldHandleConcurrentInsert() {
          when(paymentRepository.findByName("Cards")).thenReturn(Optional.empty())  // first call
                  .thenReturn(Optional.of(new PaymentEntity())); // retry
  
          when(paymentRepository.save(any())).thenThrow(DataIntegrityViolationException.class);
  
          PaymentEntity result = service.getOrCreatePayment("Cards");
  
          assertThat(result).isNotNull();
          // called twice due to concurrent insert
          verify(paymentRepository, times(2)).findByName("Cards");
      }
  
      @Test
      void replaceIfEmpty_shouldReplaceNullAndBlank() {
          assertThat(service.replaceIfEmpty(null)).isEqualTo("<empty>");
          assertThat(service.replaceIfEmpty(" ")).isEqualTo("<empty>");
          assertThat(service.replaceIfEmpty("   value  ")).isEqualTo("value");
      }
  
      @Test
      void flushDataIntoDatabase_shouldSaveRows() {
          BilanzRow row = mock(BilanzRow.class);
          when(row.getDate()).thenReturn(LocalDate.now());
          when(row.getAmount()).thenReturn(BigDecimal.TEN);
          when(row.getDescription()).thenReturn("desc");
          when(row.getShop()).thenReturn("shop");
          when(row.getPayment()).thenReturn("cash");
          when(row.getCategory()).thenReturn("food");
          when(row.getSource()).thenReturn("app");
  
          BilanzRowParserResult result = mock(BilanzRowParserResult.class);
          when(result.rows()).thenReturn(List.of(row));
  
          when(shopRepository.findByName(any())).thenReturn(Optional.of(new ShopEntity()));
          when(paymentRepository.findByName(any())).thenReturn(Optional.of(new PaymentEntity()));
          when(categoryRepository.findByName(any())).thenReturn(Optional.of(new CategoryEntity()));
          when(sourceRepository.findByName(any())).thenReturn(Optional.of(new SourceEntity()));
  
          service.flushDataIntoDatabase(result);
  
          verify(bilanzRowRepository).save(any(BilanzRowEntity.class));
      }
  }