VocabularyServiceImpl

/*
 * Copyright 2018-2022 Medical Information Systems Research Group (https://medical.zcu.cz),
 * Department of Computer Science and Engineering, University of West Bohemia.
 * Address: Univerzitni 8, 306 14 Plzen, Czech Republic.
 *
 * Author Petr Vcelak (vcelak@kiv.zcu.cz).
 *
 * This file is part of MRECore project.
 *
 * MRECore is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License.
 *
 * MRECore is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with MRECore. If not, see <http://www.gnu.org/licenses/>.
 */
package cz.zcu.mre.service.data;

import cz.zcu.mre.config.ApplicationConfiguration;
import cz.zcu.mre.data.rdf.ResourceWrapperComparator;
import cz.zcu.mre.data.rdf.VocabularyWrapper;
import cz.zcu.mre.vocab.FORM;
import cz.zcu.mre.vocab.IBDT;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import jakarta.servlet.ServletContext;
import org.apache.jena.ontology.Individual;
import org.apache.jena.ontology.OntClass;
import org.apache.jena.ontology.OntResource;
import org.apache.jena.rdf.model.RDFNode;
import org.apache.jena.rdf.model.Resource;
import org.apache.jena.rdf.model.ResourceFactory;
import org.apache.jena.util.iterator.ExtendedIterator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;

/**
 * Vocabulary service takes care of providing vocabulary items and is available
 * in servlet context as 'vocab' attribute.
 *
 * @author Petr Vcelak (vcelak@kiv.zcu.cz)
 */
//@Service
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
public class VocabularyServiceImpl implements VocabularyService {

    private static final Logger LOG = LoggerFactory.getLogger(VocabularyServiceImpl.class);

    private static final String WARN_MSG = "Missing label for property {}";

    /**
     * Vocabulary items comparator.
     */
    private static final ResourceWrapperComparator resourceWraperComparator = new ResourceWrapperComparator();

    /**
     * Maps Resource to List of IndividualWrappers.
     */
    private final Map<Resource, List<VocabularyWrapper>> vocabularyMap = new ConcurrentHashMap<>();
    /**
     * Maps individual/instance URI to a VocabularyWrapper.
     */
    private final Map<String, VocabularyWrapper> individualMap = new ConcurrentHashMap<>();

    @Autowired
    private OntologyService ontologyService;

    @Autowired
    private ServletContext servletContext;

    /**
     * Handle context refreshed event and register (set) attributes in the
     * servlet context.
     *
     * It is possible to use placeholder with the local name of vocabulary
     * ${application.vocab.label('YesNoVocab')} or property URI like:
     * ${application.vocab.values('YesNoVocab')}.
     *
     * @param e Context refreshed event.
     */
    @EventListener
    protected void handleContextRefresh(ContextRefreshedEvent e) {
        LOG.info("Add VocabularyService on the event ContextRefreshedEvent.");

        // set attribute vocab (application.vocab.*())
        servletContext.setAttribute("vocab", this);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        LOG.info("VocabularyService - prepare");
        loadVocabularies();
        LOG.info("VocabularyService - prepare - done.");
    }

    private void loadVocabularies() {

        List<OntClass> ontClassList = ontologyService.getVocabularyList();
        ontClassList.forEach((ontClass) -> {
            List<VocabularyWrapper> vwList = new ArrayList<>();
            ExtendedIterator<? extends OntResource> it = ontClass.listInstances();
            while (it.hasNext()) {
                OntResource ontResource = it.next();
                LOG.debug("Loaded vocabulary {} instance {}.", ontClass.getURI(), ontResource.getURI());
                VocabularyWrapper vw = createVocabularyWrapper(ontClass, ontResource);

                // put into a list per vocabulary
                vwList.add(vw);

                // put to individual map
                individualMap.put(ontResource.getURI(), vw);
            }

            // check if list is empty
            if (vwList.isEmpty()) {
                // mark vocabulary empty
                vocabularyMap.put(ontClass, Collections.EMPTY_LIST);
            } else {

                // list is not empty -- sort values by ResourceWrapperComparator
                LOG.debug("Sort vocabulary {} items ({}).", ontClass.getURI(), vwList.size());
                vwList.sort(resourceWraperComparator);

                // put into vocabulary map
                vocabularyMap.put(ontClass, vwList);
            }
        });
    }

    private VocabularyWrapper createVocabularyWrapper(OntClass ontClazz, OntResource ontResource) {

        LOG.debug("Create VocabularyWrapper for vocabulary {} and instance {}", ontClazz.getURI(), ontResource.getURI());
        VocabularyWrapper vw = new VocabularyWrapper(ontResource);

        // set label
        String label = ontResource.getLabel(ApplicationConfiguration.DEFAULT_LANGUAGE);
        if (label == null || label.isEmpty()) {
            label = ontResource.getLabel(null);
        }
        vw.setLabel(label);

        // set code
        if (ontResource.hasProperty(FORM.CODE)) {
            String code = ontResource.getProperty(FORM.CODE).getString();
            if (code == null || code.isEmpty()) {
                code = label;
            }
            vw.setItemCode(code);
        }

        // set item id for sorting form:vocabularyItemId
        RDFNode node = ontResource.getPropertyValue(FORM.VOCABULARY_ITEM_ID);
        if (node != null && node.asLiteral() != null) {
            int order = node.asLiteral().getInt();
            vw.setIntOrder(order);
        } else {

            // form:vocabularyLineNumber
            node = ontResource.getPropertyValue(FORM.VOCABULARY_LINE_NUMBER);
            if (node != null && node.asLiteral() != null) {
                int order = node.asLiteral().getInt();
                vw.setIntOrder(order);
            }
        }

        return vw;
    }

    @Override
    public List<VocabularyWrapper> itemsList(String rdfClass) {

        LOG.debug("List items of class {}", rdfClass);
        return itemsList(ResourceFactory.createResource(rdfClass));
    }

    @Override
    public List<VocabularyWrapper> itemsList(Resource rdfClass) {

        LOG.debug("List items of {}", rdfClass.getURI());

        if (vocabularyMap.containsKey(rdfClass)) {
            LOG.debug("List items of {} - using hash map.", rdfClass.getURI());
            return vocabularyMap.get(rdfClass);
        }

        return Collections.EMPTY_LIST;
    }

    @Override
    public VocabularyWrapper item(String uri) {

        return individualMap.get(uri);
    }

    @Override
    public String label(Resource resource) {

        if (resource == null) {
            return "";
        }

        if (individualMap.containsKey(resource.getURI())) {
            LOG.debug("Get prepared label for individual {}", resource);
            return individualMap.get(resource.getURI()).getLabel();
        }

        LOG.warn(WARN_MSG, resource);
        return resource.getLocalName();
    }

    @Override
    public String code(Resource resource) {

        if (resource == null) {
            return "";
        }

        if (individualMap.containsKey(resource.getURI())) {
            LOG.debug("Get prepared code for resource {}", resource);
            return individualMap.get(resource.getURI()).getItemCode();
        }

        LOG.warn(WARN_MSG, resource);
        return resource.getLocalName();
    }

    @Override
    public boolean itemExist(Resource rdfClass) {

        if (vocabularyMap.containsKey(rdfClass)) {
            return true;
        }

        return !itemsList(rdfClass).isEmpty();
    }

    @Override
    public int itemCount(Resource rdfClass) {

        if (vocabularyMap.containsKey(rdfClass)) {
            return vocabularyMap.get(rdfClass).size();
        }

        return itemsList(rdfClass).size();
    }

    @Override
    public boolean itemByCodeExist(Resource rdfClass, String itemCode) {

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);
        // look for the first item

        return vocabularyContent.stream().map((vw) -> (Individual) vw.getResource()).map((individual) -> individual.getPropertyValue(FORM.CODE)).anyMatch((node) -> (node != null && node.asLiteral().getString().equals(itemCode)));
    }

    @Override
    public VocabularyWrapper itemByCode(Resource rdfClass, String itemCode) {

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);

        for (VocabularyWrapper vw : vocabularyContent) {

            Individual individual = (Individual) vw.getResource();

            // look for the first item
            RDFNode node = individual.getPropertyValue(FORM.CODE);
            if (node != null && node.asLiteral().getString().equals(itemCode)) {
                return vw;
            }
        }
        return null;
    }

    @Override
    public VocabularyWrapper itemByNumber(Resource rdfClass, int number) {

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);

        for (VocabularyWrapper vw : vocabularyContent) {

            Individual individual = (Individual) vw.getResource();

            // look for the first item
            RDFNode node = individual.getPropertyValue(FORM.CODE);
            if (node != null && node.asLiteral().getInt() == number) {
                return vw;
            }
        }

        return null;
    }

    @Override
    public boolean itemByNumberExist(Resource rdfClass, int number) {

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);
        // look for the first item

        return vocabularyContent.stream().map((vw) -> (Individual) vw.getResource()).map((individual) -> individual.getPropertyValue(FORM.CODE)).anyMatch((node) -> (node != null && node.asLiteral().getInt() == number));
    }

    @Override
    public VocabularyWrapper itemDefault(String rdfClass) {

        return itemDefault(ResourceFactory.createResource(rdfClass));
    }

    @Override
    public VocabularyWrapper itemDefault(Resource rdfClass) {

        VocabularyWrapper first = null;

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);
        for (VocabularyWrapper vw : vocabularyContent) {
            Individual individual = (Individual) vw.getResource();

            // look for the first item
            RDFNode node = individual.getPropertyValue(FORM.VOCABULARY_ITEM_ID);
            if (first == null && node != null && node.asLiteral().getInt() == 1) {
                first = vw;
            }

            node = individual.getPropertyValue(FORM.IS_DEFAULT_VALUE);
            if (node != null && node.asLiteral().getBoolean()) {
                return vw;
            }
        }

        // Return the first item as default, because default value is not specified.
        return first;
    }

    @Override
    public VocabularyWrapper itemFirst(Resource rdfClass) {

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);
        if (vocabularyContent.isEmpty()) {
            return null;
        }

        return vocabularyContent.get(0);

    }

    @Override
    public VocabularyWrapper itemLast(Resource rdfClass) {

        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);
        if (vocabularyContent.isEmpty()) {
            return null;
        }

        return vocabularyContent.get(vocabularyContent.size() - 1);
    }

    public float itemScore(Individual individual) {

        RDFNode node = individual.getPropertyValue(FORM.SCORE);
        if (node != null) {
            return node.asLiteral().getFloat();
        }

        return Float.NaN;
    }

    public float itemCheckScore(Individual individual) {

        RDFNode node = individual.getPropertyValue(FORM.SCORE);
        if (node != null) {
            return node.asLiteral().getFloat();
        }

        return Float.NaN;
    }

    @Override
    public List<VocabularyWrapper> itemsFilteredByAgeSex(Resource rdfClass, int age, String sex) {

        List<VocabularyWrapper> filteredList = new ArrayList<>();
        List<VocabularyWrapper> vocabularyContent = itemsList(rdfClass);
        vocabularyContent.forEach((vw) -> {
            int ageMin = Integer.MIN_VALUE;
            int ageMax = Integer.MAX_VALUE;
            Individual individual = (Individual) vw.getResource();
            RDFNode node = individual.getPropertyValue(IBDT.COND_SEX);
            if (!(node != null && node.asLiteral().getString().equals(sex))) {
                node = individual.getPropertyValue(IBDT.AGE_MIN);
                if (node != null) {
                    ageMin = node.asLiteral().getInt();
                }
                node = individual.getPropertyValue(IBDT.AGE_MAX);
                if (node != null) {
                    ageMax = node.asLiteral().getInt();
                }
                // TODO check and fix to 'less or equal' and 'more or equal'
                if (ageMin < age && age < ageMax) {
                    filteredList.add(vw);
                }
            }
        });

        return filteredList;
    }
}