/*******************************************************************************
 * Copyright (c) 2014 Jeff Martin.
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Public License v3.0
 * which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/gpl.html
 * 
 * Contributors:
 *     Jeff Martin - initial API and implementation
 ******************************************************************************/
package cuchaz.enigma;

import static cuchaz.enigma.EntryFactory.*;
import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;

import java.util.Collection;
import java.util.Set;
import java.util.jar.JarFile;

import org.junit.Test;

import cuchaz.enigma.analysis.Access;
import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
import cuchaz.enigma.analysis.EntryReference;
import cuchaz.enigma.analysis.JarIndex;
import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
import cuchaz.enigma.mapping.BehaviorEntry;
import cuchaz.enigma.mapping.FieldEntry;
import cuchaz.enigma.mapping.MethodEntry;
import cuchaz.enigma.mapping.Translator;

public class TestJarIndexLoneClass
{
	private JarIndex m_index;
	
	public TestJarIndexLoneClass( )
	throws Exception
	{
		m_index = new JarIndex();
		m_index.indexJar( new JarFile( "build/libs/testLoneClass.obf.jar" ), false );
	}
	
	@Test
	public void obfEntries( )
	{
		assertThat( m_index.getObfClassEntries(), containsInAnyOrder(
			newClass( "cuchaz/enigma/inputs/Keep" ),
			newClass( "none/a" )
		) );
	}
	
	@Test
	public void translationIndex( )
	{
		assertThat( m_index.getTranslationIndex().getSuperclassName( "none/a" ), is( nullValue() ) );
		assertThat( m_index.getTranslationIndex().getSuperclassName( "cuchaz/enigma/inputs/Keep" ), is( nullValue() ) );
		assertThat( m_index.getTranslationIndex().getAncestry( "none/a" ), is( empty() ) );
		assertThat( m_index.getTranslationIndex().getAncestry( "cuchaz/enigma/inputs/Keep" ), is( empty() ) );
		assertThat( m_index.getTranslationIndex().getSubclassNames( "none/a" ), is( empty() ) );
		assertThat( m_index.getTranslationIndex().getSubclassNames( "cuchaz/enigma/inputs/Keep" ), is( empty() ) );
	}
	
	@Test
	public void access( )
	{
		assertThat( m_index.getAccess( newField( "none/a", "a" ) ), is( Access.Private ) );
		assertThat( m_index.getAccess( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( Access.Public ) );
		assertThat( m_index.getAccess( newField( "none/a", "b" ) ), is( nullValue() ) );
	}
	
	@Test
	public void classInheritance( )
	{
		ClassInheritanceTreeNode node = m_index.getClassInheritance( new Translator(), newClass( "none/a" ) );
		assertThat( node, is( not( nullValue() ) ) );
		assertThat( node.getObfClassName(), is( "none/a" ) );
		assertThat( node.getChildCount(), is( 0 ) );
	}

	@Test
	public void methodInheritance( )
	{
		MethodEntry source = newMethod( "none/a", "a", "()Ljava/lang/String;" );
		MethodInheritanceTreeNode node = m_index.getMethodInheritance( new Translator(), source );
		assertThat( node, is( not( nullValue() ) ) );
		assertThat( node.getMethodEntry(), is( source ) );
		assertThat( node.getChildCount(), is( 0 ) );
	}
	
	@Test
	public void classImplementations( )
	{
		ClassImplementationsTreeNode node = m_index.getClassImplementations( new Translator(), newClass( "none/a" ) );
		assertThat( node, is( nullValue() ) );
	}
	
	@Test
	public void methodImplementations( )
	{
		MethodEntry source = newMethod( "none/a", "a", "()Ljava/lang/String;" );
		MethodImplementationsTreeNode node = m_index.getMethodImplementations( new Translator(), source );
		assertThat( node, is( nullValue() ) );
	}
	
	@Test
	public void relatedMethodImplementations( )
	{
		Set<MethodEntry> entries = m_index.getRelatedMethodImplementations( newMethod( "none/a", "a", "()Ljava/lang/String;" ) );
		assertThat( entries, containsInAnyOrder( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ) );
	}
	
	@Test
	@SuppressWarnings( "unchecked" )
	public void fieldReferences( )
	{
		FieldEntry source = newField( "none/a", "a" );
		Collection<EntryReference<FieldEntry,BehaviorEntry>> references = m_index.getFieldReferences( source );
		assertThat( references, containsInAnyOrder(
			newFieldReferenceByConstructor( source, "none/a", "(Ljava/lang/String;)V" ),
			newFieldReferenceByMethod( source, "none/a", "a", "()Ljava/lang/String;" )
		) );
	}
	
	@Test
	public void behaviorReferences( )
	{
		assertThat( m_index.getBehaviorReferences( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( empty() ) );
	}
	
	@Test
	public void innerClasses( )
	{
		assertThat( m_index.getInnerClasses( "none/a" ), is( empty() ) );
	}
	
	@Test
	public void outerClass( )
	{
		assertThat( m_index.getOuterClass( "a" ), is( nullValue() ) );
	}
	
	@Test
	public void isAnonymousClass( )
	{
		assertThat( m_index.isAnonymousClass( "none/a" ), is( false ) );
	}
	
	@Test
	public void interfaces( )
	{
		assertThat( m_index.getInterfaces( "none/a" ), is( empty() ) );
	}
	
	@Test
	public void implementingClasses( )
	{
		assertThat( m_index.getImplementingClasses( "none/a" ), is( empty() ) );
	}
	
	@Test
	public void isInterface( )
	{
		assertThat( m_index.isInterface( "none/a" ), is( false ) );
	}
	
	@Test
	public void bridgeMethods( )
	{
		assertThat( m_index.getBridgeMethod( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( nullValue() ) );
	}
	
	@Test
	public void contains( )
	{
		assertThat( m_index.containsObfClass( newClass( "none/a" ) ), is( true ) );
		assertThat( m_index.containsObfClass( newClass( "none/b" ) ), is( false ) );
		assertThat( m_index.containsObfField( newField( "none/a", "a" ) ), is( true ) );
		assertThat( m_index.containsObfField( newField( "none/a", "b" ) ), is( false ) );
		assertThat( m_index.containsObfBehavior( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) );
		assertThat( m_index.containsObfBehavior( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), is( false ) );
	}
}