/*
    * 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.annotation.data.MREDataOntology;
  import cz.zcu.mre.annotation.data.MREDataPropertyName;
  import cz.zcu.mre.annotation.data.MREDataPropertyURI;
  import cz.zcu.mre.annotation.data.MREDataURIBasename;
  import cz.zcu.mre.dao.SPARQLRepository;
  import cz.zcu.mre.data.core.MREData;
  import cz.zcu.mre.data.core.MREDataException;
  import cz.zcu.mre.util.ReflectionsUtil;
  import cz.zcu.mre.vocab.MRE;
  import cz.zcu.mre.vocab.NS;
  import java.lang.reflect.Field;
  import java.time.LocalDate;
  import java.time.LocalDateTime;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  import org.apache.commons.lang3.reflect.FieldUtils;
  import org.apache.jena.arq.querybuilder.UpdateBuilder;
  import org.apache.jena.datatypes.xsd.XSDDateTime;
  import org.apache.jena.ontology.Individual;
  import org.apache.jena.query.Query;
  import org.apache.jena.query.QuerySolution;
  import org.apache.jena.rdf.model.Resource;
  import org.apache.jena.rdf.model.ResourceFactory;
  import org.apache.jena.sparql.modify.request.UpdateDeleteInsert;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.core.convert.ConversionService;
  
  /**
   *
   * MRE Data Service Implementation.
   *
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public class MREDataServiceImpl implements MREDataService {
  
      private static final Logger LOG = LoggerFactory.getLogger(MREDataServiceImpl.class);
  
      private static final Map<Class, List<MREDataBuilderConfig>> converterConfig = new HashMap<>();
  
      @Autowired
      private SPARQLRepository sparqlRepository;
  
      @Autowired
      private SPARQLBuilder sparqlBuilder;
  
      @Autowired
      private ConversionService conversionService;
  
      /**
       * Default constructor.
       */
      public MREDataServiceImpl() {
      }
  
      /**
       * Initialization constructor.
       *
       * @param sparqlBuilder SPARQL Builder
       * @param repository The SPARQL Repository.
       * @param conversionService The conversion service.
       */
      public MREDataServiceImpl(SPARQLBuilder sparqlBuilder, SPARQLRepository repository, ConversionService conversionService) {
  
          this.sparqlBuilder = sparqlBuilder;
          this.sparqlRepository = repository;
          this.conversionService = conversionService;
      }
 
     public SPARQLBuilder getSparqlBuilder() {
         return sparqlBuilder;
     }
 
     public void setSparqlBuilder(SPARQLBuilder sparqlBuilder) {
         this.sparqlBuilder = sparqlBuilder;
     }
 
     public ConversionService getConversionService() {
         return conversionService;
     }
 
     public SPARQLRepository getSparqlRepository() {
         return sparqlRepository;
     }
 
     public void setSparqlRepository(SPARQLRepository sparqlRepository) {
         this.sparqlRepository = sparqlRepository;
     }
 
     public void setConversionService(ConversionService conversionService) {
         this.conversionService = conversionService;
     }
 
     @Override
     public MREData createInstance(MREData example) {
         return createInstance(example, null, null);
     }
 
     @Override
     public MREData createInstance(MREData example, Resource uri) {
         return createInstance(example, uri, null);
     }
 
     @Override
     public MREData createInstance(Resource type) {
         return createInstance(null, null, type);
     }
 
     @Override
     public MREData createInstance(Resource type, Resource uri) {
         return createInstance(null, uri, type);
     }
 
     @Override
     public MREData createInstance(String typeURI) {
         return createInstance(null, null, ResourceFactory.createResource(typeURI));
     }
 
     @Override
     public MREData createInstance(String typeURI, Resource uri) {
         return createInstance(null, uri, ResourceFactory.createResource(typeURI));
     }
 
     private MREData createInstance(MREData example, Resource uri, Resource type) {
 
         MREData instance = null;
         Class clazz;
         String instanceTypeURI = null;
         try {
 
             if (example != null) {
                 clazz = example.getClass();
 
                 String namespace = ((MREDataOntology) clazz.getAnnotation(MREDataOntology.class)).namespace();
                 String name = clazz.getSimpleName();
                 instanceTypeURI = namespace.concat(name);
             } else if (type != null) {
                 // look for annotated Java Bean class
                 clazz = ReflectionsUtil.lookForAnnotatedJavaClass(type);
             } else {
                 // no example and no type, cannot recognize class
                 return null;
             }
 
             instance = (MREData) clazz.newInstance();
             if (uri != null) {
                 instance.setResource(uri);
             }
             if (type != null) {
                 instance.setType(type);
             } else if (instanceTypeURI != null) {
                 instance.setType(ResourceFactory.createResource(instanceTypeURI));
             }
 
         } catch (InstantiationException | IllegalAccessException ex) {
             LOG.error("Cannot instantiate class", ex);
         }
 
         return instance;
     }
 
     /**
      * ASK if instance is persistent.
      *
      * @param instance The MREData instance.
      * @return true or false.
      */
     @Override
     public boolean isPersistent(MREData instance) {
         LOG.info("Check persistent instance {} with URI {}", instance.getClass(), instance.getUri());
 
         Query query = sparqlBuilder.askExist(instance);
 
         return sparqlRepository.queryAsk(query.serialize());
     }
 
     /**
      * Save MREData instance.
      *
      * @param instance The instance.
      */
     @Override
     public boolean save(MREData instance) {
         LOG.info("Save MREData instance of type {} with URI {}", instance.getClass(), instance.getUri());
 
         if (!instance.hasURI()) {
             return insert(instance);
         } else if (isPersistent(instance)) {
             return update(instance);
         } else {
             return insert(instance);
         }
     }
 
     /**
      * Deeply save MREData instance.
      *
      * @param instance The MREData instance.
      */
     @Override
     public boolean saveAll(MREData instance) {
         LOG.info("Save all MREData instance of type {} with URI {}", instance.getClass(), instance.getUri());
 
         if (!instance.hasURI()) {
             return insertAll(instance);
         } else if (isPersistent(instance)) {
             return updateAll(instance);
         } else {
             return insertAll(instance);
         }
     }
 
     /**
      * Insert MREData instance.
      *
      * @param instance The MREData instance.
      */
     @Override
     public boolean insert(MREData instance) {
 
         if (!instance.hasURI()) {
             LOG.info("Resource URI auto-generated for the instance: {}", instance.getResource());
             instance.generateNewResource();
         }
 
         LOG.info("Insert MREData instance of type {} with URI {}", instance.getClass(), instance.getUri());
 
         UpdateBuilder updateBuilder = sparqlBuilder.insert(instance);
         if (sparqlRepository.queryInsert(updateBuilder.build())) {
             LOG.debug("Successfully saved MREData instance {}.", instance.getResource().getURI());
             return true;
         }
 
         final String msg = "MREData instance not saved.";
         LOG.error(msg);
         throw new MREDataException(msg);
         //return false;
     }
 
     /**
      * Deeply insert MREData instance.
      *
      * @param instance The MREData instance.
      */
     @Override
     public boolean insertAll(MREData instance) {
 
         if (!instance.hasURI()) {
             instance.generateNewResource();
             LOG.info("Resource URI auto-generated for the instance: {}", instance.getResource());
         }
 
         LOG.info("Insert all MREData of type {} with URI {}", instance.getClass(), instance.getUri());
 
         UpdateBuilder builder = sparqlBuilder.insertAll(instance);
         if (sparqlRepository.queryInsert(builder.build())) {
             LOG.debug("Successfully deeply saved MREData instance {}.", instance.getResource().getURI());
             return true;
         }
 
         final String msg = "MREData instance not deeply saved.";
         LOG.error(msg);
         throw new MREDataException(msg);
         //return false;
 
     }
 
     /**
      * Update MREData instance.
      *
      * @param instance The instance.
      */
     @Override
     public boolean update(MREData instance) {
         LOG.info("Update MREData instance of type {} with URI {}", instance.getClass(), instance.getUri());
 
         if (!instance.hasURI()) {
             return insert(instance);
         }
 
         MREData instanceOld = getAll(instance.getResource());
 
         UpdateDeleteInsert builder = sparqlBuilder.update(instanceOld, instance);
         if (sparqlRepository.queryUpdate(builder)) {
             LOG.debug("Successfully updated MREData instance {}.", instance.getResource().getURI());
             return true;
         }
 
         final String msg = "MREData instance not updated.";
         LOG.error(msg);
         throw new MREDataException(msg);
         //return false;
     }
 
     /**
      * Deeply update MREData instance.
      *
      * @param instance The instance.
      */
     @Override
     public boolean updateAll(MREData instance) {
         LOG.info("Update all MREData of type {} with URI {}", instance.getClass(), instance.getUri());
 
         if (!instance.hasURI()) {
             return insertAll(instance);
         }
 
         MREData instanceOld = getAll(instance.getResource());
 
         UpdateDeleteInsert builder = sparqlBuilder.updateAll(instanceOld, instance);
         if (sparqlRepository.queryUpdate(builder)) {
             LOG.debug("Successfully deeply updated MREData instance {}.", instance.getResource().getURI());
             return true;
         }
 
         final String msg = "MREData instance not deeply updated.";
         LOG.error(msg);
         throw new MREDataException(msg);
         //return false;
     }
 
     /**
      * Delete MREData instance.
      *
      * @param instance The instance.
      */
     @Override
     public boolean delete(MREData instance) {
         LOG.info("Delete MREData instance of type {} with URI {}", instance.getClass(), instance.getUri());
 
         UpdateBuilder builder = sparqlBuilder.delete(instance);
         if (sparqlRepository.queryUpdate(builder.build())) {
             LOG.debug("Successfully deleted MREData instance {}.", instance.getResource().getURI());
             return true;
         }
 
         final String msg = "MREData instance not deleted.";
         LOG.error(msg);
         throw new MREDataException(msg);
         //return false;
     }
 
     /**
      * Deeply delete MREData instance.
      *
      * @param instance The instance.
      */
     @Override
     public boolean deleteAll(MREData instance) {
         LOG.info("Delete all MREData instance of type {} with URI {}", instance.getClass(), instance.getUri());
 
         UpdateBuilder builder = sparqlBuilder.deleteAll(instance);
         if (sparqlRepository.queryUpdate(builder.build())) {
             LOG.debug("Successfully deeply deleted MREData instance {}.", instance.getResource().getURI());
             return true;
         }
 
         final String msg = "MREData instance not deeply deleted.";
         LOG.error(msg);
         throw new MREDataException(msg);
         //return false;
     }
 
     /**
      * Get the stream of MREData instances found by rdf:type.
      *
      * @param type RDF class as a type for instances.
      * @return Stream of MREData instances.
      */
     @Override
     public Stream<MREData> stream(String type) {
         LOG.info("Stream by type as String {}", type);
 
         MREData example = createInstance(type);
         return stream(example);
     }
 
     /**
      * Get the stream of MREData instances found by rdf:type.
      *
      * @param type RDF class as a type for instances.
      * @return Stream of MREData instances.
      */
     @Override
     public Stream<MREData> stream(Resource type) {
         LOG.info("Stream by type {}", type.getURI());
 
         MREData example = createInstance(type);
         return stream(example);
     }
 
     /**
      * Get the stream of MREData instances found by example.
      *
      * @param example An example.
      * @return Stream of MREData instances.
      */
     @Override
     public Stream<MREData> stream(MREData example) {
         LOG.info("Stream by example {}", example.getClass());
 
         Query query = sparqlBuilder.select(example);
         List<QuerySolution> result = sparqlRepository.querySelect(query);
 
         return asStream(result);
     }
 
     /**
      * Get the stream of MREData instances found by example.
      *
      * @param example An example.
      * @return Stream of MREData instances.
      */
     @Override
     public Stream<MREData> streamAll(MREData example) {
         LOG.info("Stream by example {}", example.getClass());
 
         Query query = sparqlBuilder.selectAll(example);
         List<QuerySolution> result = sparqlRepository.querySelect(query);
 
         return asStream(result);
     }
 
     /**
      * Parse List of QuerySolution instances to build MREData instances as a
      * stream.
      *
      * TODO can be improved when result ordered by resource URI.
      *
      * @param result MRE-query result as a List of QuerySolution instances.
      * @return Stream with MREData instances.
      */
     @Override
     public Stream<MREData> asStream(List<QuerySolution> result) {
 
         Map<Resource, MREData> map = new LinkedHashMap<>();
 
         // loop over all QuerySolution instances
         result.forEach((qs) -> {
 
             // recognize URI
             Resource uri = qs.get(SPARQLBuilderString.SELECT_VARIABLE_URI).asResource();
             // recognize rdf:type
             Resource type = qs.get(SPARQLBuilderString.SELECT_VARIABLE_TYPE).asResource();
 
             MREData data;
 
             // first, check if previous result exist
             if (map.containsKey(uri)) {
                 LOG.debug("Previous result of type={} has uri={}", type, uri);
 
                 // one instance should have more values of any attribute, so it is stored in more QuerySolution instances.
                 data = map.get(uri);
                 data.setType(type);
 
             } else {
 
                 // create new instance for the query solution
                 data = createInstance(null, uri, type);
                 if (data != null) {
                     LOG.debug("New instance for class={}, type={}, uri={}", data.getClass(), type, uri);
                     map.put(uri, data);
                 }
             }
 
             // initialise instance fields by values in QuerySolution.
             builderValuesSet(data, qs);
         });
 
         // stream map values
         return map.values().stream();
     }
 
     /**
      * Get the list of MREData instances found by rdf:type.
      *
      * @param type RDF class as a type for instances.
      * @return List of MREData instances.
      */
     @Override
     public List<MREData> list(String type) {
         LOG.info("List by type as String {}", type);
 
         MREData example = createInstance(type);
         return list(example);
     }
 
     /**
      * Get the list of MREData instances found by rdf:type.
      *
      * @param type RDF class as a type for instances.
      * @return List of MREData instances.
      */
     @Override
     public List<MREData> list(Resource type) {
         LOG.info("List by type {}", type.getURI());
 
         MREData example = createInstance(type);
         return list(example);
     }
 
     /**
      * Get list of MREData instances found by example.
      *
      * @param example An example.
      * @return List of MREData instances.
      */
     @Override
     public List<MREData> list(MREData example) {
         LOG.info("List by example {}", example.getClass());
 
         return stream(example).collect(Collectors.toList());
     }
 
     /**
      * Get list of MREData instances found by example.
      *
      * @param example An example.
      * @return List of MREData instances.
      */
     @Override
     public List<MREData> listAll(MREData example) {
         LOG.info("List all by example class {}", example);
 
         return streamAll(example).collect(Collectors.toList());
     }
 
     /**
      * Get the MREData instance by its URI.
      *
      * @param resourceUri The URI as a String.
      * @return Null or MREData instance.
      */
     @Override
     public MREData get(String resourceUri) {
 
         Query queryType = sparqlBuilder.selectType(resourceUri);
         return get(queryType, ResourceFactory.createResource(resourceUri));
     }
 
     @Override
     public MREData getAll(String resourceUri) {
         Query queryType = sparqlBuilder.selectType(resourceUri);
         return getAll(queryType, ResourceFactory.createResource(resourceUri));
     }
 
     /**
      * Get the MREData instance by its URI and values of all fields with
      * primitive types.
      *
      * @param resourceUri The URI as a Resource.
      * @return Null or MREData instance.
      */
     @Override
     public MREData get(Resource resourceUri) {
 
         Query queryType = sparqlBuilder.selectType(resourceUri);
         return get(queryType, resourceUri);
     }
 
     /**
      * Get the MREData instance by its URI.
      *
      * @param resourceUri The URI as a Resource.
      * @return Null or MREData instance.
      */
     @Override
     public MREData getAll(Resource resourceUri) {
 
         Query queryType = sparqlBuilder.selectType(resourceUri);
         return getAll(queryType, resourceUri);
     }
 
     /**
      * Get the MREData instance by its URI and values of all fields with
      * primitive types.
      *
      * @param getRdfTypeQuery String for getting the instance rdf:type we have
      * to know because of creating a right MREData instance.
      * @param resourceUri The resource to get.
      * @return Null or MREData instance.
      */
     private MREData get(Query getRdfTypeQuery, Resource resourceUri) {
 
         List<QuerySolution> list = sparqlRepository.querySelect(getRdfTypeQuery);
 
         if (list.isEmpty()) {
             return null;
         }
 
         QuerySolution qs = list.get(0); // get only the first rdf:type value
         String type = qs.getResource("type").getURI();
         if (type == null) {
             return null;
         }
 
         MREData example = createInstance(type, resourceUri);
         example.setResource(resourceUri); // have to set instance URI
         return get(example);
     }
 
     /**
      * Get the MREData instance by its URI.
      *
      * @param getRdfTypeQuery String for getting the instance rdf:type we have
      * to know because of creating a right MREData instance.
      * @param resourceUri The resource to get.
      * @return Null or MREData instance.
      */
     private MREData getAll(Query getRdfTypeQuery, Resource resourceUri) {
 
         List<QuerySolution> list = sparqlRepository.querySelect(getRdfTypeQuery);
 
         if (list.isEmpty()) {
             return null;
         }
 
         QuerySolution qs = list.get(0); // get only the first rdf:type value
         String type = qs.getResource("type").getURI();
         if (type == null) {
             return null;
         }
 
         MREData example = createInstance(type, resourceUri);
         example.setResource(resourceUri); // have to set instance URI
         return getAll(example);
     }
 
     /**
      * Get one MREData instance by example and values of all fields with
      * primitive types.
      *
      * @param example An example.
      * @return Null or MREData instance.
      */
     @Override
     public MREData get(MREData example) {
         List<MREData> list = list(example);
 
         if (list.isEmpty()) {
             return null;
         }
 
         return list.get(0);
     }
 
     /**
      * Get one MREData instance by example.
      *
      * @param example An example.
      * @return Null or MREData instance.
      */
     @Override
     public MREData getAll(MREData example) {
         List<MREData> list = listAll(example);
 
         if (list.isEmpty()) {
             return null;
         }
 
         return list.get(0);
     }
 
     /**
      * User-defined SELECT query.
      *
      * @param query SPARQL.
      * @return Stream of QuerySolution instances.
      */
     @Override
     public Stream<QuerySolution> select(String query) {
         return sparqlRepository.querySelect(query).stream();
     }
 
     @Override
     public MREDataFieldValue[] builderValuesGet(Object instance) {
 
         List<MREDataBuilderConfig> config = builderBeanConfigGet(instance);
         MREDataFieldValue[] result = new MREDataFieldValue[config.size()];
         int i = 0;
 
         for (MREDataBuilderConfig c : config) {
             result[i] = new MREDataFieldValue();
             result[i].setConfig(c);
             result[i].getValue().add(builderFieldValueGet(instance, c.getField()));
             if (instance instanceof MREData) {
 
                 if (((MREData) instance).hasURI()) { // test as a prevention to generation of new uri
                     result[i].setSubject(((MREData) instance).getResource().getURI());
                 }
             }
 
             i++;
         }
 
         return result;
     }
 
     private Object builderFieldValueGet(Object instance, Field field) {
 
         Object object = null;
         field.setAccessible(true);
 
         try {
             object = field.get(instance);
         } catch (IllegalArgumentException | IllegalAccessException ex) {
             LOG.error("{}", ex.toString());
         }
         return object;
     }
 
     public void builderValuesSet(Object instance, QuerySolution qs) {
 
         MREDataFieldValue[] fields = builderValuesGet(instance);
         for (MREDataFieldValue field : fields) {
 
             String name = field.getName();
             Class type = field.getConfig().getField().getType();
 
             if (!qs.contains(name)) {
                 // no value for this field
                 LOG.debug("Missing field {} in QuerySolution", name);
                 continue;
             } else if (qs.get(name) == null) {
                 // no value for this field
                 LOG.debug("Null value for field {}", name);
                 continue;
             }
 
             // decide the field type
             if (type == Individual.class) {
 
                 Individual individual = ReflectionsUtil.lookupIndividual(qs.getResource(name));
                 LOG.debug("Set value for Individual field={}, class={}, value={}", name, type, individual);
 
                 builderFieldValueSet(instance, field.getConfig().getField(), individual);
 
             } else if (type == List.class) {
                 // the field is List of Java objects
 
                 // if field value is null - create new empty ArrayList()
                 List list = (List) builderFieldValueGet(instance, field.getConfig().getField());
                 if (list == null) {
                     list = new ArrayList();
                     builderFieldValueSet(instance, field.getConfig().getField(), list);
                 }
 
                 // create new instance and add to the list
                 Object object = builderCreateJavaObject(qs, field);
                 list.add(object);
 
             } else if (type == Set.class) {
                 // the field is Set of Java objects
 
                 // if field value is null - create new empty HashList()
                 Set set = (Set) builderFieldValueGet(instance, field.getConfig().getField());
                 if (set == null) {
                     set = new HashSet();
                     builderFieldValueSet(instance, field.getConfig().getField(), set);
                 }
 
                 // create new instance and add to the list
                 Object object = builderCreateJavaObject(qs, field);
                 set.add(object);
 
             } else if (type == Map.class) {
                 // the field is generic Map of Java objects
 
                 // if field value is null - create new empty HashList()
                 Map map = (Map) builderFieldValueGet(instance, field.getConfig().getField());
                 if (map == null) {
                     map = new HashMap();
                     builderFieldValueSet(instance, field.getConfig().getField(), map);
                 }
 
                 // create new instance, get key and add to the map
                 Object object = builderCreateJavaObject(qs, field);
                 Object key;
                 if (object instanceof MREData) {
                     // get ID for MREDeta instances
                     key = ((MREData) object).getId();
                 } else {
                     key = object.hashCode(); // TODO improve how to get key
                 }
                 map.put(key, object);
 
             } else {
 
                 // all other types
                 builderFieldValueSet(instance, field.getConfig().getField(), builderCreateJavaObject(qs, field));
             }
 
         }
     }
 
     private Object builderCreateJavaObject(QuerySolution qs, MREDataFieldValue field) {
 
         String name = field.getName();
         Class type = field.getConfig().getField().getType();
 
         if (qs.get(name).isLiteral()) {
 
             Object value = qs.getLiteral(name).getValue();
             LOG.debug("Set value for Literal field={}, class={}, value={}", name, type, value);
             return builderValueConvert(type, value);
 
         } else if (qs.get(name).isResource()) {
             Resource uri = qs.getResource(name);
             Object object;
             LOG.debug("Set value for Object field={}, class={}, value={}", name, type, uri);
 
             // get MREData instance for the URI
             object = getAll(uri);
 
             return object;
         }
 
         // something wrong?
         return null;
     }
 
     /**
      * Convert a value to the required Class type.
      *
      * @param type The type for the result.
      * @param value The value.
      * @return
      */
     private Object builderValueConvert(Class type, Object value) {
 
         if (value == null) {
 
             return null;
 
         } else if (type == value.getClass()) {
 
             LOG.debug("No conversion required for {} with value {}", value.getClass(), value);
             return value;
 
         } else if (type == List.class
                 || type == Set.class
                 || type == Map.class) {
 
             LOG.warn("No conversion for type {}, value {} ", type, value);
             return value;
 
         }
 
         Object newValue = value;
 
         /* use Spring's ConversionService */
         if (conversionService.canConvert(value.getClass(), type)) {
 
             newValue = conversionService.convert(value, type);
             LOG.debug("Conversion for {} to {}, value {}", value.getClass(), type, value);
 
         } else /* use own "local" conversions */ if (type == LocalDate.class && value instanceof XSDDateTime) {
 
             XSDDateTime date = (XSDDateTime) value;
             newValue = LocalDate.parse(date.toString());
 
         } else if (type == LocalDateTime.class && value instanceof XSDDateTime) {
 
             XSDDateTime datetime = (XSDDateTime) value;
             newValue = LocalDateTime.parse(datetime.toString());
 
         } else if (!isPrimitiveDataType(value) && type != newValue.getClass()) {
             LOG.error("Cannot convert {} to {}", value.getClass(), type);
         }
 
         return newValue;
     }
 
     private void builderFieldValueSet(Object instance, Field field, Object value) {
 
         field.setAccessible(true);
 
         try {
             field.set(instance, value);
         } catch (IllegalArgumentException | IllegalAccessException ex) {
             LOG.error("Unable to set value for field {}", field.getName(), ex);
         }
     }
 
     private List<MREDataBuilderConfig> builderBeanConfigGet(Object instance) {
 
         if (instance == null) {
             return null;
         }
 
         if (converterConfig.containsKey(instance.getClass())) {
             return converterConfig.get(instance.getClass());
         }
 
         return builderAnnotationsGet(instance);
     }
 
     private List<MREDataBuilderConfig> builderAnnotationsGet(Object instance) {
 
         List<MREDataBuilderConfig> fieldsMapping = new ArrayList<>();
         List<Field> allFields = FieldUtils.getAllFieldsList(instance.getClass());
         MREDataURIBasename[] annotationNSData = instance.getClass().getAnnotationsByType(MREDataURIBasename.class);
         MREDataOntology[] annotationOntology = instance.getClass().getAnnotationsByType(MREDataOntology.class);
 
         // MRE name space for data.
         String nsData = NS.ID;
 
         // MRE name space when not set.
         String ontology = MRE.NS;
 
         if (annotationNSData != null && annotationNSData.length > 0) {
             nsData = annotationNSData[0].basename();
         }
 
         LOG.debug("Java {} --> instance base URI {}", instance.getClass(), nsData);
 
         if (annotationOntology != null && annotationOntology.length > 0) {
             ontology = annotationOntology[0].namespace();
         } else {
             LOG.warn("Java {} does not have an ontology annotation {}.", instance.getClass(), MREDataOntology.class);
         }
 
         String uri;
         for (Field f : allFields) {
 
             if (f.getName().equals("resource")
                     || java.lang.reflect.Modifier.isStatic(f.getModifiers())
                     || java.lang.reflect.Modifier.isFinal(f.getModifiers())) {
                 continue;
             }
 
             if (f.isAnnotationPresent(MREDataPropertyName.class)) {
                 MREDataPropertyName mREDataPropertyName = f.getAnnotation(MREDataPropertyName.class);
                 uri = ontology + mREDataPropertyName.name();
 
             } else if (f.isAnnotationPresent(MREDataPropertyURI.class)) {
                 MREDataPropertyURI mREDataPropertyURI = f.getAnnotation(MREDataPropertyURI.class);
                 uri = mREDataPropertyURI.uri();
             } else {
                 uri = ontology + f.getName();
             }
 
             LOG.debug("Java {}, field '{}' --> '{}'", instance.getClass(), f.getName(), uri);
 
             MREDataBuilderConfig converterData = new MREDataBuilderConfig();
             converterData.setClazz(instance.getClass());
             converterData.setOntology(ontology);
             //converterData.setOntologyClass(ontology);
             converterData.setField(f);
             converterData.setDataNamespace(nsData);
             converterData.setProperty(ResourceFactory.createProperty(uri));
 
             fieldsMapping.add(converterData);
         }
 
         // add to config map
         converterConfig.put(instance.getClass(), fieldsMapping);
 
         // return fields mapping for this instance
         return fieldsMapping;
     }
 
     @Override
     public boolean isPrimitiveDataType(Object object) {
 
         return object instanceof Byte
                 || object instanceof Short
                 || object instanceof Integer
                 || object instanceof Long
                 || object instanceof Float
                 || object instanceof Double
                 || object instanceof Character
                 || object instanceof String
                 || object instanceof Boolean;
     }
 
 //     public static void builderValuesSet(Object instance, Model model) {
 //
 //        // TODO implement
 //        // setFieldValue(Object instance, Field field, Object value)
 //    }
 }