/*
 * 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.jena.assembler.test;

import java.util.*;

import org.apache.jena.assembler.* ;
import org.apache.jena.assembler.assemblers.* ;
import org.apache.jena.assembler.exceptions.* ;
import org.apache.jena.rdf.model.* ;
import org.apache.jena.reasoner.* ;
import org.apache.jena.reasoner.rulesys.* ;
import org.apache.jena.reasoner.transitiveReasoner.* ;

public class TestReasonerFactoryAssembler extends AssemblerTestBase
    {
    private final Assembler ASSEMBLER = new ReasonerFactoryAssembler();

    public TestReasonerFactoryAssembler( String name )
        { super( name ); }

    @Override protected Class<? extends Assembler> getAssemblerClass()
        { return ReasonerFactoryAssembler.class; }

    public void testReasonerFactoryAssemblerType()
        { testDemandsMinimalType( new ReasonerFactoryAssembler(), JA.ReasonerFactory );  }

    public void testCreateReasonerFactory()
        {
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory" );
        assertInstanceOf( GenericRuleReasonerFactory.class, ASSEMBLER.open( root ) );
        }

    public void testStandardReasonerURLs()
        {
        testReasonerURL( GenericRuleReasonerFactory.class, GenericRuleReasonerFactory.URI );
        testReasonerURL( TransitiveReasonerFactory.class, TransitiveReasonerFactory.URI );
        testReasonerURL( RDFSRuleReasonerFactory.class, RDFSRuleReasonerFactory.URI );
        testReasonerURL( OWLFBRuleReasonerFactory.class, OWLFBRuleReasonerFactory.URI );
        testReasonerURL( OWLMicroReasonerFactory.class, OWLMicroReasonerFactory.URI );
        testReasonerURL( OWLMiniReasonerFactory.class, OWLMiniReasonerFactory.URI );
        }

    public void testBadReasonerURLFails()
        {
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:reasonerURL bad:URL" );
        try
            { ASSEMBLER.open( root );
            fail( "should detected unknown reasoner" ); }
        catch (UnknownReasonerException e)
            { assertEquals( resource( "bad:URL" ), e.getURL() ); }
        }

    public static class MockBase implements ReasonerFactory
        {
        @Override
        public Reasoner create( Resource configuration )
            { return null; }

        @Override
        public Model getCapabilities()
            { return null; }

        @Override
        public String getURI()
            { return null; }
        }

    public static class MockFactory extends MockBase implements ReasonerFactory
        {
        public static final MockFactory instance = new MockFactory();

        public static ReasonerFactory theInstance() { return instance; }
        }

    public void testReasonerClassThrowsIfClassNotFound()
        {
        String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:noSuchClass";
        Resource root = resourceInModel( description );
        try
            { ASSEMBLER.open( root ); fail( "should trap missing class noSuchClass" ); }
        catch (CannotLoadClassException e)
            { assertEquals( "noSuchClass", e.getClassName() ); }
        }

    public void testReasonerClassThrowsIfClassNotFactory()
        {
        String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:java.util.ArrayList";
        Resource root = resourceInModel( description );
        try
            { ASSEMBLER.open( root ); fail( "should trap non-ReasonerFactory ArrayList" ); }
        catch (NotExpectedTypeException e)
            {
            assertEquals( root, e.getRoot() );
            assertEquals( ReasonerFactory.class, e.getExpectedType() );
            assertEquals( ArrayList.class, e.getActualType() );
            }
        }

    public void testReasonerClassUsesTheInstance()
        {
        String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:";
        String MockName = MockFactory.class.getName();
        Resource root = resourceInModel( description + MockName );
        assertEquals( MockFactory.instance, ASSEMBLER.open( root ) );
        }

    public void testReasonerClassInstantiatesIfNoInstance()
        {
        String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:";
        String MockName = MockBase.class.getName();
        Resource root = resourceInModel( description + MockName );
        assertInstanceOf( MockBase.class, ASSEMBLER.open( root ) );
        assertNotSame( MockFactory.instance, ASSEMBLER.open( root ) );
        }

    public void testMultipleURLsFails()
        {
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:reasonerURL bad:URL; x ja:reasonerURL another:bad/URL" );
        try
            { ASSEMBLER.open( root );
            fail( "should detected multiple reasoner URLs" ); }
        catch (NotUniqueException e)
            { assertEquals( JA.reasonerURL, e.getProperty() );
            assertEquals( root, e.getRoot() ); }
        }

    public void testOnlyGenericReasonerCanHaveRules()
        {
        String url = TransitiveReasonerFactory.URI;
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:rule '[->(a\\sP\\sb)]'; x ja:reasonerURL " + url );
        String ruleStringA = "[rdfs2:  (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)]";
        final RuleSet rules = RuleSet.create( ruleStringA );
        try
            { ASSEMBLER.open( new FixedObjectAssembler( rules ), root );
            fail( "only GenericRuleReasoners can have attached rules" ); }
        catch (CannotHaveRulesException e )
            {
            }
        }

    public void testSchema()
        {
        Model schema = model( "P rdf:type owl:ObjectProperty" );
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:schema S" );
        Assembler sub = new NamedObjectAssembler( resource( "S" ), schema );
        ReasonerFactory rf = (ReasonerFactory) ASSEMBLER.open( sub, root );
        Reasoner r = rf.create( null );
        assertIsomorphic( schema.getGraph(), ((FBRuleReasoner) r).getBoundSchema() );
        }

    public void testSingleRules()
        {
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:rules S" );
        String ruleStringA = "[rdfs2:  (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)]";
        final RuleSet rules = RuleSet.create( ruleStringA );
        Assembler mock = new AssemblerBase()
            {
            @Override
            public Object open( Assembler a, Resource root, Mode irrelevant )
                {
                assertEquals( root, resource( "S" ) );
                return rules;
                }
            };
        ReasonerFactory r = (ReasonerFactory) ASSEMBLER.open( mock, root );
        GenericRuleReasoner grr = (GenericRuleReasoner) r.create( null );
        assertEquals( new HashSet<>( rules.getRules() ), new HashSet<>( grr.getRules() ) );
        }

    public void testMultipleRules()
        {
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:rules S; x ja:rules T" );
        String ruleStringA = "[rdfs2:  (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)]";
        String ruleStringB = "[rdfs9:  (?x rdfs:subClassOf ?y), (?a rdf:type ?x) -> (?a rdf:type ?y)]";
        final RuleSet rulesA = RuleSet.create( ruleStringA );
        final RuleSet rulesB = RuleSet.create( ruleStringB );
        Assembler mock = new AssemblerBase()
            {
            @Override
            public Object open( Assembler a, Resource root, Mode irrelevant )
                {
                if (root.equals( resource( "S" ) )) return rulesA;
                if (root.equals( resource( "T" ) )) return rulesB;
                throw new RuntimeException( "unknown resource in mock: " + root );
                }
            };
        ReasonerFactory r = (ReasonerFactory) ASSEMBLER.open( mock, root );
        GenericRuleReasoner grr = (GenericRuleReasoner) r.create( null );
        HashSet<Rule> wanted = new HashSet<>();
        wanted.addAll( rulesA.getRules() );
        wanted.addAll( rulesB.getRules() );
        assertEquals( wanted, new HashSet<>( grr.getRules() ) );
        }

    protected void testReasonerURL( Class<?> wanted, String string )
        {
        Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:reasonerURL " + string );
        ReasonerFactory rf = (ReasonerFactory) ASSEMBLER.open( root );
        assertInstanceOf( wanted, rf );
        }
    }
