/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package com.epam.dlab.backendapi.service.impl;

import com.epam.dlab.auth.UserInfo;
import com.epam.dlab.backendapi.dao.ExploratoryDAO;
import com.epam.dlab.backendapi.dao.ExploratoryLibDAO;
import com.epam.dlab.backendapi.dao.ImageExploratoryDao;
import com.epam.dlab.backendapi.domain.EndpointDTO;
import com.epam.dlab.backendapi.domain.ProjectDTO;
import com.epam.dlab.backendapi.resources.dto.ImageInfoRecord;
import com.epam.dlab.backendapi.service.EndpointService;
import com.epam.dlab.backendapi.service.ProjectService;
import com.epam.dlab.backendapi.util.RequestBuilder;
import com.epam.dlab.cloud.CloudProvider;
import com.epam.dlab.dto.UserInstanceDTO;
import com.epam.dlab.dto.exploratory.ExploratoryImageDTO;
import com.epam.dlab.dto.exploratory.ExploratoryStatusDTO;
import com.epam.dlab.dto.exploratory.ImageStatus;
import com.epam.dlab.dto.exploratory.LibStatus;
import com.epam.dlab.exceptions.DlabException;
import com.epam.dlab.exceptions.ResourceAlreadyExistException;
import com.epam.dlab.exceptions.ResourceNotFoundException;
import com.epam.dlab.model.ResourceType;
import com.epam.dlab.model.exploratory.Image;
import com.epam.dlab.model.library.Library;
import com.epam.dlab.rest.client.RESTService;
import com.mongodb.client.result.UpdateResult;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import java.util.Collections;
import java.util.List;
import java.util.Optional;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.anyVararg;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class ImageExploratoryServiceImplTest {

	private final String USER = "test";
	private final String TOKEN = "token";
	private final String EXPLORATORY_NAME = "expName";
	private final String PROJECT = "project";

	private UserInfo userInfo;
	private UserInstanceDTO userInstance;
	private Image image;

	@Mock
	private ExploratoryDAO exploratoryDAO;
	@Mock
	private ImageExploratoryDao imageExploratoryDao;
	@Mock
	private ExploratoryLibDAO libDAO;
	@Mock
	private RESTService provisioningService;
	@Mock
	private RequestBuilder requestBuilder;
	@Mock
	private EndpointService endpointService;
	@Mock
	private ProjectService projectService;

	@InjectMocks
	private ImageExploratoryServiceImpl imageExploratoryService;

	@Rule
	public ExpectedException expectedException = ExpectedException.none();

	@Before
	public void setUp() {
		userInfo = getUserInfo();
		userInstance = getUserInstanceDto();
		image = fetchImage();
	}

	@Test
	public void createImage() {
		when(projectService.get(anyString())).thenReturn(getProjectDTO());
		when(exploratoryDAO.fetchRunningExploratoryFields(anyString(), anyString(), anyString())).thenReturn(userInstance);
		when(imageExploratoryDao.exist(anyString(), anyString())).thenReturn(false);

		when(libDAO.getLibraries(anyString(), anyString(), anyString())).thenReturn(Collections.singletonList(getLibrary()));
		doNothing().when(imageExploratoryDao).save(any(Image.class));
		when(exploratoryDAO.updateExploratoryStatus(any(ExploratoryStatusDTO.class)))
				.thenReturn(mock(UpdateResult.class));
		ExploratoryImageDTO eiDto = new ExploratoryImageDTO();
		when(endpointService.get(anyString())).thenReturn(endpointDTO());
		when(requestBuilder.newExploratoryImageCreate(any(UserInfo.class), any(UserInstanceDTO.class), anyString(),
				any(EndpointDTO.class), any(ProjectDTO.class))).thenReturn(eiDto);

		String expectedUuid = "someUuid";
		when(provisioningService.post(anyString(), anyString(), any(ExploratoryImageDTO.class), any()))
				.thenReturn(expectedUuid);

		String imageName = "someImageName", imageDescription = "someDescription";
		String actualUuid = imageExploratoryService.createImage(userInfo, PROJECT, EXPLORATORY_NAME,
				imageName, imageDescription);
		assertNotNull(actualUuid);
		assertEquals(expectedUuid, actualUuid);

		verify(projectService).get(PROJECT);
		verify(exploratoryDAO).fetchRunningExploratoryFields(USER, PROJECT, EXPLORATORY_NAME);
		verify(exploratoryDAO).updateExploratoryStatus(any(ExploratoryStatusDTO.class));
		verify(imageExploratoryDao).exist(imageName, PROJECT);
		verify(imageExploratoryDao).save(any(Image.class));
		verify(libDAO).getLibraries(USER, PROJECT, EXPLORATORY_NAME);
		verify(requestBuilder).newExploratoryImageCreate(userInfo, userInstance, imageName, endpointDTO(), getProjectDTO());
		verify(endpointService).get(anyString());
		verify(provisioningService).post(endpointDTO().getUrl() + "exploratory/image", TOKEN, eiDto, String.class);
		verifyNoMoreInteractions(projectService, exploratoryDAO, imageExploratoryDao, libDAO, requestBuilder, endpointService, provisioningService);
	}

	@Test
	public void createImageWhenMethodFetchRunningExploratoryFieldsThrowsException() {
		doThrow(new DlabException("Running exploratory instance for user with name not found."))
				.when(exploratoryDAO).fetchRunningExploratoryFields(anyString(), anyString(), anyString());

		String imageName = "someImageName", imageDescription = "someDescription";

		try {
			imageExploratoryService.createImage(userInfo, PROJECT, EXPLORATORY_NAME, imageName, imageDescription);
		} catch (DlabException e) {
			assertEquals("Running exploratory instance for user with name not found.", e.getMessage());
		}
		verify(exploratoryDAO).fetchRunningExploratoryFields(USER, PROJECT, EXPLORATORY_NAME);
		verifyNoMoreInteractions(exploratoryDAO);
	}

	@Test
	public void createImageWhenResourceAlreadyExists() {
		when(exploratoryDAO.fetchRunningExploratoryFields(anyString(), anyString(), anyString())).thenReturn(userInstance);
		when(imageExploratoryDao.exist(anyString(), anyString())).thenReturn(true);

		expectedException.expect(ResourceAlreadyExistException.class);
		expectedException.expectMessage("Image with name someImageName is already exist");

		String imageName = "someImageName", imageDescription = "someDescription";
		imageExploratoryService.createImage(userInfo, PROJECT, EXPLORATORY_NAME, imageName, imageDescription);
	}

	@Test
	public void createImageWhenMethodNewExploratoryImageCreateThrowsException() {
		when(projectService.get(anyString())).thenReturn(getProjectDTO());
		when(exploratoryDAO.fetchRunningExploratoryFields(anyString(), anyString(), anyString())).thenReturn(userInstance);
		when(imageExploratoryDao.exist(anyString(), anyString())).thenReturn(false);

		when(libDAO.getLibraries(anyString(), anyString(), anyString())).thenReturn(Collections.singletonList(getLibrary()));
		doNothing().when(imageExploratoryDao).save(any(Image.class));
		when(exploratoryDAO.updateExploratoryStatus(any(ExploratoryStatusDTO.class)))
				.thenReturn(mock(UpdateResult.class));
		doThrow(new DlabException("Cannot create instance of resource class")).when(requestBuilder)
				.newExploratoryImageCreate(any(UserInfo.class), any(UserInstanceDTO.class), anyString(), any(EndpointDTO.class), any(ProjectDTO.class));
		when(endpointService.get(anyString())).thenReturn(endpointDTO());

		String imageName = "someImageName", imageDescription = "someDescription";
		try {
			imageExploratoryService.createImage(userInfo, PROJECT, EXPLORATORY_NAME, imageName, imageDescription);
		} catch (DlabException e) {
			assertEquals("Cannot create instance of resource class", e.getMessage());
		}

		verify(projectService).get(PROJECT);
		verify(exploratoryDAO).fetchRunningExploratoryFields(USER, PROJECT, EXPLORATORY_NAME);
		verify(exploratoryDAO).updateExploratoryStatus(any(ExploratoryStatusDTO.class));
		verify(imageExploratoryDao).exist(imageName, PROJECT);
		verify(imageExploratoryDao).save(any(Image.class));
		verify(libDAO).getLibraries(USER, PROJECT, EXPLORATORY_NAME);
		verify(requestBuilder).newExploratoryImageCreate(userInfo, userInstance, imageName, endpointDTO(), getProjectDTO());
		verify(endpointService).get(anyString());
		verifyNoMoreInteractions(projectService, exploratoryDAO, imageExploratoryDao, libDAO, requestBuilder, endpointService);
	}

	@Test
	public void finishImageCreate() {
		when(exploratoryDAO.updateExploratoryStatus(any(ExploratoryStatusDTO.class)))
				.thenReturn(mock(UpdateResult.class));
		doNothing().when(imageExploratoryDao).updateImageFields(any(Image.class));
		doNothing().when(exploratoryDAO).updateExploratoryIp(anyString(), anyString(), anyString(), anyString());

		String notebookIp = "someIp";
		imageExploratoryService.finishImageCreate(image, EXPLORATORY_NAME, notebookIp);

		verify(exploratoryDAO).updateExploratoryStatus(any(ExploratoryStatusDTO.class));
		verify(exploratoryDAO).updateExploratoryIp(USER, PROJECT, notebookIp, EXPLORATORY_NAME);
		verify(imageExploratoryDao).updateImageFields(image);
		verifyNoMoreInteractions(exploratoryDAO, imageExploratoryDao);
	}

	@Test
	public void finishImageCreateWhenMethodUpdateExploratoryIpThrowsException() {
		when(exploratoryDAO.updateExploratoryStatus(any(ExploratoryStatusDTO.class)))
				.thenReturn(mock(UpdateResult.class));
		doNothing().when(imageExploratoryDao).updateImageFields(any(Image.class));
		doThrow(new ResourceNotFoundException("Exploratory for user with name not found"))
				.when(exploratoryDAO).updateExploratoryIp(anyString(), anyString(), anyString(), anyString());

		String notebookIp = "someIp";
		try {
			imageExploratoryService.finishImageCreate(image, EXPLORATORY_NAME, notebookIp);
		} catch (ResourceNotFoundException e) {
			assertEquals("Exploratory for user with name not found", e.getMessage());
		}

		verify(exploratoryDAO).updateExploratoryStatus(any(ExploratoryStatusDTO.class));
		verify(exploratoryDAO).updateExploratoryIp(USER, PROJECT, notebookIp, EXPLORATORY_NAME);
		verify(imageExploratoryDao).updateImageFields(image);
		verifyNoMoreInteractions(exploratoryDAO, imageExploratoryDao);
	}

	@Test
	public void finishImageCreateWhenNotebookIpIsNull() {
		when(exploratoryDAO.updateExploratoryStatus(any(ExploratoryStatusDTO.class)))
				.thenReturn(mock(UpdateResult.class));
		doNothing().when(imageExploratoryDao).updateImageFields(any(Image.class));

		imageExploratoryService.finishImageCreate(image, EXPLORATORY_NAME, null);

		verify(exploratoryDAO).updateExploratoryStatus(any(ExploratoryStatusDTO.class));
		verify(exploratoryDAO, never()).updateExploratoryIp(USER, PROJECT, null, EXPLORATORY_NAME);
		verify(imageExploratoryDao).updateImageFields(image);
		verifyNoMoreInteractions(exploratoryDAO, imageExploratoryDao);
	}

	@Test
	public void getCreatedImages() {
		ImageInfoRecord imageInfoRecord = getImageInfoRecord();
		List<ImageInfoRecord> expectedRecordList = Collections.singletonList(imageInfoRecord);
		when(imageExploratoryDao.getImages(anyString(), anyString(), anyString(), anyString(), anyVararg()))
				.thenReturn(expectedRecordList);

		List<ImageInfoRecord> actualRecordList = imageExploratoryService.getNotFailedImages(USER,
				"someImage", "someProject", "someEndpoint");
		assertNotNull(actualRecordList);
		assertEquals(1, actualRecordList.size());
		assertEquals(expectedRecordList, actualRecordList);

		verify(imageExploratoryDao).getImages(USER, "someImage", "someProject", "someEndpoint", ImageStatus.CREATED, ImageStatus.CREATING);
		verifyNoMoreInteractions(imageExploratoryDao);
	}

	@Test
	public void getImage() {
		ImageInfoRecord expectedImageInfoRecord = getImageInfoRecord();
		when(imageExploratoryDao.getImage(anyString(), anyString(), anyString(), anyString()))
				.thenReturn(Optional.of(expectedImageInfoRecord));

		ImageInfoRecord actualImageInfoRecord = imageExploratoryService.getImage(USER, "someName", "someProject", "someEndpoint");
		assertNotNull(actualImageInfoRecord);
		assertEquals(expectedImageInfoRecord, actualImageInfoRecord);

		verify(imageExploratoryDao).getImage(USER, "someName", "someProject", "someEndpoint");
		verifyNoMoreInteractions(imageExploratoryDao);
	}

	@Test
	public void getImageWhenMethodGetImageReturnsOptionalEmpty() {
		when(imageExploratoryDao.getImage(anyString(), anyString(), anyString(), anyString())).thenReturn(Optional.empty());
		expectedException.expect(ResourceNotFoundException.class);
		expectedException.expectMessage(String.format("Image with name %s was not found for user %s",
				"someImageName", USER));
		imageExploratoryService.getImage(USER, "someImageName", "someProject", "someEndpoint");
	}

	@Test
	public void getImagesForProject() {
		when(imageExploratoryDao.getImagesForProject(anyString())).thenReturn(Collections.singletonList(getImageInfoRecord()));

		imageExploratoryService.getImagesForProject(PROJECT);

		verify(imageExploratoryDao).getImagesForProject(PROJECT);
		verifyNoMoreInteractions(imageExploratoryDao);
	}

	private ImageInfoRecord getImageInfoRecord() {
		return new ImageInfoRecord("someName", "someDescription", "someProject", "someEndpoint", "someUser", "someApp",
				"someFullName", ImageStatus.CREATED);
	}

	private Image fetchImage() {
		return Image.builder()
				.name("someImageName")
				.description("someDescription")
				.status(ImageStatus.CREATING)
				.user(USER)
				.project(PROJECT)
				.libraries(Collections.singletonList(getLibrary()))
				.computationalLibraries(Collections.emptyMap())
				.dockerImage("someImageName")
				.exploratoryId("explId").build();
	}

	private Library getLibrary() {
		return new Library("someGroup", "someName", "someVersion", LibStatus.INSTALLED,
				"someErrorMessage").withType(ResourceType.EXPLORATORY);
	}

	private UserInstanceDTO getUserInstanceDto() {
		return new UserInstanceDTO()
				.withUser(USER)
				.withExploratoryName(EXPLORATORY_NAME)
				.withExploratoryId("explId")
				.withProject(PROJECT);
	}

	private UserInfo getUserInfo() {
		return new UserInfo(USER, TOKEN);
	}

	private EndpointDTO endpointDTO() {
		return new EndpointDTO("test", "url", "", null, EndpointDTO.EndpointStatus.ACTIVE, CloudProvider.AWS);
	}

	private ProjectDTO getProjectDTO() {
		return ProjectDTO.builder().name(PROJECT).build();
	}
}