package org.legrog.web.publisher;

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import org.legrog.entities.Country;
import org.legrog.entities.Publisher;
import org.legrog.entities.PublisherVersion;
import org.legrog.test.MockitoExtension;
import org.legrog.web.xyz.SharedService;
import org.mockito.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.when;

/**
 * Classe testant PublisherVersionView.
 */
@RunWith(JUnitPlatform.class)
@ExtendWith(MockitoExtension.class)
@DisplayName("Creates new versions of a publisher, and shows existing with history of actions on it")
public class PublisherVersionViewTest {
    Logger logger = LoggerFactory.getLogger(getClass());

    private PublisherVersionView publisherVersionView;

    private PublisherVersion publisherVersion;
    private PublisherService publisherService;
    private SharedService sharedService;

    @Mock
    PublisherVersion publisherVersionMock;

    @BeforeEach
    public void setUp(@Mock PublisherService publisherService, @Mock SharedService sharedService) throws Exception {
        this.publisherService = publisherService;
        this.sharedService = sharedService;
        publisherVersionView = new PublisherVersionView(publisherService, sharedService);
        publisherVersionView.setEditMode(false);
        publisherVersionView.setNewPublisher(false);

        publisherVersion = new PublisherVersion();
        publisherVersion.setPublisherName("A");
        publisherVersion.setPublisherStreetAddress("B");
        publisherVersion.setPublisherPostalCode("C");
        publisherVersion.setPublisherPostOfficeBoxNumber("D");
        publisherVersion.setPublisherAddressRegion("E");
        publisherVersion.setPublisherAddressLocality("F");
        publisherVersion.setPublisherAddressCountry(new Country());
        publisherVersion.setPublisherTelephone("G");
        publisherVersion.setPublisherEmail("H");
        publisherVersion.setPublisherURL("I");
        publisherVersion.setPublisherHistory("J");
        publisherVersion.setPublisher(new Publisher());

        when(publisherService.getPublisherVersion(1)).thenReturn(publisherVersion);

    }

    @Test
    @DisplayName("when constructed, should have right dependencies : Shared Service and Publisher Service")
    public void testDependencies() {
        assertThat(publisherVersionView).isNotNull();
        assertThat(publisherVersionView.publisherService).isEqualTo(publisherService);
        assertThat(publisherVersionView.sharedService).isEqualTo(sharedService);
    }

    @DisplayName("when edit is clicked, should switch to edit mode")
    @Test
    public void testEdit() {
        assertThat(publisherVersionView.isEditMode()).isFalse();
        publisherVersionView.edit();
        assertThat(publisherVersionView.isEditMode()).isTrue();
    }

    @DisplayName("when cancel is clicked for an new publisher, should clean new form data and switch to non-edit mode")
    @Test
    public void testCancelNewPublisher() {
        publisherVersionView.setNewPublisher(true);

        publisherVersionView.cancel();

        assertThat(publisherVersionView.getPublisherName()).isNull();
        assertThat(publisherVersionView.getStreetAddress()).isNull();
        assertThat(publisherVersionView.getPostalCode()).isNull();
        assertThat(publisherVersionView.getPostOfficeBoxNumber()).isNull();
        assertThat(publisherVersionView.getAddressRegion()).isNull();
        assertThat(publisherVersionView.getAddressLocality()).isNull();
        assertThat(publisherVersionView.getTelephone()).isNull();
        assertThat(publisherVersionView.getEmail()).isNull();
        assertThat(publisherVersionView.getuRL()).isNull();
        assertThat(publisherVersionView.getPublisherHistory()).isNull();
        assertThat(publisherVersionView.isEditMode()).isTrue();
    }

    @DisplayName("whan cancel is clicked for a publisher update, should revert to original data and switch to non-edit mode")
    @Test
    public void testCancelNewVersionOfPublisher() {
        publisherVersionView.setNewPublisher(false);
        publisherVersionView.setStringId("1");

        publisherVersionView.setPublisherName("1");
        publisherVersionView.setStreetAddress("2");
        publisherVersionView.setPostalCode("3");
        publisherVersionView.setPostOfficeBoxNumber("4");
        publisherVersionView.setAddressRegion("5");
        publisherVersionView.setAddressLocality("6");
        publisherVersionView.setPublisherAddressCountry(new Country());
        publisherVersionView.setTelephone("7");
        publisherVersionView.setEmail("8");
        publisherVersionView.setuRL("9");
        publisherVersionView.setPublisherHistory("10");

        publisherVersionView.cancel();

        assertThat(publisherVersionView.getPublisherName()).isEqualTo("A");
        assertThat(publisherVersionView.getStreetAddress()).isEqualTo("B");
        assertThat(publisherVersionView.getPostalCode()).isEqualTo("C");
        assertThat(publisherVersionView.getPostOfficeBoxNumber()).isEqualTo("D");
        assertThat(publisherVersionView.getAddressRegion()).isEqualTo("E");
        assertThat(publisherVersionView.getAddressLocality()).isEqualTo("F");
        assertThat(publisherVersionView.getTelephone()).isEqualTo("G");
        assertThat(publisherVersionView.getEmail()).isEqualTo("H");
        assertThat(publisherVersionView.getuRL()).isEqualTo("I");
        assertThat(publisherVersionView.getPublisherHistory()).isEqualTo("J");
        assertThat(publisherVersionView.isEditMode()).isFalse();

    }

    @Nested
    @DisplayName("init method")
    class LoadDataTests{

        @Test
        @DisplayName("Loads all actions on it")
        public void testLoadActions(@Mock PublisherService publisherService) {
            publisherVersionView.setStringId("1");
            publisherVersionView.init();
            Mockito.verify(publisherService).getAllPublisherVersionActions(publisherVersion);
        }

        @Test
        @DisplayName("when called for existing publisher, should get the rigtht data into the form")
        public void testLoadData() {
            publisherVersionView.setNewPublisher(true);
            publisherVersionView.setStringId("1");
            publisherVersionView.init();
            assertThat(publisherVersionView.getPublisherName()).isEqualTo("A");
            assertThat(publisherVersionView.getStreetAddress()).isEqualTo("B");
            assertThat(publisherVersionView.getPostalCode()).isEqualTo("C");
            assertThat(publisherVersionView.getPostOfficeBoxNumber()).isEqualTo("D");
            assertThat(publisherVersionView.getAddressRegion()).isEqualTo("E");
            assertThat(publisherVersionView.getAddressLocality()).isEqualTo("F");
            assertThat(publisherVersionView.getTelephone()).isEqualTo("G");
            assertThat(publisherVersionView.getEmail()).isEqualTo("H");
            assertThat(publisherVersionView.getuRL()).isEqualTo("I");
            assertThat(publisherVersionView.getPublisherHistory()).isEqualTo("J");
            assertThat(publisherVersionView.isNewPublisher()).isFalse();
        }

        @Test
        @DisplayName("when called for new publisher, should set form for new version")
        public void testLoadDataEmpty() {
            publisherVersionView.setNewPublisher(false);
            publisherVersionView.setStringId("0");
            publisherVersionView.init();
            assertThat(publisherVersionView.isNewPublisher()).isTrue();
            assertThat(publisherVersionView.isEditMode()).isTrue();
        }

    }

    @Nested
    @DisplayName("getImmutableValues method")
    class GetImmutableValuesTests{
        @BeforeEach
        @DisplayName("given a way to get a null")
        public void given(@Mock PublisherService publisherService) {
            when(publisherService.addNewPublisher(any())).thenReturn(publisherVersionMock);
            when(publisherVersionMock.getPublisherVersionId()).thenReturn(2);
            when(publisherService.getPublisherVersion(2)).thenReturn(null);
        }
        @Test
        @DisplayName("throws an IllegalStateException")
        public void testUnexcpetedNull() {
            assertThrows(IllegalStateException.class, () -> publisherVersionView.add());
        }
    }

    @Nested
    @DisplayName("save method")
    class SaveTests{
        PublisherVersionView publisherVersionViewForSave;
        public boolean addCalled = false;
        public boolean updateCalled = false;

        @BeforeEach
        public void given() {
            publisherVersionViewForSave = new PublisherVersionView() {

                @Override
                public void add() {
                    addCalled = true;
                }

                @Override
                public void update() {
                    updateCalled = true;
                }

            };
        }

        @Test
        @DisplayName("when view is for a new publisher, should delegate to add() method")
        public void testSaveAdd() {
            publisherVersionViewForSave.setNewPublisher(true);
            publisherVersionViewForSave.save();
            assertThat(addCalled).isTrue();
        }

        @Test
        @DisplayName("when view is not for a new publisher, should delegate to update() method")
        public void testSaveUpdate() {
            publisherVersionViewForSave.setNewPublisher(false);
            publisherVersionViewForSave.save();
            assertThat(updateCalled).isTrue();
        }

    }

    @Nested
    @DisplayName("post construct method")
    class Init {

        private List<Country> countries;

        @BeforeEach
        public void setUp(@Mock SharedService sharedService) {
            when(sharedService.getAllCountries()).thenReturn(countries);
        }

        @Test
        @DisplayName("should set lists of available masks, account roles, and account properties from shared service")
        public void testList(@Mock SharedService sharedService) {
            publisherVersionView.init();
            assertThat(publisherVersionView.getAvailableCountries()).isEqualTo(countries);
        }
    }

    @Nested
    @DisplayName("Update method")
    class UpdateTests {

        @BeforeEach
        public void given(@Mock Publisher publisherMock) {
            publisherVersionView.setNewPublisher(false);

            publisherVersionView.setPublisherName("1");
            publisherVersionView.setStreetAddress("2");
            publisherVersionView.setPostalCode("3");
            publisherVersionView.setPostOfficeBoxNumber("4");
            publisherVersionView.setAddressRegion("5");
            publisherVersionView.setAddressLocality("6");
            publisherVersionView.setPublisherAddressCountry(new Country());
            publisherVersionView.setTelephone("7");
            publisherVersionView.setEmail("8");
            publisherVersionView.setuRL("9");
            publisherVersionView.setPublisherHistory("10");
            publisherVersionView.setPublisher(publisherMock);
        }

        @Nested
        @DisplayName("given some input fields")
        class Given {

            @Captor
            ArgumentCaptor<PublisherVersion> publisherVersionArgumentCaptor;

            @Captor
            ArgumentCaptor<Publisher> publisherArgumentCaptor;

            @BeforeEach
            public void test(@Mock PublisherService publisherService, @Mock Publisher publisherMock, @Mock PublisherVersion publisherVersionMock) {
                // mock de l'appel dans Immutables values
                when(publisherService.getPublisherVersion(anyInt())).thenReturn(new PublisherVersion());

                when(publisherService.addVersionToPublisher(any(Publisher.class), any(PublisherVersion.class))).thenReturn(publisherVersionMock);
                when(publisherVersionMock.getPublisher()).thenReturn(publisherMock);
                when(publisherVersionMock.getPublisherVersionId()).thenReturn(13);

                publisherVersionView.update();
            }

            @DisplayName("should add a new version to a publisher")
            @Test
            public void shouldAddNewVersion(@Mock PublisherService publisherService) {
                Mockito.verify(publisherService).addVersionToPublisher(publisherArgumentCaptor.capture(), publisherVersionArgumentCaptor.capture());
                PublisherVersion capturedPublisherVersion = publisherVersionArgumentCaptor.getValue();
                assertThat(capturedPublisherVersion.getPublisherName()).isEqualTo("1");
            }

            @DisplayName("should put state in non edit mode")
            @Test
            public void shouldNonEdit() {
                assertThat(publisherVersionView.isEditMode()).isFalse();
            }

            @DisplayName("should put state in non new publisher with new ids")
            @Test
            public void shouldNonNewPublisher(@Mock Publisher publisherMock) {

                assertThat(publisherVersionView.isNewPublisher()).isFalse();
                assertThat(publisherVersionView.getPublisher()).isEqualTo(publisherMock);
                assertThat(publisherVersionView.getPublisherVersionId()).isEqualTo(13);
            }

        }

    }

    @Nested
    @DisplayName("Add method")
    class AddTests {

        @BeforeEach
        public void given(@Mock Publisher publisherMock) {
            publisherVersionView.setNewPublisher(true);

            publisherVersionView.setPublisherName("A");
            publisherVersionView.setStreetAddress("B");
            publisherVersionView.setPostalCode("C");
            publisherVersionView.setPostOfficeBoxNumber("D");
            publisherVersionView.setAddressRegion("E");
            publisherVersionView.setAddressLocality("F");
            publisherVersionView.setPublisherAddressCountry(new Country());
            publisherVersionView.setTelephone("G");
            publisherVersionView.setEmail("H");
            publisherVersionView.setuRL("I");
            publisherVersionView.setPublisherHistory("J");
            publisherVersionView.setPublisher(publisherMock);
        }

        @Nested
        @DisplayName("given some input fields")
        class Given {

            @Captor
            ArgumentCaptor<PublisherVersion> publisherVersionArgumentCaptor;

            @BeforeEach
            public void test(@Mock PublisherService publisherService, @Mock Publisher publisherMock, @Mock PublisherVersion publisherVersionMock) {
                // mock de l'appel dans Immutables values
                when(publisherService.getPublisherVersion(anyInt())).thenReturn(new PublisherVersion());


                when(publisherService.addNewPublisher(any(PublisherVersion.class))).thenReturn(publisherVersionMock);
                when(publisherVersionMock.getPublisher()).thenReturn(publisherMock);
                when(publisherVersionMock.getPublisherVersionId()).thenReturn(42);
                publisherVersionView.add();
            }

            @DisplayName("should create a new publisher in the application with its first version")
            @Test
            public void shouldSave(@Mock PublisherService publisherService) {
                Mockito.verify(publisherService).addNewPublisher(publisherVersionArgumentCaptor.capture());
                PublisherVersion capturedPublisherVersion = publisherVersionArgumentCaptor.getValue();
                assertThat(capturedPublisherVersion.getPublisherName()).isEqualTo("A");
            }


            @DisplayName("should put state in non edit mode")
            @Test
            public void shouldNonEdit() {
                assertThat(publisherVersionView.isEditMode()).isFalse();
            }

            @DisplayName("should put state in non new publisher with new ids")
            @Test
            public void shouldNonNewPublisher(@Mock Publisher publisherMock) {

                assertThat(publisherVersionView.isNewPublisher()).isFalse();
                assertThat(publisherVersionView.getPublisher()).isEqualTo(publisherMock);
                assertThat(publisherVersionView.getPublisherVersionId()).isEqualTo(42);
            }

        }

    }

}