/**
 * @author tschw
 */

QUnit.module( "AnimationObjectGroup" );

var ObjectA = new THREE.Object3D(),
	ObjectB = new THREE.Object3D(),
	ObjectC = new THREE.Object3D(),

	PathA = 'object.position',
	PathB = 'object.rotation',
	PathC = 'object.scale',

	ParsedPathA = THREE.PropertyBinding.parseTrackName( PathA ),
	ParsedPathB = THREE.PropertyBinding.parseTrackName( PathB ),
	ParsedPathC = THREE.PropertyBinding.parseTrackName( PathC );


QUnit.test( "smoke test", function( assert ) {

	var expect = function expect( testIndex, group, bindings, path, cached, roots ) {

		var rootNodes = [], pathsOk = true, nodesOk = true;

		for ( var i = group.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {

			if ( bindings[ i ].path !== path ) pathsOk = false;
			rootNodes.push( bindings[ i ].rootNode );

		}

		for ( var i = 0, n = roots.length; i !== n; ++ i ) {

			if ( rootNodes.indexOf( roots[ i ] ) === -1 ) nodesOk = false;

		}

		assert.ok( pathsOk, testIndex + " paths" );
		assert.ok( nodesOk, testIndex + " nodes");
		assert.ok( group.nCachedObjects_ === cached, testIndex + " cache size" );
		assert.ok( bindings.length - group.nCachedObjects_ === roots.length, testIndex + " object count" );

	};

	// initial state

	var groupA = new THREE.AnimationObjectGroup();
	assert.ok( groupA instanceof THREE.AnimationObjectGroup, "constructor (w/o args)" );

	var bindingsAA = groupA.subscribe_( PathA, ParsedPathA );
	expect( 0, groupA, bindingsAA, PathA, 0, [] );

	var groupB = new THREE.AnimationObjectGroup( ObjectA, ObjectB );
	assert.ok( groupB instanceof THREE.AnimationObjectGroup, "constructor (with args)" );

	var bindingsBB = groupB.subscribe_( PathB, ParsedPathB );
	expect( 1, groupB, bindingsBB, PathB, 0, [ ObjectA, ObjectB ] );

	// add

	groupA.add( ObjectA, ObjectB );
	expect( 2, groupA, bindingsAA, PathA, 0, [ ObjectA, ObjectB ] );

	groupB.add( ObjectC );
	expect( 3, groupB, bindingsBB, PathB, 0, [ ObjectA, ObjectB, ObjectC ] );

	// remove

	groupA.remove( ObjectA, ObjectC );
	expect( 4, groupA, bindingsAA, PathA, 1, [ ObjectB ] );

	groupB.remove( ObjectA, ObjectB, ObjectC );
	expect( 5, groupB, bindingsBB, PathB, 3, [] );

	// subscribe after re-add

	groupA.add( ObjectC );
	expect( 6, groupA, bindingsAA, PathA, 1, [ ObjectB, ObjectC ] );
	var bindingsAC = groupA.subscribe_( PathC, ParsedPathC );
	expect( 7, groupA, bindingsAC, PathC, 1, [ ObjectB, ObjectC ] );

	// re-add after subscribe

	var bindingsBC = groupB.subscribe_( PathC, ParsedPathC );
	groupB.add( ObjectA, ObjectB );
	expect( 8, groupB, bindingsBB, PathB, 1, [ ObjectA, ObjectB ] );

	// unsubscribe

	var copyOfBindingsBC = bindingsBC.slice();
	groupB.unsubscribe_( PathC );
	groupB.add( ObjectC );
	assert.deepEqual( bindingsBC, copyOfBindingsBC, "no more update after unsubscribe" );

	// uncache active

	groupB.uncache( ObjectA );
	expect( 9, groupB, bindingsBB, PathB, 0, [ ObjectB, ObjectC ] );

	// uncache cached

	groupA.uncache( ObjectA );
	expect( 10, groupA, bindingsAC, PathC, 0, [ ObjectB, ObjectC ] );

} );