package de.mummeit.pmg.service.config;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import de.mummeit.pmg.api.model.integration.DomainIntegration;
import de.mummeit.pmg.api.model.integration.Integration;
import de.mummeit.pmg.service.PermissionManager;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.List;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class AbstractPermissionManagerConfigurationTest {

    @Mock
    private PermissionManager permissionManager;

    @Mock
    private ResourceLoader resourceLoader;

    @Mock
    private ObjectMapper objectMapper;

    @Mock
    private Resource resource;

    @Mock
    private ApplicationReadyEvent event;

    private TestPermissionManagerConfiguration configuration;

    @BeforeEach
    void setUp() {
        configuration = new TestPermissionManagerConfiguration(
            permissionManager,
            resourceLoader,
            objectMapper
        );
    }

    @Test
    @DisplayName("should perform programmatic integrations on startup")
    void shouldPerformProgrammaticIntegrationsOnStartup() {
        // Given
        List<Integration<?>> integrations = Collections.singletonList(
            DomainIntegration.builder()
                .id("1")
                .action(Integration.Action.create)
                .data(DomainIntegration.Data.builder()
                    .name("test")
                    .description("test")
                    .build())
                .build()
        );
        configuration.setProgrammaticIntegrations(integrations);

        // When
        configuration.performIntegrationsOnStartup();

        // Then
        verify(permissionManager).performIntegration(integrations);
        verify(resourceLoader, never()).getResource(any());
    }

    @Test
    @DisplayName("should perform JSON integrations on startup")
    void shouldPerformJsonIntegrationsOnStartup() throws IOException {
        // Given
        List<Integration<?>> integrations = Collections.singletonList(
            DomainIntegration.builder()
                .id("1")
                .action(Integration.Action.create)
                .data(DomainIntegration.Data.builder()
                    .name("test")
                    .description("test")
                    .build())
                .build()
        );

        configuration.setProgrammaticIntegrations(null);
        configuration.setJsonPath("classpath:integrations.json");

        when(resourceLoader.getResource("classpath:integrations.json")).thenReturn(resource);
        when(resource.getInputStream()).thenReturn(new ByteArrayInputStream("[]".getBytes()));
        doReturn(integrations).when(objectMapper).readValue(any(InputStream.class), any(TypeReference.class));

        // When
        configuration.performIntegrationsOnStartup();

        // Then
        verify(permissionManager).performIntegration(integrations);
        verify(resourceLoader).getResource("classpath:integrations.json");
    }

    @Test
    @DisplayName("should handle no integrations gracefully")
    void shouldHandleNoIntegrationsGracefully() {
        // Given
        configuration.setProgrammaticIntegrations(null);
        configuration.setJsonPath(null);

        // When
        configuration.performIntegrationsOnStartup();

        // Then
        verify(permissionManager, never()).performIntegration(any());
        verify(resourceLoader, never()).getResource(any());
    }

    private static class TestPermissionManagerConfiguration extends AbstractPermissionManagerConfiguration {
        private List<Integration<?>> programmaticIntegrations;
        private String jsonPath;

        public TestPermissionManagerConfiguration(
            PermissionManager permissionManager,
            ResourceLoader resourceLoader,
            ObjectMapper objectMapper
        ) {
            super(permissionManager, resourceLoader, objectMapper);
        }

        public void setProgrammaticIntegrations(List<Integration<?>> integrations) {
            this.programmaticIntegrations = integrations;
        }

        public void setJsonPath(String path) {
            this.jsonPath = path;
        }

        @Override
        protected List<Integration<?>> getIntegrations() {
            return programmaticIntegrations;
        }

        @Override
        protected String getIntegrationsJsonPath() {
            return jsonPath;
        }
    }
}