package eu.eudat.logic.services.references;

import com.fasterxml.jackson.core.JsonProcessingException;
import eu.eudat.authorization.AuthorizationFlags;
import eu.eudat.authorization.Permission;
import eu.eudat.commons.XmlHandlingService;
import eu.eudat.commons.enums.IsActive;
import eu.eudat.commons.enums.ReferenceType;
import eu.eudat.commons.scope.user.UserScope;
import eu.eudat.commons.types.reference.DefinitionEntity;
import eu.eudat.commons.types.reference.FieldEntity;
import eu.eudat.configurations.referencetype.ReferenceTypeProperties;
import eu.eudat.convention.ConventionService;
import eu.eudat.data.ReferenceEntity;
import eu.eudat.data.dao.criteria.*;
import eu.eudat.data.old.DataRepository;
import eu.eudat.data.old.ExternalDataset;
import eu.eudat.data.old.Registry;
import eu.eudat.data.old.Service;
import eu.eudat.logic.builders.model.criteria.ExternalDatasetCriteriaBuilder;
import eu.eudat.logic.proxy.config.ExternalUrlCriteria;
import eu.eudat.logic.proxy.config.exceptions.HugeResultSet;
import eu.eudat.logic.proxy.config.exceptions.NoURLFound;
import eu.eudat.logic.proxy.fetching.RemoteFetcher;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.model.Reference;
import eu.eudat.model.builder.ReferenceBuilder;
import eu.eudat.model.builder.referencesearch.ReferenceSearchBuilder;
import eu.eudat.model.deleter.ReferenceDeleter;
import eu.eudat.model.persist.ReferencePersist;
import eu.eudat.model.persist.referencedefinition.DefinitionPersist;
import eu.eudat.model.persist.referencedefinition.FieldPersist;
import eu.eudat.models.data.FetcherReference;
import eu.eudat.query.ReferenceQuery;
import eu.eudat.query.lookup.ReferenceSearchLookup;
import eu.eudat.queryable.QueryableList;
import gr.cite.commons.web.authz.service.AuthorizationService;
import gr.cite.tools.data.builder.BuilderFactory;
import gr.cite.tools.data.deleter.DeleterFactory;
import gr.cite.tools.data.query.QueryFactory;
import gr.cite.tools.exception.MyApplicationException;
import gr.cite.tools.exception.MyForbiddenException;
import gr.cite.tools.exception.MyNotFoundException;
import gr.cite.tools.exception.MyValidationException;
import gr.cite.tools.fieldset.BaseFieldSet;
import gr.cite.tools.fieldset.FieldSet;
import gr.cite.tools.logging.LoggerService;
import gr.cite.tools.logging.MapLogEntry;
import jakarta.persistence.EntityManager;
import jakarta.xml.bind.JAXBException;
import org.jetbrains.annotations.NotNull;
import org.slf4j.LoggerFactory;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;

import javax.management.InvalidApplicationException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import java.time.Instant;
import java.util.*;
import java.util.stream.Collectors;

@org.springframework.stereotype.Service
public class ReferenceService {

    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(ReferenceService.class));
    private final ApiContext apiContext;
    private final UserScope userScope;
    private final RemoteFetcher remoteFetcher;
    private final EntityManager entityManager;
    private final AuthorizationService authorizationService;
    private final DeleterFactory deleterFactory;
    private final BuilderFactory builderFactory;
    private final ConventionService conventionService;
    private final MessageSource messageSource;
    private final QueryFactory queryFactory;
    private final XmlHandlingService xmlHandlingService;
    private final ReferenceTypeProperties referenceTypeProperties;

    public ReferenceService(ApiContext apiContext,
                            UserScope userScope,
                            RemoteFetcher remoteFetcher,
                            EntityManager entityManager,
                            AuthorizationService authorizationService,
                            DeleterFactory deleterFactory,
                            BuilderFactory builderFactory,
                            ConventionService conventionService,
                            MessageSource messageSource,
                            QueryFactory queryFactory,
                            XmlHandlingService xmlHandlingService,
                            ReferenceTypeProperties referenceTypeProperties) {
        this.apiContext = apiContext;
        this.userScope = userScope;
        this.remoteFetcher = remoteFetcher;
        this.entityManager = entityManager;
        this.authorizationService = authorizationService;
        this.deleterFactory = deleterFactory;
        this.builderFactory = builderFactory;
        this.conventionService = conventionService;
        this.messageSource = messageSource;
        this.queryFactory = queryFactory;
        this.xmlHandlingService = xmlHandlingService;
        this.referenceTypeProperties = referenceTypeProperties;
    }

    public Reference persist(ReferencePersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException, JAXBException, JsonProcessingException, TransformerException, ParserConfigurationException {
        logger.debug(new MapLogEntry("persisting data").And("model", model).And("fields", fields));

        this.authorizationService.authorizeForce(Permission.EditDmpBlueprint);

        Boolean isUpdate = this.conventionService.isValidGuid(model.getId());

        ReferenceEntity data;
        if (isUpdate) {
            data = this.entityManager.find(ReferenceEntity.class, model.getId());
            if (data == null)
                throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), Reference.class.getSimpleName()}, LocaleContextHolder.getLocale()));
        } else {
            data = new ReferenceEntity();
            data.setId(UUID.randomUUID());
            data.setIsActive(IsActive.Active);
            data.setCreatedAt(Instant.now());
        }

        data.setLabel(model.getLabel());
        data.setType(model.getType());
        data.setDescription(model.getDescription());
        data.setDefinition(this.xmlHandlingService.toXmlSafe(this.buildDefinitionEntity(model.getDefinition())));
        data.setUpdatedAt(Instant.now());
        data.setReference(model.getReference());
        data.setAbbreviation(model.getAbbreviation());
        data.setSource(model.getSource());
        data.setSourceType(model.getSourceType());

        if (isUpdate) this.entityManager.merge(data);
        else  this.entityManager.persist(data);

        this.entityManager.flush();

        return this.builderFactory.builder(ReferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(BaseFieldSet.build(fields, Reference._id), data);
    }

    private @NotNull DefinitionEntity buildDefinitionEntity(DefinitionPersist persist){
        DefinitionEntity data = new DefinitionEntity();
        if (persist == null) return data;
        if (!this.conventionService.isListNullOrEmpty(persist.getFields())){
            data.setFields(new ArrayList<>());
            for (FieldPersist fieldPersist: persist.getFields()) {
                data.getFields().add(this.buildFieldEntity(fieldPersist));
            }
        }

        return data;
    }

    private @NotNull FieldEntity buildFieldEntity(FieldPersist persist){
        FieldEntity data = new FieldEntity();
        if (persist == null) return data;

        data.setCode(persist.getCode());
        data.setDataType(persist.getDataType());
        data.setCode(persist.getCode());

        return data;
    }

    public void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException {
        logger.debug("deleting : {}", id);

        this.authorizationService.authorizeForce(Permission.DeleteReference);

        this.deleterFactory.deleter(ReferenceDeleter.class).deleteAndSaveByIds(List.of(id));
    }

//    public List<FetcherReference> searchReference(ReferenceType externalType, String query, String type) throws HugeResultSet, NoURLFound, InvalidApplicationException {
//        ExternalUrlCriteria externalUrlCriteria = new ExternalUrlCriteria(query);
//
//        List<Map<String, String>> remoteRepos = this.apiContext.getOperationsContext().getRemoteFetcher().get(externalType, externalUrlCriteria, type);
//
//        List<FetcherReference> list = this.fetchFromDb(externalType, query, type, remoteRepos);
//
//        list.addAll(remoteRepos.stream().map(FetcherReference::fromRemoteModel).toList());
//        list = list.stream().filter(x -> x.getName().toLowerCase().contains(query.toLowerCase())).collect(Collectors.toList());
//        list.sort(Comparator.comparing(FetcherReference::getName));
//        return list;
//    }

    public List<Reference> searchReference(ReferenceSearchLookup lookup) throws HugeResultSet, NoURLFound, InvalidApplicationException {
        ExternalUrlCriteria externalUrlCriteria = new ExternalUrlCriteria(lookup.getLike());

        List<Map<String, String>> remoteRepos = this.apiContext.getOperationsContext().getRemoteFetcher().get(lookup.getType(), externalUrlCriteria, lookup.getKey());

        List<Reference> externalModels = this.builderFactory.builder(ReferenceSearchBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(lookup.getProject(), remoteRepos);
        List<Reference> models = this.fetchFromDb(lookup);

        models.addAll(externalModels);

        models = models.stream().filter(x -> x.getLabel().toLowerCase().contains(lookup.getLike().toLowerCase())).collect(Collectors.toList());
        models.sort(Comparator.comparing(Reference::getLabel));

        return models;
    }

    private List<Reference> fetchFromDb(ReferenceSearchLookup lookup){

        List<String> fields = Arrays.asList(Reference._id, Reference._label, Reference._description, Reference._abbreviation, Reference._source,
                Reference._isActive, Reference._createdAt, Reference._updatedAt, Reference._type, Reference._definition, Reference._reference, Reference._sourceType );
        lookup.setProject(new BaseFieldSet(fields));

        ReferenceQuery query = lookup.enrich(this.queryFactory).authorize(AuthorizationFlags.OwnerOrPermission);
        List<ReferenceEntity> datas = query.collectAs(lookup.getProject());
        return this.builderFactory.builder(ReferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(lookup.getProject(), datas);
    }

//    private List<FetcherReference> fetchFromDb(ReferenceType externalType, String query, String type, List<Map<String, String>> remoteRepos) throws InvalidApplicationException {
//        List<FetcherReference> list = new LinkedList<>();
//        switch (externalType) {
//            case DataRepositories:
//            case PubRepositories:
//            case Journals: {
//                DataRepositoryCriteria criteria = new DataRepositoryCriteria();
//                if (!query.isEmpty()) criteria.setLike(query);
//                criteria.setCreationUserId(this.userScope.getUserId());
//                if (type.equals("")) {
//                    List<DataRepository> dataRepositoryList = (this.apiContext.getOperationsContext().getDatabaseRepository().getDataRepositoryDao().getWithCriteria(criteria)).toList();
//                    list = dataRepositoryList.stream().map(item -> new FetcherReference().fromDataRepository(item)).collect(Collectors.toList());
//                }
//            }
//            case Registries: {
//                RegistryCriteria criteria = new RegistryCriteria();
//                if (!query.isEmpty()) criteria.setLike(query);
//                criteria.setCreationUserId(this.userScope.getUserId());
//                if (type.equals("")) {
//                    List<Registry> registryList = (this.apiContext.getOperationsContext().getDatabaseRepository().getRegistryDao().getWithCriteria(criteria)).toList();
//                    list = registryList.stream().map(item -> new FetcherReference().fromRegistry(item)).collect(Collectors.toList());
//                }
//            }
//            case Services:
//            {
//                ServiceCriteria criteria = new ServiceCriteria();
//
//                if (!query.isEmpty()) criteria.setLike(query);
//                criteria.setCreationUserId(this.userScope.getUserId());
//
//                if (type.equals("")) {
//                    List<Service> serviceList = (this.apiContext.getOperationsContext().getDatabaseRepository().getServiceDao().getWithCriteria(criteria)).toList();
//                   list = serviceList.stream().map(item -> new FetcherReference().fromService(item)).collect(Collectors.toList());
//                }
//            }
//            case Datasets:{
//
//                ExternalDatasetCriteria criteria = apiContext.getOperationsContext().getBuilderFactory().getBuilder(ExternalDatasetCriteriaBuilder.class).like(query).build();
//
//                criteria.setCreationUserId(this.userScope.getUserId());
//                QueryableList<ExternalDataset> items = apiContext.getOperationsContext().getDatabaseRepository().getExternalDatasetDao().getWithCriteria(criteria);
//
//                list = items.select(item -> new FetcherReference().fromDataset(item));
//            }
//            case Taxonomies:
//            case Publications:
//            case Licenses:
//                break;
//        }
//
//        return list;
//    }

}