/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.rya.forwardchain.rule;

import java.util.Arrays;

import org.apache.rya.api.domain.VarNameUtils;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.model.vocabulary.FOAF;
import org.eclipse.rdf4j.model.vocabulary.OWL;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.model.vocabulary.RDFS;
import org.eclipse.rdf4j.query.algebra.StatementPattern;
import org.eclipse.rdf4j.query.algebra.Var;
import org.eclipse.rdf4j.query.parser.ParsedGraphQuery;
import org.eclipse.rdf4j.query.parser.sparql.SPARQLParser;
import org.junit.Assert;
import org.junit.Test;

import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;

public class SpinConstructRuleTest {
    private static final ValueFactory VF = SimpleValueFactory.getInstance();
    private static final SPARQLParser PARSER = new SPARQLParser();

    private static final IRI RL_CAX_SCO = VF.createIRI("http://example.org/rl/cax-sco");
    private static final IRI RL_SCM_CLS = VF.createIRI("http://example.org/rl/scm-cls");
    private static final IRI RL_PRP_SPO1 = VF.createIRI("http://example.org/rl/prp-spo");
    private static final IRI LIVING_THING = VF.createIRI("http://example.org/LivingThing");

    private static Var c(Value val) {
        return VarNameUtils.createUniqueConstVar(val);
    }
    private static Var ac(Value val) {
        Var v = c(val);
        v.setAnonymous(true);
        return v;
    }

    @Test
    public void testEmptyWhere() throws Exception {
        String text = "CONSTRUCT {\n"
                + "  ?this a <" + LIVING_THING.stringValue() + "> .\n"
                + "} WHERE { }";
        ParsedGraphQuery query = (ParsedGraphQuery) PARSER.parseQuery(text, null);
        SpinConstructRule rule = new SpinConstructRule(FOAF.PERSON, VF.createIRI("urn:person-is-living"), query);
        Multiset<StatementPattern> expectedAntecedents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("this"), c(RDF.TYPE), c(FOAF.PERSON))));
        Multiset<StatementPattern> expectedConsequents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("subject"), new Var("predicate", RDF.TYPE), new Var("object", LIVING_THING))));
        Assert.assertEquals(expectedAntecedents, HashMultiset.create(rule.getAntecedentPatterns()));
        Assert.assertEquals(expectedConsequents, HashMultiset.create(rule.getConsequentPatterns()));
        Assert.assertFalse(rule.hasAnonymousConsequent());
        // Basic pattern matches
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDF.TYPE), c(LIVING_THING))));
        // Broader patterns match (variables in place of constants)
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDF.TYPE), new Var("y"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), new Var("y"), c(LIVING_THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("a"), new Var("b"), new Var("c"))));
        // Narrower patterns match (constants in place of variables)
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(RDF.TYPE), c(RDF.TYPE), c(LIVING_THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(FOAF.MBOX), c(RDF.TYPE), new Var("y"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(RDF.ALT), new Var("y"), c(LIVING_THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(RDF.BAG), new Var("b"), new Var("c"))));
        // Incompatible patterns don't match (different constants)
        Assert.assertFalse(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBCLASSOF), new Var("y"))));
        Assert.assertFalse(rule.canConclude(new StatementPattern(new Var("x"), new Var("y"), c(FOAF.PERSON))));
        Assert.assertFalse(rule.canConclude(new StatementPattern(c(RDF.TYPE), c(RDF.TYPE), c(RDF.TYPE))));
    }

    @Test
    public void testThisUnbound() throws Exception {
        String text = "CONSTRUCT {\n"
                + "  ?ind a ?superclass .\n"
                + "} WHERE {\n"
                + "  ?ind a ?subclass .\n"
                + "  ?subclass rdfs:subClassOf ?superclass .\n"
                + "}";
        ParsedGraphQuery query = (ParsedGraphQuery) PARSER.parseQuery(text, null);
        SpinConstructRule rule = new SpinConstructRule(OWL.THING, RL_CAX_SCO, query);
        Multiset<StatementPattern> expectedAntecedents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("subclass"), ac(RDFS.SUBCLASSOF), new Var("superclass")),
                new StatementPattern(new Var("ind"), ac(RDF.TYPE), new Var("subclass"))));
        Multiset<StatementPattern> expectedConsequents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("subject"), new Var("predicate", RDF.TYPE), new Var("object"))));
        Assert.assertEquals(expectedAntecedents, HashMultiset.create(rule.getAntecedentPatterns()));
        Assert.assertEquals(expectedConsequents, HashMultiset.create(rule.getConsequentPatterns()));
        Assert.assertFalse(rule.hasAnonymousConsequent());
        // Basic pattern matches
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDF.TYPE), new Var("y"))));
        // Broader patterns match (variables in place of constants)
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("a"), new Var("b"), new Var("c"))));
        // Narrower patterns match (constants in place of variables)
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(RDF.TYPE), c(RDF.TYPE), c(RDF.TYPE))));
        // Incompatible patterns don't match (different constants)
        Assert.assertFalse(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBCLASSOF), new Var("y"))));
    }

    @Test
    public void testMultipleConsequents() throws Exception {
        String text = "CONSTRUCT {\n"
                // actual rule is "?this subClassOf ?this", but reflexive construct patterns produce
                // bnodes due to an openrdf bug, resulting in incorrect matches
                // TODO: is the above comment still a concern with RDF4J? bnodes
                // don't appear to be produced with RDF4J
                + "  ?this rdfs:subClassOf ?something .\n"
                + "  ?this owl:equivalentClass ?something .\n"
                + "  ?this rdfs:subClassOf owl:Thing .\n"
                + "  owl:Nothing rdfs:subClassOf ?this .\n"
                + "} WHERE { }";
        ParsedGraphQuery query = (ParsedGraphQuery) PARSER.parseQuery(text, null);
        SpinConstructRule rule = new SpinConstructRule(OWL.CLASS, RL_SCM_CLS, query);
        Multiset<StatementPattern> expectedAntecedents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("this"), c(RDF.TYPE), c(OWL.CLASS))));
        Multiset<StatementPattern> expectedConsequents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("subject"), new Var("predicate", RDFS.SUBCLASSOF), new Var("object")),
                new StatementPattern(new Var("subject"), new Var("predicate", OWL.EQUIVALENTCLASS), new Var("object")),
                new StatementPattern(new Var("subject"), new Var("predicate", RDFS.SUBCLASSOF), new Var("object", OWL.THING)),
                new StatementPattern(new Var("subject", OWL.NOTHING), new Var("predicate", RDFS.SUBCLASSOF), new Var("object"))));
        Assert.assertEquals(expectedAntecedents, HashMultiset.create(rule.getAntecedentPatterns()));
        Assert.assertEquals(expectedConsequents, HashMultiset.create(rule.getConsequentPatterns()));
        // Basic pattern matches
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBCLASSOF), new Var("y"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(OWL.EQUIVALENTCLASS), new Var("y"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBCLASSOF), c(OWL.THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), c(RDFS.SUBCLASSOF), new Var("y"))));
        // Broader patterns match (variables in place of constants)
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("a"), new Var("b"), new Var("c"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("a"), new Var("b"), c(OWL.THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), new Var("b"), new Var("c"))));
        // Narrower patterns match (constants in place of variables)
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(FOAF.PERSON), c(RDFS.SUBCLASSOF), new Var("x"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(FOAF.PERSON), c(OWL.EQUIVALENTCLASS), c(FOAF.PERSON))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), c(RDFS.SUBCLASSOF), c(FOAF.PERSON))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), c(OWL.EQUIVALENTCLASS), c(FOAF.PERSON))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), c(OWL.EQUIVALENTCLASS), c(OWL.THING))));
        // Incompatible patterns don't match (different constants)
        Assert.assertFalse(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBPROPERTYOF), c(OWL.THING))));
    }

    @Test
    public void testGeneralConsequent() throws Exception {
        String text = "CONSTRUCT {\n"
                + "  ?x ?p2 ?y"
                + "} WHERE {\n"
                + "  ?x ?p1 ?y .\n"
                + "  ?p1 rdfs:subPropertyOf ?p2 .\n"
                + "}";
        ParsedGraphQuery query = (ParsedGraphQuery) PARSER.parseQuery(text, null);
        SpinConstructRule rule = new SpinConstructRule(OWL.THING, RL_PRP_SPO1, query);
        Multiset<StatementPattern> expectedAntecedents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("p1"), ac(RDFS.SUBPROPERTYOF), new Var("p2")),
                new StatementPattern(new Var("x"), new Var("p1"), new Var("y"))));
        Multiset<StatementPattern> expectedConsequents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("subject"), new Var("predicate"), new Var("object"))));
        Assert.assertEquals(expectedAntecedents, HashMultiset.create(rule.getAntecedentPatterns()));
        Assert.assertEquals(expectedConsequents, HashMultiset.create(rule.getConsequentPatterns()));
        Assert.assertFalse(rule.hasAnonymousConsequent());
        // Basic pattern matches
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("a"), new Var("b"), new Var("c"))));
        // Narrower patterns match (constants in place of variables)
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBPROPERTYOF), c(OWL.THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), new Var("prop"), c(OWL.THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(FOAF.PERSON), c(RDFS.SUBCLASSOF), new Var("x"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), c(RDFS.SUBCLASSOF), c(FOAF.PERSON))));
    }

    @Test
    public void testAnonymousConsequent() throws Exception {
        String text = "CONSTRUCT {\n"
                + "  ?x ?p2 _:something"
                + "} WHERE {\n"
                + "  ?x ?p1 ?y .\n"
                + "  ?p1 rdfs:subPropertyOf ?p2 .\n"
                + "}";
        ParsedGraphQuery query = (ParsedGraphQuery) PARSER.parseQuery(text, null);
        SpinConstructRule rule = new SpinConstructRule(OWL.THING, RL_PRP_SPO1, query);
        Multiset<StatementPattern> expectedAntecedents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("p1"), ac(RDFS.SUBPROPERTYOF), new Var("p2")),
                new StatementPattern(new Var("x"), new Var("p1"), new Var("y"))));
        Assert.assertEquals(expectedAntecedents, HashMultiset.create(rule.getAntecedentPatterns()));
        // should have detected anonymous node
        Assert.assertTrue(rule.hasAnonymousConsequent());
        Var anonymousObject = new Var("object");
        anonymousObject.setAnonymous(true);
        Multiset<StatementPattern> expectedConsequents = HashMultiset.create(Arrays.asList(
                new StatementPattern(new Var("subject"), new Var("predicate"), anonymousObject)));
        Assert.assertEquals(expectedConsequents, HashMultiset.create(rule.getConsequentPatterns()));
        // Pattern matches should be unaffected by anonymous node status
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("a"), new Var("b"), new Var("c"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(new Var("x"), c(RDFS.SUBPROPERTYOF), c(OWL.THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), new Var("prop"), c(OWL.THING))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(FOAF.PERSON), c(RDFS.SUBCLASSOF), new Var("x"))));
        Assert.assertTrue(rule.canConclude(new StatementPattern(c(OWL.NOTHING), c(RDFS.SUBCLASSOF), c(FOAF.PERSON))));
    }
}