package eu.eudat.models.rda.mapper;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import eu.eudat.data.entities.DatasetProfile;
import eu.eudat.elastic.entities.Tag;
import eu.eudat.logic.managers.DatasetManager;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.logic.utilities.json.JsonSearcher;
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
import eu.eudat.models.rda.Dataset;
import eu.eudat.models.rda.Language;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.transaction.Transactional;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Component
public class DatasetRDAMapper {
	private static final Logger logger = LoggerFactory.getLogger(DatasetRDAMapper.class);

	private DatasetManager datasetManager;
	private ApiContext apiContext;

	@Autowired
	public DatasetRDAMapper(DatasetManager datasetManager, ApiContext apiContext) {
		this.datasetManager = datasetManager;
		this.apiContext = apiContext;
	}

	@Transactional
	public Dataset toRDA(eu.eudat.data.entities.Dataset dataset) {
		Dataset rda = new Dataset();
//		rda.setDatasetId(DatasetIdRDAMapper.toRDA(dataset.getId()));
		rda.setTitle(dataset.getLabel());
		rda.setDescription(dataset.getDescription());
		rda.setAdditionalProperty("template", dataset.getProfile().getId());
		try {
			JSONObject jObject = new JSONObject(dataset.getProperties());
			Map<String, Object> templateIdsToValues = jObject.toMap();
			DatasetWizardModel datasetWizardModel = new DatasetWizardModel().fromDataModel(dataset);
			datasetWizardModel.setDatasetProfileDefinition(datasetManager.getPagedProfile(datasetWizardModel, dataset));
			ObjectMapper mapper = new ObjectMapper();
			String datasetDescriptionJson = mapper.writeValueAsString(datasetWizardModel.getDatasetProfileDefinition());
			JsonNode datasetDescriptionObj = mapper.readTree(datasetDescriptionJson);
			List<JsonNode> idNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.dataset_id");
			if (!idNodes.isEmpty()) {
				rda.setDatasetId(DatasetIdRDAMapper.toRDA(idNodes));
			}
			List<JsonNode> typeNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.type");
			if (!typeNodes.isEmpty()) {
				rda.setType(typeNodes.get(0).get("value").asText());
			} else {
				rda.setType(dataset.getLabel());
			}
			List<JsonNode> languageNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.language");
			if (!languageNodes.isEmpty()) {
				rda.setLanguage(Language.fromValue(languageNodes.get(0).get("value").asText()));
			} else {
				rda.setLanguage(LanguageRDAMapper.mapLanguageIsoToRDAIso(dataset.getProfile().getLanguage()));
			}
			List<JsonNode> metadataNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.metadata");
			if (!metadataNodes.isEmpty()) {
				rda.setMetadata(MetadataRDAMapper.toRDAList(metadataNodes));
			}
			List<JsonNode> qaNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.data_quality_assurance");
			if (!qaNodes.isEmpty()) {
				/*rda.setDataQualityAssurance(qaNodes.stream().map(qaNode -> qaNode.get("value").asText()).collect(Collectors.toList()));
				for (int i = 0; i < qaNodes.size(); i++) {
					rda.setAdditionalProperty("qaId" + (i + 1),  qaNodes.get(i).get("id").asText());
				}*/
				rda.setDataQualityAssurance(Collections.singletonList(qaNodes.get(0).get("value").asText()));
			}
			List<JsonNode> preservationNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.preservation_statement");
			if (!preservationNodes.isEmpty()) {
				rda.setPreservationStatement(preservationNodes.get(0).get("value").asText());
			}
			List<JsonNode> distributionNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.distribution");
			if (!distributionNodes.isEmpty()) {
				rda.setDistribution(Collections.singletonList(DistributionRDAMapper.toRDA(distributionNodes)));
			}
			List<JsonNode> keywordNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.keyword");
			if (!keywordNodes.isEmpty()) {
				rda.setKeyword(keywordNodes.stream().map(keywordNode -> keywordNode.get("value").asText()).collect(Collectors.toList()));
				for (int i = 0; i < keywordNodes.size(); i++) {
					rda.setAdditionalProperty("keyword" + (i + 1),  keywordNodes.get(i).get("id").asText());
				}
			} else {
				List<String> tags = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(dataset.getId().toString()).getTags().stream().map(Tag::getName).collect(Collectors.toList());
				rda.setKeyword(tags);
			}
			List<JsonNode> personalDataNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.personal_data");
			if (!personalDataNodes.isEmpty()) {
				rda.setPersonalData(personalDataNodes.stream().map(personalDataNode -> Dataset.PersonalData.fromValue(personalDataNode.get("value").asText())).findFirst().get());
			} else {
				rda.setPersonalData(Dataset.PersonalData.UNKNOWN);
			}
			List<JsonNode> securityAndPrivacyNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.security_and_privacy");
			if (!securityAndPrivacyNodes.isEmpty()) {
				rda.setSecurityAndPrivacy(SecurityAndPrivacyRDAMapper.toRDAList(securityAndPrivacyNodes));
			}
			List<JsonNode> sensitiveDataNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.sensitive_data");
			if (!sensitiveDataNodes.isEmpty()) {
				rda.setSensitiveData(sensitiveDataNodes.stream().map(sensitiveDataNode -> Dataset.SensitiveData.fromValue(sensitiveDataNode.get("value").asText())).findFirst().get());
			}
			List<JsonNode> technicalResourceNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.technical_resource");
			if (!technicalResourceNodes.isEmpty()) {
				rda.setTechnicalResource(TechnicalResourceRDAMapper.toRDAList(technicalResourceNodes));
			}
			List<JsonNode> issuedNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.issued");
			if (!issuedNodes.isEmpty()) {
				rda.setIssued(issuedNodes.get(0).get("value").asText());
			}
			List<JsonNode> foundNodes = Stream.of(typeNodes, languageNodes, metadataNodes, qaNodes, preservationNodes, distributionNodes,
					keywordNodes, personalDataNodes, securityAndPrivacyNodes, sensitiveDataNodes, technicalResourceNodes).flatMap(Collection::stream).collect(Collectors.toList());
			templateIdsToValues.entrySet().forEach(entry -> {
				boolean isFound = foundNodes.stream().anyMatch(node -> node.get("id").asText().equals(entry.getKey()));
				if (!isFound && entry.getValue() != null && !entry.getValue().toString().isEmpty()) {
					rda.setAdditionalProperty(entry.getKey(), entry.getValue());
				}
			});


		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}


		return rda;
	}


	public eu.eudat.data.entities.Dataset toEntity(Dataset rda, DatasetProfile defaultProfile) {
		eu.eudat.data.entities.Dataset entity = new eu.eudat.data.entities.Dataset();
		entity.setLabel(rda.getTitle());
		entity.setDescription(rda.getDescription());
		try {
			DatasetProfile profile = apiContext.getOperationsContext().getDatabaseRepository().getDatasetProfileDao().find(UUID.fromString(rda.getAdditionalProperties().get("template").toString()));
			entity.setProfile(profile);
		}catch(Exception e) {
			logger.warn(e.getMessage(), e);
			entity.setProfile(defaultProfile);
		}
		try {
			Map<String, Object> properties = new HashMap<>();
			DatasetWizardModel datasetWizardModel = new DatasetWizardModel();
			datasetWizardModel.setProfile(entity.getProfile().getId());
			datasetWizardModel.setDatasetProfileDefinition(datasetManager.getPagedProfile(datasetWizardModel, entity));
			ObjectMapper mapper = new ObjectMapper();
			String datasetDescriptionJson = mapper.writeValueAsString(datasetWizardModel.getDatasetProfileDefinition());
			JsonNode datasetDescriptionObj = mapper.readTree(datasetDescriptionJson);

			List<JsonNode> typeNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.type");
			if (!typeNodes.isEmpty()) {
				properties.put(typeNodes.get(0).get("id").asText(), rda.getType());
			}

			List<JsonNode> languageNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.language");
			if (!languageNodes.isEmpty() && rda.getLanguage() != null) {
				properties.put(languageNodes.get(0).get("id").asText(), rda.getLanguage().value());
			}

			if (rda.getMetadata() != null) {
				properties.putAll(MetadataRDAMapper.toProperties(rda.getMetadata()));
			}

			if (rda.getDatasetId() != null) {
				properties.putAll(DatasetIdRDAMapper.toProperties(rda.getDatasetId(), datasetDescriptionObj));
			}

			/*List <String> qaIds = rda.getAdditionalProperties().entrySet().stream().filter(entry -> entry.getKey().startsWith("qaId")).map(entry -> entry.getValue().toString()).collect(Collectors.toList());
			for (int i = 0; i < qaIds.size(); i++) {
				properties.put(qaIds.get(i), rda.getDataQualityAssurance().get(i));
			}*/
			List<JsonNode> qaNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.data_quality_assurance");
			if (!qaNodes.isEmpty() && rda.getDataQualityAssurance() != null && !rda.getDataQualityAssurance().isEmpty()) {
				properties.put(qaNodes.get(0).get("id").asText(), rda.getDataQualityAssurance().get(0));
			}

			List<JsonNode> preservationNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.preservation_statement");
			if (!preservationNodes.isEmpty()) {
				properties.put(preservationNodes.get(0).get("id").asText(), rda.getPreservationStatement());
			}

			List<JsonNode> issuedNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.issued");
			if (!issuedNodes.isEmpty()) {
				properties.put(issuedNodes.get(0).get("id").asText(), rda.getIssued());
			}

			if (rda.getDistribution() != null) {
				properties.putAll(DistributionRDAMapper.toProperties(rda.getDistribution().get(0), datasetDescriptionObj));
			}

			List <String> keywordIds = rda.getAdditionalProperties().entrySet().stream().filter(entry -> entry.getKey().startsWith("keyword")).map(entry -> entry.getValue().toString()).collect(Collectors.toList());
			for (int i = 0; i < keywordIds.size(); i++) {
				properties.put(keywordIds.get(i), rda.getKeyword().get(i));
			}

			List<JsonNode> personalDataNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.personal_data");
			if (!personalDataNodes.isEmpty()) {
				properties.put(personalDataNodes.get(0).get("id").asText(), rda.getPersonalData().value());
			}

			if (rda.getSecurityAndPrivacy() != null) {
				properties.putAll(SecurityAndPrivacyRDAMapper.toProperties(rda.getSecurityAndPrivacy()));
			}

			List<JsonNode> sensitiveDataNodes = JsonSearcher.findNodes(datasetDescriptionObj, "rdaProperty", "dataset.sensitive_data");
			if (!sensitiveDataNodes.isEmpty()) {
				properties.put(sensitiveDataNodes.get(0).get("id").asText(), rda.getSensitiveData().value());
			}

			if (rda.getTechnicalResource() != null) {
				properties.putAll(TechnicalResourceRDAMapper.toProperties(rda.getTechnicalResource()));
			}

			rda.getAdditionalProperties().entrySet().stream()
			   .filter(entry -> !entry.getKey().equals("template") && !entry.getKey().startsWith("qaId") && !entry.getKey().startsWith("keyword"))
			   .forEach(entry -> properties.put(entry.getKey(), entry.getValue()));
			entity.setProperties(new ObjectMapper().writeValueAsString(properties));
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}


		return entity;
	}
}