package de.dlr.shepard.neo4Core.services;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.Collections;
   import java.util.List;
   
   import de.dlr.shepard.influxDB.FillOption;
   import de.dlr.shepard.influxDB.SingleValuedUnaryFunction;
  import de.dlr.shepard.influxDB.Timeseries;
  import de.dlr.shepard.influxDB.TimeseriesPayload;
  import de.dlr.shepard.influxDB.TimeseriesService;
  import de.dlr.shepard.neo4Core.dao.PermissionsDAO;
  import de.dlr.shepard.neo4Core.dao.TimeseriesContainerDAO;
  import de.dlr.shepard.neo4Core.dao.UserDAO;
  import de.dlr.shepard.neo4Core.entities.Permissions;
  import de.dlr.shepard.neo4Core.entities.TimeseriesContainer;
  import de.dlr.shepard.neo4Core.io.TimeseriesContainerIO;
  import de.dlr.shepard.util.DateHelper;
  import de.dlr.shepard.util.PermissionType;
  import de.dlr.shepard.util.QueryParamHelper;
  import lombok.extern.slf4j.Slf4j;
  
  @Slf4j
  public class TimeseriesContainerService implements IContainerService<TimeseriesContainer, TimeseriesContainerIO> {
  
  	private TimeseriesContainerDAO timeseriesContainerDAO = new TimeseriesContainerDAO();
  	private TimeseriesService timeseriesService = new TimeseriesService();
  	private PermissionsDAO permissionsDAO = new PermissionsDAO();
  	private UserDAO userDAO = new UserDAO();
  	private DateHelper dateHelper = new DateHelper();
  
  	/**
  	 * Creates a TimeseriesContainer and stores it in Neo4J
  	 *
  	 * @param timeseriesContainer to be stored
  	 * @param username            of the related user
  	 * @return the created timeseriesContainer
  	 */
  	@Override
  	public TimeseriesContainer createContainer(TimeseriesContainerIO timeseriesContainer, String username) {
  		var user = userDAO.find(username);
  
  		var toCreate = new TimeseriesContainer();
  		toCreate.setCreatedAt(dateHelper.getDate());
  		toCreate.setCreatedBy(user);
  		toCreate.setDatabase(timeseriesService.createDatabase());
  		toCreate.setName(timeseriesContainer.getName());
  
  		var created = timeseriesContainerDAO.createOrUpdate(toCreate);
  		permissionsDAO.createOrUpdate(new Permissions(created, user, PermissionType.Private));
  		return created;
  	}
  
  	/**
  	 * Searches the TimeseriesContainer in Neo4j
  	 *
  	 * @param timeSeriesContainerId identifies the searched TimeseriesContainer
  	 * @return the TimeseriesContainer with matching id or null
  	 */
  	@Override
  	public TimeseriesContainer getContainer(long timeSeriesContainerId) {
  		TimeseriesContainer timeseriesContainer = timeseriesContainerDAO.find(timeSeriesContainerId);
  		if (timeseriesContainer == null || timeseriesContainer.isDeleted()) {
  			log.error("Timeseries Container with id {} is null or deleted", timeSeriesContainerId);
  			return null;
  		}
  		return timeseriesContainer;
  	}
  
  	/**
  	 * Searches the database for all TimeseriesContainers
  	 *
  	 * @param params   QueryParamsHelper
  	 * @param username the name of the user
  	 * @return a list of TimeseriesContainers
  	 */
  	@Override
  	public List<TimeseriesContainer> getAllContainers(QueryParamHelper params, String username) {
  		var containers = timeseriesContainerDAO.findAllTimeseriesContainers(params, username);
  		return containers;
  	}
  
  	/**
  	 * Deletes a TimeseriesContainer in Neo4j
  	 *
  	 * @param timeSeriesContainerId identifies the TimeseriesContainer
  	 * @param username              of the related user
  	 * @return a boolean to determine if TimeseriesContainer was successfully
  	 *         deleted
  	 */
  
  	@Override
  	public boolean deleteContainer(long timeSeriesContainerId, String username) {
  		var user = userDAO.find(username);
  		TimeseriesContainer timeseriesContainer = timeseriesContainerDAO.find(timeSeriesContainerId);
  		if (timeseriesContainer == null) {
  			return false;
  		}
 
 		timeseriesContainer.setDeleted(true);
 		timeseriesContainer.setUpdatedAt(dateHelper.getDate());
 		timeseriesContainer.setUpdatedBy(user);
 		timeseriesContainerDAO.createOrUpdate(timeseriesContainer);
 		timeseriesService.deleteDatabase(timeseriesContainer.getDatabase());
 		return true;
 	}
 
 	/**
 	 * Saves timeseries payload in a timeseries container.
 	 *
 	 * @param timeseriesContainerId identifies the TimeseriesContainer
 	 * @param payload               TimeseriesPayload to be created
 	 * @return created timeseries
 	 */
 	public Timeseries createTimeseries(long timeseriesContainerId, TimeseriesPayload payload) {
 		var timeseriesContainer = timeseriesContainerDAO.find(timeseriesContainerId);
 		if (timeseriesContainer == null || timeseriesContainer.isDeleted()) {
 			log.error("Timeseries Container with id {} is null or deleted", timeseriesContainerId);
 			return null;
 		}
 		var result = timeseriesService.createTimeseries(timeseriesContainer.getDatabase(), payload);
 		if (!result.isBlank()) {
 			log.error("Failed to create timeseries with error: {}", result);
 			return null;
 		}
 		return payload.getTimeseries();
 	}
 
 	/**
 	 * Loads timeseries payload from a timeseries container.
 	 *
 	 * @param timeseriesContainerId identifies the TimeseriesContainer
 	 * @param timeseries            The timeseries to load
 	 * @param start                 The beginning of the timeseries
 	 * @param end                   The end of the timeseries
 	 * @param function              The aggregate function
 	 * @param groupBy               The time interval measurements get grouped by
 	 * @param fillOption            The fill option for missing values
 	 * @return TimeseriesPayload
 	 */
 	public TimeseriesPayload getTimeseriesPayload(long timeseriesContainerId, Timeseries timeseries, long start,
 			long end, SingleValuedUnaryFunction function, Long groupBy, FillOption fillOption) {
 		var timeseriesContainer = timeseriesContainerDAO.findLight(timeseriesContainerId);
 		if (timeseriesContainer == null || timeseriesContainer.isDeleted()) {
 			log.error("Timeseries Container with id {} is null or deleted", timeseriesContainerId);
 			return null;
 		}
 		var result = timeseriesService.getTimeseriesPayload(start, end, timeseriesContainer.getDatabase(), timeseries,
 				function, groupBy, fillOption);
 		return result;
 	}
 
 	/**
 	 * Returns a list of timeseries objects that are in the given database.
 	 *
 	 * @param timeseriesContainerId the given timeseries container
 	 * @return a list of timeseries objects
 	 */
 	public List<Timeseries> getTimeseriesAvailable(long timeseriesContainerId) {
 		var timeseriesContainer = timeseriesContainerDAO.findLight(timeseriesContainerId);
 		if (timeseriesContainer == null || timeseriesContainer.isDeleted()) {
 			log.error("Timeseries Container with id {} is null or deleted", timeseriesContainerId);
 			return Collections.emptyList();
 		}
 		return timeseriesService.getTimeseriesAvailable(timeseriesContainer.getDatabase());
 	}
 
 	public InputStream exportTimeseriesPayload(long timeseriesContainerId, Timeseries timeseries, long start, long end,
 			SingleValuedUnaryFunction function, Long groupBy, FillOption fillOption) throws IOException {
 		var timeseriesContainer = timeseriesContainerDAO.findLight(timeseriesContainerId);
 		if (timeseriesContainer == null || timeseriesContainer.isDeleted()) {
 			log.error("Timeseries Container with id {} is null or deleted", timeseriesContainerId);
 			return null;
 		}
 		var result = timeseriesService.exportTimeseriesPayload(start, end, timeseriesContainer.getDatabase(),
 				List.of(timeseries), function, groupBy, fillOption, Collections.emptySet(), Collections.emptySet(),
 				Collections.emptySet());
 		return result;
 	}
 
 	public boolean importTimeseries(long timeseriesContainerId, InputStream stream) throws IOException {
 		var timeseriesContainer = timeseriesContainerDAO.findLight(timeseriesContainerId);
 		if (timeseriesContainer == null || timeseriesContainer.isDeleted()) {
 			log.error("Timeseries Container with id {} is null or deleted", timeseriesContainerId);
 			return false;
 		}
 		var result = timeseriesService.importTimeseries(timeseriesContainer.getDatabase(), stream);
 		if (!result.isBlank()) {
 			log.error("Failed to import timeseries with error: {}", result);
 			return false;
 		}
 		return true;
 	}
 
 }