////////////////////////////////////////////////////////////////////////////////
//
//  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 mx.core
{

import flash.events.IEventDispatcher;
import flash.events.Event;

[ExcludeClass]

/**
 *  @private
 *  Utility class for loading a list of RSLs.
 *
 *  <p>A list of cross-domain RSLs and a list of regular RSLs
 *  can be loaded using this utility.</p>
 */
public class RSLListLoader
{
    include "../core/Version.as";
    
	//--------------------------------------------------------------------------
	//
	//  Constructor
	//
	//--------------------------------------------------------------------------

    /**
     *  Constructor.
     * 
     *  @param rslList Array of RSLs to load.
	 *  Each entry in the array is of type RSLItem or CdRSLItem.
     *  The RSLs will be loaded from index 0 to the end of the array.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function RSLListLoader(rslList:Array) 
    {
    	super();
        this.rslList = rslList;
    }
    
	//--------------------------------------------------------------------------
	//
	//  Variables
	//
	//--------------------------------------------------------------------------

    /**
	 *  @private
	 *  The index of the RSL being loaded.
	 */
	private var currentIndex:int = 0;
    
    /**
	 *  @private
	 *  The list of RSLs to load.
	 *  Each entry is of type RSLNode or CdRSLNode.
	 */
	private var rslList:Array = [];
    
    /**
	 *  @private
	 *  Supplied by caller.
	 */
	private var chainedProgressHandler:Function;
    
    /**
	 *  @private
	 *  Supplied by caller.
	 */
	private var chainedCompleteHandler:Function;
    
    /**
	 *  @private
	 *  Supplied by caller.
	 */
	private var chainedIOErrorHandler:Function;
    
    /**
	 *  @private
	 *  Supplied by caller.
	 */
	private var chainedSecurityErrorHandler:Function;
    
    /**
	 *  @private
	 *  Supplied by caller.
	 */
	private var chainedRSLErrorHandler:Function;
 
	//--------------------------------------------------------------------------
	//
	//  Methods
	//
	//--------------------------------------------------------------------------

    /**
     *  Loads the RSLs in this list object.
     * 
     *  <p>This function accepts listeners to observe events
	 *  that result from loading an RSL.
     *  The function must be of the form required by a listener function 
     *  passed to <code>IEventDispatcher.addEventListener();</code>
     * 
     *  When an event is received, the RSL that generated
	 *  this event can be found by calling
	 *  <code>rslListLoader.getItem(getIndex());</code></p>
     * 
     *  @param progressHandler Receives ProgressEvent.PROGRESS events.
	 *  May be null.
	 *
     *  @param completeHandler Receives Event.COMPLETE events.
	 *  May be null.
	 *
     *  @param ioErrorHandler Receives IOErrorEvent.IO_ERROR events.
	 *  May be null.
	 *
     *  @param securityErrorHandler
	 *  Receives SecurityErrorEvent.SECURITY_ERROR events.
	 *  May be null.
	 *
     *  @param rslErrorHandler Receives RSLEvent.RSL_ERROR events.
	 *  May be null.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
 	public function load(progressHandler:Function,
	                     completeHandler:Function,
	                     ioErrorHandler:Function,
	                     securityErrorHandler:Function,
	                     rslErrorHandler:Function):void 
    {
    	chainedProgressHandler = progressHandler;
	    chainedCompleteHandler = completeHandler;
	    chainedIOErrorHandler = ioErrorHandler;
	    chainedSecurityErrorHandler = securityErrorHandler;
	    chainedRSLErrorHandler = rslErrorHandler;
	    
	    currentIndex = -1; // so first loaded item will be index 0
	    loadNext();
         
    }
    
    /**
     *  Increments the current index and loads the next RSL.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    private function loadNext():void
    {
        if (!isDone())
        {
            currentIndex++;

	        // Load the current RSL.
	        if (currentIndex < rslList.length)
	        {
	            // Load rsl and have the RSL loader chain the
	            // events our internal events handler or the chained
	            // events handler if we don't care about them.
	            rslList[currentIndex].load(chainedProgressHandler,
	                                       listCompleteHandler,
	                                       listIOErrorHandler,
	                                       listSecurityErrorHandler,
	                                       chainedRSLErrorHandler);
	        }
        }
    }
    
    
    /**
     *  Gets an RSL from the list of RSLs.
     * 
     *  @param index A zero-based index into the list of RSLs.
     * 
     *  @return The current item at <code>index</code> in the list,
	 *  or <code>null</code> if there is no item at that index.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function getItem(index:int):RSLItem
    {
        if (index < 0 || index >= rslList.length)
            return null;
        
        return rslList[index];    
    }
    
    
    /**
     *  Gets the index of the currently loading RSL.
     * 
     *  @return The index of the currently loading RSL.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function getIndex():int
    {
        return currentIndex;
    }
    
    
   /**
    *  Gets the total number of RSLs in this object.
	*  When the load() method is called the RSLs will be loaded.
    *  
    *  @return The total number of RSLs in this object
    *  
    *  @langversion 3.0
    *  @playerversion Flash 9
    *  @playerversion AIR 1.1
    *  @productversion Flex 3
    */
    public function getItemCount():int
    {
        return rslList.length;    
    }
    
    /**
     *  Tests if all the RSLs are done loading.
     * 
     *  @return <code>true</code> if all the RSLs have been loaded,
	 *  <code>false</code> otherwise.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function isDone():Boolean
    {
        return currentIndex >= rslList.length;
    }
   	
	//--------------------------------------------------------------------------
	//
	//  Event handlers
	//
	//--------------------------------------------------------------------------

    /**
	 *  @private
	 */
	private function listCompleteHandler(event:Event):void
    {
        // Pass event to external listener.
        if (chainedCompleteHandler != null)
            chainedCompleteHandler(event);

        // Load the next RSL.
        loadNext();
    }
    
    /**
	 *  @private
	 */
    private function listIOErrorHandler(event:Event):void
    {
        // Pass event to external listener.
        if (chainedIOErrorHandler != null)
            chainedIOErrorHandler(event);
    }

    /**
	 *  @private
	 */
    private function listSecurityErrorHandler(event:Event):void
    {
        // Pass event to external listener.
        if (chainedSecurityErrorHandler != null)
            chainedSecurityErrorHandler(event);
    }    
}

}