package org.simantics.modeling.scl.ontologymodule;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;

import org.simantics.Simantics;
import org.simantics.databoard.Bindings;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.uri.UnescapedChildMapOfResource;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.request.Read;
import org.simantics.layer0.Layer0;
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.constants.StringConstant;
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
import org.simantics.scl.compiler.elaboration.expressions.ESimpleLambda;
import org.simantics.scl.compiler.elaboration.expressions.EVariable;
import org.simantics.scl.compiler.elaboration.expressions.Expression;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.elaboration.macros.MacroRule;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.elaboration.relations.SCLEntityType;
import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.module.ImportDeclaration;
import org.simantics.scl.compiler.module.LazyModule;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.TVar;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
import org.simantics.scl.compiler.types.kinds.Kinds;
import org.simantics.scl.runtime.SCLContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import gnu.trove.map.hash.THashMap;
import gnu.trove.procedure.TObjectProcedure;

public class OntologyModule extends LazyModule {
    private static final Logger LOGGER = LoggerFactory.getLogger(OntologyModule.class);
    
    private static final String DB_MODULE = "Simantics/DB";
    private static final String VARIABLE_MODULE = "Simantics/Variable";
    private static final Collection<ImportDeclaration> DEPENDENCIES = Arrays.asList(
            new ImportDeclaration(DB_MODULE, null),
            new ImportDeclaration(VARIABLE_MODULE, null)
            );
    private static final TCon RESOURCE = Types.con(DB_MODULE, "Resource");
    private static final TCon BROWSABLE = Types.con(DB_MODULE, "Browsable");
    private static final TCon VARIABLE = Types.con(VARIABLE_MODULE, "Variable");
    
    Resource ontology;
    String defaultLocalName;
    THashMap<Resource,Map<String,Resource>> childMaps = new THashMap<Resource,Map<String,Resource>>();
    
    public OntologyModule(ReadGraph graph, String moduleName) throws DatabaseException {
        super(moduleName);
        ontology = graph.getResource(moduleName);
        readDefaultLocalName(graph);
        childMaps.put(ontology, createLocalMap(graph, ontology));
    }
    
    private void readDefaultLocalName(ReadGraph graph) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        defaultLocalName = graph.getPossibleRelatedValue(ontology, L0.Ontology_defaultLocalName);
        if(defaultLocalName == null)
            defaultLocalName = "";
    }

	@Override
    public String getDefaultLocalName() {
    	return defaultLocalName;
    }

    @Override
    public List<ImportDeclaration> getDependencies() {
        //return DEPENDENCIES;
        return Collections.emptyList();
    }
    
    private static interface ResourceSearchResult {}
    private static class JustResource implements ResourceSearchResult {
        public final Resource resource;
        public JustResource(Resource resource) {
            this.resource = resource;
        }   
    }
    private static class ResourceAndSuffix implements ResourceSearchResult {
        public final Resource resource;
        public final String suffix;
        public ResourceAndSuffix(Resource resource, String suffix) {
            this.resource = resource;
            this.suffix = suffix;
        }  
    }
    
    private ResourceSearchResult getResourceOrSuffixedResource(String name) {
        Map<String,Resource> localMap = childMaps.get(ontology); 
        if(localMap == null)
            return null;
        Resource parent = ontology;
        while(true) {
            int p = name.indexOf('.');
            if(p < 0)
                break;
            String localName = name.substring(0, p);
            parent = localMap.get(localName);
            if(parent == null)
                return null;
            name = name.substring(p+1);
            
            // Get new local map
            localMap = getLocalMap(parent);
            if(localMap == null)
                return null;
        }
        Resource child = localMap.get(name);
        if(child != null)
            return new JustResource(child);
        else
            return new ResourceAndSuffix(parent, name);
    }
    
    private Resource getResource(String name) {
        ResourceSearchResult searchResult = getResourceOrSuffixedResource(name);
        if(searchResult instanceof JustResource)
            return ((JustResource)searchResult).resource;
        else
            return null;
    }
    
    private Map<String, Resource> getLocalMap(Resource parent) {
        Map<String, Resource> localMap = childMaps.get(parent);
        if(localMap == null) {
            if(childMaps.contains(parent))
                return null;
            localMap = createLocalMap(parent);
            childMaps.put(parent, localMap);
        }
        return localMap;
    }

    private static Map<String, Resource> createLocalMap(final Resource parent) {
        ReadGraph graph = (ReadGraph)SCLContext.getCurrent().get("graph");
        if(graph != null)
            return createLocalMap(graph, parent);
        else
            try {
                return Simantics.getSession().syncRequest(new Read<Map<String, Resource>>() {
                    @Override
                    public Map<String, Resource> perform(ReadGraph graph) throws DatabaseException {
                        return createLocalMap(graph, parent);
                    }
                });
            } catch(DatabaseException e) {
                e.printStackTrace();
                return null;
            }   
    }

    private static Map<String, Resource> createLocalMap(ReadGraph graph, Resource parent) {
        try {
            return graph.syncRequest(new UnescapedChildMapOfResource(parent));
        } catch (DatabaseException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    @FunctionalInterface
    private static interface ResourceFunctionGenerator {
        SCLValue createValue(Name name, Resource resource);
    }
    
    private static class RelatedValueMacroRule implements MacroRule {
        private final Resource relation;
        private final SCLRelationInfo relationInfo;
        private final boolean optionalValue;
        
        public RelatedValueMacroRule(Resource relation, SCLRelationInfo relationInfo, boolean optionalValue) {
            this.relation = relation;
            this.relationInfo = relationInfo;
            this.optionalValue = optionalValue;
        }

        private Expression applyWithSubject(SimplificationContext context, Type subjectType, Expression evidence, Expression subject) {
            if(Types.equals(subjectType, RESOURCE))
                return new EApply(
                        Locations.NO_LOCATION,
                        Types.READ_GRAPH,
                        context.getConstant(Name.create(DB_MODULE, optionalValue ? "possibleRelatedValue2" : "relatedValue2"), relationInfo.rangeType),
                        subject,
                        new EExternalConstant(relation, RESOURCE));
            else if(Types.equals(subjectType, VARIABLE))
                return new EApply(
                        Locations.NO_LOCATION,
                        Types.READ_GRAPH,
                        context.getConstant(Name.create(DB_MODULE, optionalValue ? "untypedPossiblePropertyValue" : "untypedPropertyValue"), relationInfo.rangeType),
                        subject,
                        new ELiteral(new StringConstant(relationInfo.name)));
            else
                return new EApply(
                        Locations.NO_LOCATION,
                        Types.READ_GRAPH,
                        context.getConstant(Name.create(DB_MODULE, optionalValue ? "genericPossibleRelatedValue" : "genericRelatedValue"), subjectType, relationInfo.rangeType),
                        evidence,
                        subject,
                        new EExternalConstant(relation, RESOURCE));
        }
        
        @Override
        public Expression apply(SimplificationContext context, Type[] typeParameters, EApply apply) {
            Type subjectType = typeParameters[0];
            if(apply.parameters.length == 1) {
                Variable subject = new Variable("subject", subjectType);
                return new ESimpleLambda(subject, applyWithSubject(context, subjectType, apply.parameters[0], new EVariable(subject)));
            }
            else if(apply.parameters.length >= 2) {
                Expression valueReplacement = applyWithSubject(context, subjectType, apply.parameters[0], apply.parameters[1]);
                if(apply.parameters.length == 2)
                    return valueReplacement;
                else {
                    apply.set(valueReplacement, Arrays.copyOfRange(apply.parameters, 2, apply.parameters.length));
                    return apply;
                }
            }
            else {
                LOGGER.error("Application of relation following functions should have at least one parameter (the evidence of Browsable).");
                return null;
            }
        }
    }
    
    private final static HashMap<String, ResourceFunctionGenerator> VALUE_GENERATOR_MAP = new HashMap<>();
    static {
        TVar A = Types.var(Kinds.STAR);
        VALUE_GENERATOR_MAP.put("value", (name, resource) -> {
            SCLRelationInfo relationInfo = SCLRelationInfoRequest.getRelationInfo(resource);
            if(relationInfo == null)
                return null;
            
            SCLValue value = new SCLValue(name);
            value.setType(Types.forAll(A, Types.function(Types.pred(BROWSABLE, A), Types.functionE(A, Types.READ_GRAPH, relationInfo.rangeType))));
            value.setMacroRule(new RelatedValueMacroRule(resource, relationInfo, false));
            return value;
        });
        VALUE_GENERATOR_MAP.put("possibleValue", (name, resource) -> {
            SCLRelationInfo relationInfo = SCLRelationInfoRequest.getRelationInfo(resource);
            if(relationInfo == null)
                return null;
            
            SCLValue value = new SCLValue(name);
            value.setType(Types.forAll(A, Types.function(Types.pred(BROWSABLE, A), Types.functionE(A, Types.READ_GRAPH, Types.apply(Types.MAYBE, relationInfo.rangeType)))));
            value.setMacroRule(new RelatedValueMacroRule(resource, relationInfo, true));
            return value;
        });
    }
   
    @Override
    protected SCLValue createValue(String name) {
        ResourceSearchResult searchResult = getResourceOrSuffixedResource(name);
        if(searchResult instanceof JustResource) {
            Resource resource = ((JustResource)searchResult).resource;
            SCLValue value = new SCLValue(Name.create(getName(), name));
            value.setType(RESOURCE);
            value.setExpression(new EExternalConstant(resource, RESOURCE));
            value.setInlineInSimplification(true);
            return value;        
        }
        else if(searchResult instanceof ResourceAndSuffix){
            ResourceAndSuffix resourceAndSuffix = (ResourceAndSuffix)searchResult;
            ResourceFunctionGenerator generator = VALUE_GENERATOR_MAP.get(resourceAndSuffix.suffix);
            if(generator == null)
                return null;
            else
                return generator.createValue(Name.create(getName(), name), resourceAndSuffix.resource);
        }
        else
            return null;
    }
    
    @Override
    protected SCLRelation createRelation(String name) {
        final Resource resource = getResource(name);
        if(resource == null)
            return null;
        ReadGraph graph = (ReadGraph)SCLContext.getCurrent().get("graph");
        if(graph != null)
            return createRelation(graph, resource);
        else
            try {
                return Simantics.getSession().syncRequest(new Read<SCLRelation>() {
                    @Override
                    public SCLRelation perform(ReadGraph graph) throws DatabaseException {
                        return createRelation(graph, resource);
                    }
                });
            } catch(DatabaseException e) {
                e.printStackTrace();
                return null;
            }   
    }
    
    public static SCLRelation createRelation(ReadGraph graph, Resource relation) {
        try {
            Layer0 L0 = Layer0.getInstance(graph);
            if(!graph.isInstanceOf(relation, L0.Relation))
                return null;
            if(graph.isInstanceOf(relation, L0.PropertyRelation) && graph.isInstanceOf(relation, L0.FunctionalRelation)) {
                Type valueType = getValueType(graph, relation);
                if(valueType != null)
                    return new GraphPropertyRelation(relation, valueType);
            }
            
            Resource inverseRelation = graph.getPossibleInverse(relation);
            return new GraphRelation(relation, getSelectivity(graph, relation),
                    inverseRelation, getSelectivity(graph, inverseRelation));
        } catch(DatabaseException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    @Override
    protected SCLEntityType createEntityType(String name) {
        final Resource resource = getResource(name);
        if(resource == null)
            return null;
        ReadGraph graph = (ReadGraph)SCLContext.getCurrent().get("graph");
        if(graph != null)
            return createEntityType(graph, resource);
        else
            try {
                return Simantics.getSession().syncRequest(new Read<SCLEntityType>() {
                    @Override
                    public SCLEntityType perform(ReadGraph graph) throws DatabaseException {
                        return createEntityType(graph, resource);
                    }
                });
            } catch(DatabaseException e) {
                e.printStackTrace();
                return null;
            }   
    }
    
    private SCLEntityType createEntityType(ReadGraph graph, Resource type) {
        try {
            Layer0 L0 = Layer0.getInstance(graph);
            if(!graph.isInstanceOf(type, L0.Type))
                return null;
            return new GraphEntityType(graph, type);
        } catch(DatabaseException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    private static double getSelectivity(ReadGraph graph, Resource relation) throws DatabaseException {
        if(relation == null)
            return Double.POSITIVE_INFINITY;
        Layer0 L0 = Layer0.getInstance(graph);
        if(graph.isInstanceOf(relation, L0.FunctionalRelation))
            return 1.0;
        else
            return 10.0;
    }

    private static Type getValueType(ReadGraph graph, Resource relation) throws DatabaseException {
        Layer0 L0 = Layer0.getInstance(graph);
        Type valueType = parseValueType((String)graph.getPossibleRelatedValue(relation, L0.RequiresValueType, Bindings.STRING));
        if(valueType != null)
            return valueType;
        Resource range = graph.getPossibleObject(relation, L0.HasRange);
        if(range != null) {
            for(Resource valueTypeLiteral : graph.getAssertedObjects(range, L0.HasValueType)) {
                valueType = parseValueType((String)graph.getValue(valueTypeLiteral, Bindings.STRING));
                if(valueType != null)
                    return valueType;
            }
        }
        return null;
    }
    
    private static Type parseValueType(String valueTypeString) {
        if(valueTypeString == null)
            return null;
        try {
            return Types.parseType(valueTypeString);
        } catch (SCLTypeParseException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    @Override
    public void findValuesForPrefix(String prefix,
            NamespaceFilter filter,
            TObjectProcedure<SCLValue> proc) {
        Map<String,Resource> localMap = childMaps.get(ontology); 
        if(localMap == null)
            return;
        String namePrefix = "";
        while(true) {
            int p = prefix.indexOf('.');
            if(p < 0)
                break;
            String localName = prefix.substring(0, p);
            Resource newParent = localMap.get(localName);
            if(newParent == null)
                return;
            prefix = prefix.substring(p+1);
            namePrefix = namePrefix + localName + ".";
            
            // Get new local map
            localMap = getLocalMap(newParent);
            if(localMap == null)
                return;
        }
        for(String name : localMap.keySet())
            if(name.startsWith(prefix) && filter.isValueIncluded(name))
                proc.execute(getValue(namePrefix+name));
    }
    
    @Override
    public void findValuesForPrefix(String prefix, NamespaceFilter filter, Consumer<SCLValue> consumer) {
        Map<String,Resource> localMap = childMaps.get(ontology); 
        if(localMap == null)
            return;
        String namePrefix = "";
        while(true) {
            int p = prefix.indexOf('.');
            if(p < 0)
                break;
            String localName = prefix.substring(0, p);
            Resource newParent = localMap.get(localName);
            if(newParent == null)
                return;
            prefix = prefix.substring(p+1);
            namePrefix = namePrefix + localName + ".";
            
            // Get new local map
            localMap = getLocalMap(newParent);
            if(localMap == null)
                return;
        }
        for(String name : localMap.keySet())
            if(name.startsWith(prefix) && filter.isValueIncluded(name))
                consumer.accept(getValue(namePrefix+name));
    }

    @Override
    public void findTypesForPrefix(String prefix, NamespaceFilter instance, Consumer<TCon> consumer) {
        
    }

    @Override
    public void dispose() {
        childMaps.clear();
        childMaps = null;
        ontology = null;
    }
    
    @Override
    public String toString() {
        return new StringBuilder().append("OntologyModule ").append(getName()).toString();
    }

    @Override
    public ClassLoader getParentClassLoader() {
        return getClass().getClassLoader();
    }
}