package eu.eudat.managers;

import eu.eudat.builders.entity.UserInfoBuilder;
import eu.eudat.dao.entities.*;
import eu.eudat.documents.word.WordBuilder;
import eu.eudat.entities.UserInfo;
import eu.eudat.models.HintedModelFactory;
import eu.eudat.models.criteria.DataRepositoryCriteria;
import eu.eudat.models.criteria.ExternalDatasetCriteria;
import eu.eudat.models.criteria.RegistryCriteria;
import eu.eudat.models.criteria.ServiceCriteria;
import eu.eudat.models.dataset.DatasetTableRequest;
import eu.eudat.models.datasetwizard.DatasetWizardModel;
import eu.eudat.models.helpers.common.DataTableData;
import eu.eudat.models.listingmodels.DatasetListingModel;
import eu.eudat.models.security.Principal;
import eu.eudat.models.user.composite.PagedDatasetProfile;
import eu.eudat.queryable.QueryableList;
import eu.eudat.services.ApiContext;
import org.json.JSONObject;

import javax.xml.bind.JAXBException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;


public class DatasetManager {

    public DataTableData<DatasetListingModel> getPaged(ApiContext apiContext, DatasetTableRequest datasetTableRequest, Principal principal) throws Exception {
        UserInfo userInfo = apiContext.getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
        QueryableList<eu.eudat.entities.Dataset> items = apiContext.getDatabaseRepository().getDatasetDao().getWithCriteria(datasetTableRequest.getCriteria());
        QueryableList<eu.eudat.entities.Dataset> authItems = apiContext.getDatabaseRepository().getDatasetDao().getAuthenticated(items, userInfo);
        QueryableList<eu.eudat.entities.Dataset> pagedItems = PaginationManager.applyPaging(authItems, datasetTableRequest);
        DataTableData<DatasetListingModel> dataTable = new DataTableData<DatasetListingModel>();

        CompletableFuture<List<DatasetListingModel>> itemsFuture = pagedItems.withHint(HintedModelFactory.getHint(DatasetListingModel.class)).
                selectAsync(item -> new DatasetListingModel().fromDataModel(item)).whenComplete((resultList, throwable) -> {
            dataTable.setData(resultList);
        });

        CompletableFuture countFuture = items.countAsync().whenComplete((count, throwable) -> {
            dataTable.setTotalCount(count);
        });

        CompletableFuture.allOf(itemsFuture, countFuture).join();
        return dataTable;
    }

    public DatasetWizardModel getSingle(DatasetDao datatasetRepository, String id) throws InstantiationException, IllegalAccessException {
        DatasetWizardModel dataset = new DatasetWizardModel();
        eu.eudat.entities.Dataset datasetEntity = datatasetRepository.find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
        dataset.setDatasetProfileDefinition(getPagedProfile(dataset, datasetEntity));
        dataset.fromDataModel(datasetEntity);
        return dataset;
    }

    private PagedDatasetProfile getPagedProfile(DatasetWizardModel dataset, eu.eudat.entities.Dataset datasetEntity) {
        eu.eudat.models.user.composite.DatasetProfile datasetprofile = UserManager.generateDatasetProfileModel(datasetEntity.getProfile());
        datasetprofile.setStatus(dataset.getStatus());
        if (datasetEntity.getProperties() != null) {
            JSONObject jobject = new JSONObject(datasetEntity.getProperties());
            Map<String, Object> properties = (Map<String, Object>) jobject.toMap();
            datasetprofile.fromJsonObject(properties);
        }
        PagedDatasetProfile pagedDatasetProfile = new PagedDatasetProfile();
        pagedDatasetProfile.buildPagedDatasetProfile(datasetprofile);
        return pagedDatasetProfile;
    }

    public File getWordDocument(DatasetDao datatasetRepository, String id) throws InstantiationException, IllegalAccessException, IOException {
        WordBuilder wordBuilder = new WordBuilder();
        DatasetWizardModel dataset = new DatasetWizardModel();
        eu.eudat.entities.Dataset datasetEntity = datatasetRepository.find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
        PagedDatasetProfile pagedDatasetProfile = getPagedProfile(dataset,datasetEntity);
        return wordBuilder.build(pagedDatasetProfile);
    }

    public static eu.eudat.entities.Dataset createOrUpdate(ApiContext apiContext, DatasetWizardModel profile, Principal principal) throws Exception {
        eu.eudat.entities.Dataset dataset = profile.toDataModel();
        propertiesModelToString(profile, dataset);
        UserInfo userInfo = apiContext.getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
        dataset.setCreator(userInfo);
        createRegistriesIfTheyDontExist(apiContext.getDatabaseRepository().getRegistryDao(), dataset);
        createDataRepositoriesIfTheyDontExist(apiContext.getDatabaseRepository().getDataRepositoryDao(), dataset);
        createServicesIfTheyDontExist(apiContext.getDatabaseRepository().getServiceDao(), dataset);
        createExternalDatasetsIfTheyDontExist(apiContext.getDatabaseRepository().getExternalDatasetDao(), dataset);
        return apiContext.getDatabaseRepository().getDatasetDao().createOrUpdate(dataset);
    }

    private static void propertiesModelToString(DatasetWizardModel datasetWizardModel, eu.eudat.entities.Dataset dataset) {
        Map<String, Object> values = new HashMap();
        PagedDatasetProfile properties = datasetWizardModel.getDatasetProfileDefinition();
        properties.toMap(values);
        JSONObject jobject = new JSONObject(values);
        dataset.setProperties(jobject.toString());
    }


    private static void createRegistriesIfTheyDontExist(RegistryDao registryDao, eu.eudat.entities.Dataset dataset) {
        if (dataset.getRegistries() != null && !dataset.getRegistries().isEmpty()) {
            for (eu.eudat.entities.Registry registry : dataset.getRegistries()) {
                RegistryCriteria criteria = new RegistryCriteria();
                criteria.setLike(registry.getReference());
                List<eu.eudat.entities.Registry> entries = registryDao.getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) registry.setId(entries.get(0).getId());
                else registry = registryDao.createOrUpdate(registry);
            }
        }
    }

    private static void createServicesIfTheyDontExist(ServiceDao serviceDao, eu.eudat.entities.Dataset dataset) {
        if (dataset.getServices() != null && !dataset.getServices().isEmpty()) {
            for (eu.eudat.entities.Service service : dataset.getServices()) {
                ServiceCriteria criteria = new ServiceCriteria();
                criteria.setLike(service.getReference());
                List<eu.eudat.entities.Service> entries = serviceDao.getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) service.setId(entries.get(0).getId());
                else service = serviceDao.createOrUpdate(service);
            }
        }
    }

    private static void createDataRepositoriesIfTheyDontExist(DataRepositoryDao dataRepositoryDao, eu.eudat.entities.Dataset dataset) {
        if (dataset.getDataRepositories() != null && !dataset.getDataRepositories().isEmpty()) {
            for (eu.eudat.entities.DataRepository dataRepo : dataset.getDataRepositories()) {
                DataRepositoryCriteria criteria = new DataRepositoryCriteria();
                criteria.setLike(dataRepo.getReference());
                List<eu.eudat.entities.DataRepository> entries = dataRepositoryDao.getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) dataRepo.setId(entries.get(0).getId());
                else dataRepo = dataRepositoryDao.createOrUpdate(dataRepo);
            }
        }
    }

    private static void createExternalDatasetsIfTheyDontExist(ExternalDatasetDao externalDatasetDao, eu.eudat.entities.Dataset dataset) {
        if (dataset.getExternalDatasets() != null && !dataset.getExternalDatasets().isEmpty()) {
            for (eu.eudat.entities.ExternalDataset externalDataset : dataset.getExternalDatasets()) {
                ExternalDatasetCriteria criteria = new ExternalDatasetCriteria();
                criteria.setLike(externalDataset.getReference());
                List<eu.eudat.entities.ExternalDataset> entries = externalDatasetDao.getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) externalDataset.setId(entries.get(0).getId());
                else externalDataset = externalDatasetDao.createOrUpdate(externalDataset);
            }
        }
    }

    public static void makePublic(DatasetDao datasetDao, UUID id) throws Exception {
        eu.eudat.entities.Dataset dataset = datasetDao.find(id);
        if (dataset.getStatus() != eu.eudat.entities.Dataset.Status.FINALISED.getValue())
            throw new Exception("You cannot make public a Dataset That Has not Been Finalised");
        dataset.setPublic(true);
        datasetDao.createOrUpdate(dataset);
    }

}