/*
 * 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.rdf.model.test.helpers;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.jena.graph.Node;
import org.apache.jena.graph.test.GraphTestBase;
import org.apache.jena.graph.test.NodeCreateUtils;
import org.apache.jena.rdf.model.*;
import org.apache.jena.rdf.model.test.AbstractModelTestBase;
import org.apache.jena.shared.PrefixMapping;
import org.apache.jena.util.CollectionFactory;
import org.junit.Ignore;

/**
    provides useful functionality for testing models, eg building small models
    from strings, testing equality, etc.

    Currently this class extends GraphTestBase and thus TestCase.

    TODO: Refactoring should remove the TestCase dependency in future.

 */
@Ignore // ignore this class as a test case.
public class ModelHelper extends GraphTestBase
{
	private ModelHelper(String name)
	{ super(name); }


	protected static Model aModel;

	static {
		aModel = ModelFactory.createDefaultModel();
		aModel.setNsPrefixes( PrefixMapping.Extended );
	}

	protected static final Model empty = ModelFactory.createDefaultModel();

	protected static Model extendedModel(AbstractModelTestBase base)
	{
		Model result = base.createModel();
		result.setNsPrefixes( PrefixMapping.Extended );
		return result;
	}

	protected static String nice( RDFNode n )
	{ return nice( n.asNode() ); }

	/**
        create a Statement in a given Model with (S, P, O) extracted by parsing a string.

        @param m the model the statement is attached to
        @param fact an "S P O" string.
        @return model.createStatement(S, P, O)
	 */
	public static Statement statement( Model m, String fact )
	{
		StringTokenizer st = new StringTokenizer( fact );
		Resource sub = resource( m, st.nextToken() );
		Property pred = property( m, st.nextToken() );
		RDFNode obj = rdfNode( m, st.nextToken() );
		return m.createStatement( sub, pred, obj );
	}

	public static Statement statement( String fact )
	{ return statement( aModel, fact ); }

	public static RDFNode rdfNode( Model m, String s )
	{ return m.asRDFNode( NodeCreateUtils.create( m, s ) ); }

	public static <T extends RDFNode> T rdfNode( Model m, String s, Class<T> c )
	{ return rdfNode( m, s ).as(  c  );  }

	public static Resource resource()
	{ return ResourceFactory.createResource(); }

	public static Resource resource( String s )
	{ return resource( aModel, s ); }

	public static Resource resource( Model m, String s )
	{ return (Resource) rdfNode( m, s ); }

	public static Property property( String s )
	{ return property( aModel, s ); }

	public static Property property( Model m, String s )
	{ return rdfNode( m, s ).as( Property.class ); }

	public static Literal literal( Model m, String s )
	{ return rdfNode( m, s ).as( Literal.class ); }

	/**
        Create an array of Statements parsed from a semi-separated string.

        @param m a model to serve as a statement factory
        @param facts a sequence of semicolon-separated "S P O" facts
        @return a Statement[] of the (S P O) statements from the string
	 */
	public static Statement [] statements( Model m, String facts )
	{
		ArrayList<Statement> sl = new ArrayList<>();
		StringTokenizer st = new StringTokenizer( facts, ";" );
		while (st.hasMoreTokens()) sl.add( statement( m, st.nextToken() ) );
		return sl.toArray( new Statement[sl.size()] );
	}

	/**
        Create an array of Resources from a whitespace-separated string

        @param m a model to serve as a resource factory
        @param items a whitespace-separated sequence to feed to resource
        @return a RDFNode[] of the parsed resources
	 */
	public static Resource [] resources( Model m, String items )
	{
		ArrayList<Resource> rl = new ArrayList<>();
		StringTokenizer st = new StringTokenizer( items );
		while (st.hasMoreTokens()) rl.add( resource( m, st.nextToken() ) );
		return rl.toArray( new Resource[rl.size()] );
	}

	/**
        Answer the set of resources given by the space-separated
        <code>items</code> string. Each resource specification is interpreted
        as per <code>resource</code>.
	 */
	public static Set<Resource> resourceSet( String items )
	{
		Set<Resource> result = new HashSet<>();
		StringTokenizer st = new StringTokenizer( items );
		while (st.hasMoreTokens()) result.add( resource(  st.nextToken() ) );
		return result;
	}

	/**
        add to a model all the statements expressed by a string.

        @param m the model to be updated
        @param facts a sequence of semicolon-separated "S P O" facts
        @return the updated model
	 */
	public static Model modelAdd( Model m, String facts )
	{
		StringTokenizer semis = new StringTokenizer( facts, ";" );
		while (semis.hasMoreTokens()) m.add( statement( m, semis.nextToken() ) );
		return m;
	}

	/**
        makes a model with a given reiifcation style, initialised with statements parsed
        from a string.

        @param facts a string in semicolon-separated "S P O" format
        @return a model containing those facts
	 */
	public static Model modelWithStatements( AbstractModelTestBase base, String facts )
	{ return modelAdd( createModel( base ), facts ); }

	/**
        make a model and give it Extended prefixes
	 */
	public static Model createModel( AbstractModelTestBase base )
	{
		Model result = base.createModel();
		result.setNsPrefixes( PrefixMapping.Extended );
		return result;
	}

	/**
        Answer a default model; it exists merely to abbreviate the rather long explicit
        invocation.

     	@return a new default [aka memory-based] model
	 */
	//public static Model createMemModel()
	//     { return ModelFactory.createDefaultModel(); }

	/**
        test that two models are isomorphic and fail if they are not.

        @param title a String appearing at the beginning of the failure message
        @param wanted the model value that is expected
        @param got the model value to check
        @exception junit.framework.AssertionFailedError the models are not isomorphic
	 */
	public static void assertIsoModels( String title, Model wanted, Model got )
	{
		if (wanted.isIsomorphicWith( got ) == false)
		{
			Map<Node, Object> map = CollectionFactory.createHashedMap();
			fail( title + ": expected " + nice( wanted.getGraph(), map ) + "\n but had " + nice( got.getGraph(), map ) );
		}
	}

	/**
        Fail if the two models are not isomorphic. See assertIsoModels(String,Model,Model).
	 */
	public static  void assertIsoModels( Model wanted, Model got )
	{ assertIsoModels( "models must be isomorphic", wanted, got ); }

}
