package ru.kirkazan.rmis.app.stocks.impl.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 ru.kirkazan.common.exception.CodifiedException;
import ru.kirkazan.rmis.app.organization.model.OrganizationCode;
import ru.kirkazan.rmis.app.organization.service.OrganizationService;
import ru.kirkazan.rmis.app.stocks.api.model.Clinic;
import ru.kirkazan.rmis.app.stocks.impl.entity.ClinicEntity;

import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.persistence.TypedQuery;

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

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class TestClinicService {

    @InjectMocks
    private ClinicServiceImpl clinicService;

    @Mock
    private EntityManager entityManager;

    @Mock
    private OrganizationService organizationService;

    private static final Integer CLINIC_ID = 1;

    @Before
    public void setUp() throws Exception {
        ClinicEntity clinicEntity = new ClinicEntity();
        clinicEntity.setId(CLINIC_ID);
        when(entityManager.getReference(ClinicEntity.class, CLINIC_ID)).thenReturn(clinicEntity);
        TypedQuery mockQuery = mock(TypedQuery.class);
        when(entityManager.createQuery(anyString(), any())).thenReturn(mockQuery);
        when(mockQuery.setParameter(anyString(), any())).thenReturn(mockQuery);

    }

    @Test
    public void testSaveNewClinic() throws Exception {
        Clinic newClinic = getClinic();
        clinicService.saveClinic(newClinic);
        verify(entityManager).persist(any(ClinicEntity.class));
        verify(organizationService).save(newClinic);
    }

    @Test
    public void testSaveExistedClinic() throws Exception {
        Clinic clinic = getClinic();
        clinic.setId(CLINIC_ID);
        clinicService.saveClinic(clinic);
        verify(entityManager).getReference(ClinicEntity.class, clinic.getId());
        verify(organizationService).save(clinic);
    }

    @Test(expected = CodifiedException.class)
    public void testSaveSameClinic() throws Exception {
        List<Clinic> clinics=new ArrayList<>();
        clinics.add(getClinic());
        TypedQuery mockQuery = mock(TypedQuery.class);
        when(entityManager.createQuery(anyString(), any())).thenReturn(mockQuery);
        when(mockQuery.getResultList()).thenReturn(clinics);
        when(mockQuery.setParameter(anyString(), any())).thenReturn(mockQuery);
        Clinic clinic = getClinic();
        clinicService.saveClinic(clinic);
    }

    private Clinic getClinic() {
        Clinic clinic = new Clinic();
        clinic.setFullName("testFullName");
        clinic.setShortName("testShortName");
        clinic.setCode("testCode");
        return clinic;
    }
}