package cd.casic.server;

import cd.casic.ci.process.dto.req.resource.ResourceReq;
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);
//    }


}
