package rest.entities;

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;

import javax.transaction.Transactional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mchange.v2.sql.filter.SynchronizedFilterDataSource;

import dao.entities.DMPDao;
import dao.entities.DMPProfileDao;
import dao.entities.DataRepositoryDao;
import dao.entities.DatasetDao;
import dao.entities.DatasetProfileDao;
import dao.entities.DatasetProfileRulesetDao;
import dao.entities.DatasetProfileViewstyleDao;
import dao.entities.OrganisationDao;
import dao.entities.ProjectDao;
import dao.entities.RegistryDao;
import dao.entities.ResearcherDao;
import dao.entities.ServiceDao;
import dao.entities.UserInfoDao;
import entities.DMP;
import entities.DMPProfile;
import entities.Dataset;
import entities.DatasetProfile;
import entities.DatasetProfileRuleset;
import entities.Project;
import entities.UserInfo;
import entities.responses.IDLabelPair;
import helpers.SerializerProvider;
import helpers.Transformers;
import responses.RestResponse;


@RestController
@CrossOrigin
public class DMPs  {
	
	@Autowired private DataRepositoryDao dataRepositoryDao;
	@Autowired private DatasetDao datasetDao;
	@Autowired private DatasetProfileDao datasetProfileDao;
	@Autowired private DatasetProfileRulesetDao datasetProfileRulesetDao;
	@Autowired private DatasetProfileViewstyleDao datasetProfileViewstyleDao;
	@Autowired private DMPDao dMPDao;
	@Autowired private DMPProfileDao dMPProfileDao;
	@Autowired private OrganisationDao organisationDao;
	@Autowired private ProjectDao projectDao;
	@Autowired private RegistryDao registryDao;
	@Autowired private ResearcherDao researcherDao;
	@Autowired private ServiceDao serviceDao;
	@Autowired private UserInfoDao userInfoDao;
	

	private ObjectMapper objectMapper = SerializerProvider.getJsonSerializer();

	
	// FETCH BY DMP(S)
	
	@RequestMapping(method = RequestMethod.GET, value = { "/dmps" }, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> listDMPs(){
		try {
			List<UUID> allIDs = dMPDao.listAllIDs();
			return ResponseEntity.status(HttpStatus.OK).body(objectMapper.writeValueAsString(allIDs));
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
	}

	@RequestMapping(method = RequestMethod.GET, value = { "/dmps/{id}" }, produces="application/json")
	public @ResponseBody ResponseEntity<Object> getDMP(@PathVariable("id") String id){
		try {
			DMP dmp = dMPDao.read(UUID.fromString(id));
			return ResponseEntity.status(HttpStatus.OK).body(objectMapper.writeValueAsString(dmp));
		}
		catch(Exception ex) {
			ex.printStackTrace();
			return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Erroneous input: "+ex.getMessage());
		}
	}

	@RequestMapping(method = RequestMethod.GET, value = { "/dmp/listDMPLabelID" }, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> listDmpLabelID(){
		try {
			List<IDLabelPair> allIDLabels = dMPDao.listAllIDsLabels();
			return ResponseEntity.status(HttpStatus.OK).body(objectMapper.writeValueAsString(allIDLabels));
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
	}
	
	
	/**
	 * This should be called on extreme cases. It's computationally intensive
	 */
	@RequestMapping(method = RequestMethod.GET, value = { "/dmp/getAll" }, produces="application/json")
	public @ResponseBody ResponseEntity<Object> getAllDMPs(){
		
		try {
			List<DMP> allDMPs = dMPDao.getAll();
			
			//sorry for that, spring-jersey serialisation has issues when performed on tables, so -> custom 
			List<String> dmpStrL = allDMPs.parallelStream().map((dmpObj) -> {
				try {
					return objectMapper.writeValueAsString(dmpObj);
				} catch (JsonProcessingException e) {
					return "";
				}
			}).collect(Collectors.toList());
			
			return new ResponseEntity<Object>("["+String.join(",", dmpStrL)+"]", HttpStatus.OK);
			
		}
		catch(Exception ex) {
			ex.printStackTrace();
			return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
		}
	}
	
	
	@Transactional
	@RequestMapping(method = RequestMethod.POST, value = { "/dmp/create" }, consumes = "application/json", produces="application/json")
	public @ResponseBody ResponseEntity<Object> createDMP(@RequestBody DMP dmp) {
		DMP createdDmp = dMPDao.update(dmp);
		try {
			return ResponseEntity.status(HttpStatus.CREATED).body(objectMapper.writeValueAsString(createdDmp));
		} catch (JsonProcessingException e) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"msg\":\"Could not create DMP!\"");
		}
		
	}
	
	@Transactional
	@RequestMapping(method = RequestMethod.POST, value = { "/dmp/update" }, consumes = "application/json", produces="application/json")
	public @ResponseBody ResponseEntity<Object> updateDMP(@RequestBody DMP dmp) {
		DMP updatedDMP = dMPDao.update(dmp);
		try {
			return ResponseEntity.status(HttpStatus.CREATED).body(objectMapper.writeValueAsString(updatedDMP));
		} catch (JsonProcessingException e) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"msg\":\"Could not update DMP!\"");
		}
		
	}
	
	
	/*
	@RequestMapping(method = RequestMethod.POST, value = { "/dmp/set/full" }, consumes = "application/json", produces="application/json")
	public @ResponseBody ResponseEntity<Object> setFullDMP(@RequestBody DMP dmp) {
		
		//This function is a little bit tricky to implement (due to the irregular ORM mappings of the hibernate).
		// Please make changes only if you are sure about what you're altering.
		
		Dataset dataset = SerializationUtils.clone(dmp.getDataset());
		
		dmp.setDataset(null);
		
		int failsDMP = 0;
		String reasonDmp = "";
		DMP storedDMP = null;
		//try first to create DMP
		try {
			storedDMP = dMPDao.create(dmp);
		}
		catch(Exception e) {
			e.printStackTrace();
			failsDMP++;
			reasonDmp += e.getMessage();
			//try updating DMP
			try {
				storedDMP = dMPDao.update(dmp);
			}
			catch(Exception ex) {
				reasonDmp += (System.lineSeparator()+e.getMessage());
				failsDMP++;
				ex.printStackTrace();
			}
		}
		
		if(failsDMP==2)
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Could not create or update DMP! Reason: " + reasonDmp);
		
		dataset.setDmp(storedDMP); //very important!
		
		int failsDataset = 0;
		String reasonDataset = "";
		Dataset storedDataset = null;
		if(dataset != null) {
			//try first to create DMP
			try {
				storedDataset = datasetDao.create(dataset);
			}
			catch(Exception e) {
				e.printStackTrace();
				failsDataset++;
				reasonDataset += e.getMessage();
				//try updating DMP
				try {
					storedDataset = datasetDao.update(dataset);
				}
				catch(Exception ex) {
					reasonDataset += (System.lineSeparator()+e.getMessage());
					failsDataset++;
					ex.printStackTrace();
				}
			}
		}
		
		String respBody;
		try {
			respBody = objectMapper.writeValueAsString(storedDMP.getId());
		}
		catch(JsonProcessingException ex) { 
			respBody = "{\"id\":\""+storedDMP.getId()+"\"}";
		}
		
		if(failsDataset != 2) {
			if(failsDMP==0)
				return ResponseEntity.status(HttpStatus.CREATED).body(respBody);
			else if(failsDMP==1)
				return ResponseEntity.status(HttpStatus.CREATED).body("Updated DMP with id: " + storedDMP.getId());
			else
				return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Could not create DMP! Reason:"+ reasonDmp);
		}
		else {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Could not create DMP! Failed to create or update its Dataset. Reason: "+reasonDataset);
		}

		
	}
	
	*/
	
	
	
	@RequestMapping(method = RequestMethod.POST, value = { "/dmp/getdatasets" }, consumes = "application/json", produces="application/json")
	public @ResponseBody ResponseEntity<Object> getDatasetsOfDMP(@RequestBody DMP dmp) {
		Set<Dataset> datasets = dMPDao.read(dmp.getId()).getDataset();
		try {
			return ResponseEntity.status(HttpStatus.OK).body(objectMapper.writeValueAsString(datasets));
		} catch (JsonProcessingException e) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"msg\":\"Could not get datasets of DMP!\"");
		}
		
	}
	
	
	
	@RequestMapping(method = RequestMethod.POST, value = { "/dmp/delete" }, consumes = "application/json", produces="text/plain")
	public @ResponseBody ResponseEntity<Object> delete(@RequestBody DMP dmp) {
		
		DMP d = new DMP();
		d.setId(dmp.getId());
		try {
			dMPDao.delete(d);
			return ResponseEntity.status(HttpStatus.CREATED).body("DELETED!");
		} catch (Exception e) {
			e.printStackTrace();
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"msg\":\"Could not Delete DMP!\"");
		}
		
	}
	
	
	
	
	////////////////////////////////
	//// USER - RELATED ACTIONS ////
	////////////////////////////////
	
	@RequestMapping(method = RequestMethod.GET, value = { "/dmp/getofuser" }, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> getDmpsOfUser(){
		
		String userID = null;
		try {
			userID = SecurityContextHolder.getContext().getAuthentication().getPrincipal().toString();
		} catch(NullPointerException ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("You have not logged in. You shouldn't be here");
		}
		
		UserInfo userInfo = userInfoDao.read(UUID.fromString(userID));
		
		if(userInfo==null) //this should normally never happer
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("There's no such a user on the system. You shouldn't be here");
		
		try {
			Set<DMP> userDMPs = new HashSet<DMP>();
			
			userInfo.getProjects().forEach(project -> {
				userDMPs.addAll(project.getDmps());
			});
			
			return ResponseEntity.status(HttpStatus.OK).body(objectMapper.writeValueAsString(userDMPs));	
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
		
	}
	
	@RequestMapping(method = RequestMethod.GET, value = { "/dmp/createforproject" }, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> createDmpOfProject(@RequestParam("projectid") String projectid, @RequestBody DMP dmp){
		
		UUID projIdUuid;
		try {
			projIdUuid = UUID.fromString(projectid);
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.NOT_MODIFIED).body("Did not specify an id or id was not valid... Could not do anything");
		}
		
		
		try {
			dmp.setId(null);
			dmp = dMPDao.create(dmp);
			
			Project project = projectDao.read(projIdUuid);			
			
			Set<DMP> dmps = project.getDmps();
			if(dmps == null) 
				dmps = new HashSet<DMP>();
			dmps.add(dmp);
			project.setDmps(dmps);
			
			project = projectDao.update(project);
			
			return ResponseEntity.status(HttpStatus.OK).body(objectMapper.writeValueAsString(dmp));	
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
		
	}
	
	
	
	
	
	
}