package cd.casic.server;

import cd.casic.ci.process.dto.req.resource.ResourceReq;
import cd.casic.ci.process.dto.resp.resource.ResourceFindResp;
import cd.casic.ci.process.process.converter.ResourceConverter;
import cd.casic.ci.process.process.dao.pipeline.PipResourceCloudDao;
import cd.casic.ci.process.process.dao.pipeline.PipResourceK8SDao;
import cd.casic.ci.process.process.dao.pipeline.PipResourceMachineDao;
import cd.casic.ci.process.process.dao.pipeline.PipResourceManagerDao;
import cd.casic.ci.process.process.dataObject.resource.PipResourceCloud;
import cd.casic.ci.process.process.dataObject.resource.PipResourceK8S;
import cd.casic.ci.process.process.dataObject.resource.PipResourceMachine;
import cd.casic.ci.process.process.dataObject.resource.PipResourceManager;
import cd.casic.ci.process.process.service.resource.impl.ResourceManagerServiceImpl;
import cd.casic.module.execute.docker.dao.DockerEndpointDao;
import cd.casic.module.execute.docker.dataobject.dto.DockerEndpointDo;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.ActiveProfiles;

import static org.junit.jupiter.api.Assertions.assertNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.*;

@SpringBootTest(classes = {OpsServerApplication.class})
@ActiveProfiles("local")
@Slf4j
public class ResourceTest {
    @Autowired
    private ResourceManagerServiceImpl resourceManagerService;

    @MockBean
    private PipResourceManagerDao pipResourceManagerDao;

    @MockBean
    private PipResourceMachineDao machineDao;

    @MockBean
    private PipResourceK8SDao k8SDao;

    @MockBean
    private DockerEndpointDao dockerEndpointDao;

    @MockBean
    private PipResourceCloudDao cloudDao;

    @MockBean
    private ResourceConverter resourceConverter;

    @Test
    void testCreateResourceWithMachine() {
        // Arrange
        ResourceReq resourceReq = new ResourceReq();
        PipResourceMachine resourceMachine = new PipResourceMachine();
        resourceMachine.setId("machineId");
        resourceReq.setResourceMachine(resourceMachine);

        when(machineDao.insert(any(PipResourceMachine.class))).thenAnswer(invocation -> {
            PipResourceMachine machine = invocation.getArgument(0);
            machine.setId("machineId"); // 模拟插入后生成ID
            return null;
        });

        when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
            PipResourceManager manager = invocation.getArgument(0);
            manager.setId("resourceId"); // 模拟插入后生成ID
            return null;
        });

        // Act
        String result = resourceManagerService.createResource(resourceReq);

        // Assert
        verify(machineDao, times(1)).insert(any(PipResourceMachine.class));
        verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));

        // 验证返回的ID
        assert result.equals("resourceId");
    }

    @Test
    void testCreateResourceWithK8s() {
        // Arrange
        ResourceReq resourceReq = new ResourceReq();
        PipResourceK8S pipResourceK8S = new PipResourceK8S();
        pipResourceK8S.setId("k8sId");
        resourceReq.setPipResourceK8S(pipResourceK8S);

        when(k8SDao.insert(any(PipResourceK8S.class))).thenAnswer(invocation -> {
            PipResourceK8S k8s = invocation.getArgument(0);
            k8s.setId("k8sId"); // 模拟插入后生成ID
            return null;
        });

        when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
            PipResourceManager manager = invocation.getArgument(0);
            manager.setId("resourceId"); // 模拟插入后生成ID
            return null;
        });

        // Act
        String result = resourceManagerService.createResource(resourceReq);

        // Assert
        verify(k8SDao, times(1)).insert(any(PipResourceK8S.class));
        verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));

        // 验证返回的ID
        assert result.equals("resourceId");
    }

    @Test
    void testCreateResourceWithDocker() {
        // Arrange
        ResourceReq resourceReq = new ResourceReq();
        DockerEndpointDo dockerEndpoint = new DockerEndpointDo();
        dockerEndpoint.setId("dockerId");
        resourceReq.setDockerEndpoint(dockerEndpoint);

        when(dockerEndpointDao.insert(any(DockerEndpointDo.class))).thenAnswer(invocation -> {
            DockerEndpointDo endpoint = invocation.getArgument(0);
            endpoint.setId("dockerId"); // 模拟插入后生成ID
            return null;
        });

        when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
            PipResourceManager manager = invocation.getArgument(0);
            manager.setId("resourceId"); // 模拟插入后生成ID
            return null;
        });

        // Act
        String result = resourceManagerService.createResource(resourceReq);

        // Assert
        verify(dockerEndpointDao, times(1)).insert(any(DockerEndpointDo.class));
        verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));

        // 验证返回的ID
        assert result.equals("resourceId");
    }

    @Test
    void testCreateResourceWithCloud() {
        // Arrange
        ResourceReq resourceReq = new ResourceReq();
        PipResourceCloud pipResourceCloud = new PipResourceCloud();
        pipResourceCloud.setId("cloudId");
        resourceReq.setPipResourceCloud(pipResourceCloud);

        when(cloudDao.insert(any(PipResourceCloud.class))).thenAnswer(invocation -> {
            PipResourceCloud cloud = invocation.getArgument(0);
            cloud.setId("cloudId"); // 模拟插入后生成ID
            return null;
        });

        when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
            PipResourceManager manager = invocation.getArgument(0);
            manager.setId("resourceId"); // 模拟插入后生成ID
            return null;
        });

        // Act
        String result = resourceManagerService.createResource(resourceReq);

        // Assert
        verify(cloudDao, times(1)).insert(any(PipResourceCloud.class));
        verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));

        // 验证返回的ID
        assert result.equals("resourceId");
    }



    @Test
    void testDeleteResource_WithAllSubResources() {
        // Arrange
        String resourceId = "res123";
        PipResourceManager pipResourceManager = new PipResourceManager();
        pipResourceManager.setId(resourceId);
        pipResourceManager.setMachineId("machine123");
        pipResourceManager.setK8sId("k8s123");
        pipResourceManager.setDockerId("docker123");
        pipResourceManager.setCloudId("cloud123");

        Mockito.when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);

        // Act
        resourceManagerService.deleteResource(resourceId);

        // Assert
        Mockito.verify(machineDao, Mockito.times(1)).deleteById("machine123");
        Mockito.verify(k8SDao, Mockito.times(1)).deleteById("k8s123");
        Mockito.verify(dockerEndpointDao, Mockito.times(1)).deleteById("docker123");
        Mockito.verify(cloudDao, Mockito.times(1)).deleteById("cloud123");
        Mockito.verify(pipResourceManagerDao, Mockito.times(1)).deleteById(resourceId);
    }

    @Test
    void testDeleteResource_WithOnlyMachineResource() {
        // Arrange
        String resourceId = "res123";
        PipResourceManager pipResourceManager = new PipResourceManager();
        pipResourceManager.setId(resourceId);
        pipResourceManager.setMachineId("machine123");

        Mockito.when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);

        // Act
        resourceManagerService.deleteResource(resourceId);

        // Assert
        Mockito.verify(machineDao, Mockito.times(1)).deleteById("machine123");
        Mockito.verify(k8SDao, never()).deleteById(anyString());
        Mockito.verify(dockerEndpointDao, never()).deleteById(anyString());
        Mockito.verify(cloudDao, never()).deleteById(anyString());
        Mockito.verify(pipResourceManagerDao, Mockito.times(1)).deleteById(resourceId);
    }

    @Test
    void testDeleteResource_ResourceNotFound() {
        // Arrange
        String resourceId = "nonExistent";

        Mockito.when(pipResourceManagerDao.selectById(resourceId)).thenReturn(null);

        // Act & Assert
        try {
            resourceManagerService.deleteResource(resourceId);
        } catch (Exception e) {
            // Expect no exception, just skip deletion
        }

        Mockito.verify(machineDao, never()).deleteById(anyString());
        Mockito.verify(k8SDao, never()).deleteById(anyString());
        Mockito.verify(dockerEndpointDao, never()).deleteById(anyString());
        Mockito.verify(cloudDao, never()).deleteById(anyString());
        Mockito.verify(pipResourceManagerDao, never()).deleteById(anyString());
    }


    @Test
    void testDeleteResourceWithAllSubResources() {
        // Arrange
        String resourceId = "resourceId";
        PipResourceManager pipResourceManager = new PipResourceManager();
        pipResourceManager.setId(resourceId);
        pipResourceManager.setMachineId("machineId");
        pipResourceManager.setK8sId("k8sId");
        pipResourceManager.setDockerId("dockerId");
        pipResourceManager.setCloudId("cloudId");

        when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);

        // Act
        resourceManagerService.deleteResource(resourceId);

        // Assert
        verify(pipResourceManagerDao, times(1)).selectById(resourceId);
        verify(machineDao, times(1)).deleteById("machineId");
        verify(k8SDao, times(1)).deleteById("k8sId");
        verify(dockerEndpointDao, times(1)).deleteById("dockerId");
        verify(cloudDao, times(1)).deleteById("cloudId");
        verify(pipResourceManagerDao, times(1)).deleteById(resourceId);
    }

    @Test
    void testDeleteResourceWithOnlyMachine() {
        // Arrange
        String resourceId = "resourceId";
        PipResourceManager pipResourceManager = new PipResourceManager();
        pipResourceManager.setId(resourceId);
        pipResourceManager.setMachineId("machineId");

        when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);

        // Act
        resourceManagerService.deleteResource(resourceId);

        // Assert
        verify(pipResourceManagerDao, times(1)).selectById(resourceId);
        verify(machineDao, times(1)).deleteById("machineId");
        verify(k8SDao, never()).deleteById(anyString());
        verify(dockerEndpointDao, never()).deleteById(anyString());
        verify(cloudDao, never()).deleteById(anyString());
        verify(pipResourceManagerDao, times(1)).deleteById(resourceId);
    }

    @Test
    void testDeleteResourceWithNoSubResources() {
        // Arrange
        String resourceId = "resourceId";
        PipResourceManager pipResourceManager = new PipResourceManager();
        pipResourceManager.setId(resourceId);

        when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);

        // Act
        resourceManagerService.deleteResource(resourceId);

        // Assert
        verify(pipResourceManagerDao, times(1)).selectById(resourceId);
        verify(machineDao, never()).deleteById(anyString());
        verify(k8SDao, never()).deleteById(anyString());
        verify(dockerEndpointDao, never()).deleteById(anyString());
        verify(cloudDao, never()).deleteById(anyString());
        verify(pipResourceManagerDao, times(1)).deleteById(resourceId);
    }



    @Test
    void testFindResourceById_ResourceExists() {

        ResourceFindResp resourceById = resourceManagerService.findResourceById("1");

        assertNull(resourceById);
    }


}