////////////////////////////////////////////////////////////////////////////////
//
//  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 spark.layouts
{	
import flash.events.Event;
import flash.geom.Point;
import flash.geom.Rectangle;

import mx.core.ILayoutElement;
import mx.core.IVisualElement;
import mx.core.mx_internal;

import spark.components.DataGroup;
import spark.components.SpinnerList;
import spark.components.supportClasses.GroupBase;
import spark.core.NavigationUnit;

use namespace mx_internal;

[ExcludeClass]

/**
 *  Custom wrapping layout for the SpinnerList
 */ 
public class VerticalSpinnerLayout extends VerticalLayout
{
	public function VerticalSpinnerLayout()
	{
		super();
	}
	
	//--------------------------------------------------------------------------
	//
	//  Variables
	//
	//--------------------------------------------------------------------------
	
	private function get totalHeight():Number
	{
		return Math.ceil(target.numElements * rowHeight);
	}
	
	// If true, then when the layout encounters a disabled element, it will scroll past it
	// in ascending index order. If false, then it will scroll in the descending index order
	mx_internal var autoScrollAscending:Boolean = false;
	
	mx_internal static const FORCE_NO_WRAP_ELEMENTS_CHANGE:String = "forceNoWrapElementsChange";
    
    // If the scrollPosition is too small or large, we need to shift the y positions
    // of the item renderers or else we hit a player limitation. 
    private var yOffset:Number = 0;
    
    // The max value for x/y seems to be 2^30 / 10. int.MAX_VALUE = 2^31;
    private static const MAX_Y_VALUE:Number = int.MAX_VALUE / 20;
    private static const MIN_Y_VALUE:Number = int.MIN_VALUE / 20;
	
	//--------------------------------------------------------------------------
	//
	//  Properties
	//
	//--------------------------------------------------------------------------
	
	//----------------------------------
	//  requestedWrapElements
	//----------------------------------
	
	private var _requestedWrapElements:Boolean = true;
	
	/**
	 *  This is the suggested value for wrapElements. However, the layout might not honor this value
	 *  if there are too few elements to display in the viewable area. 
	 * 
	 *  @default true
	 */
	public function get requestedWrapElements():Boolean
	{
		return _requestedWrapElements;
	}
	
	public function set requestedWrapElements(value:Boolean):void
	{
		if (value == _requestedWrapElements)
			return;
		
		_requestedWrapElements = value;
		target.invalidateSize();
		target.invalidateDisplayList();
	}
	
	/**
	 *  If true, the layout has forced wrapElements to be false
	 */ 
	public var forceNoWrapElements:Boolean = false;
	
	//----------------------------------
	//  wrapElements
	//----------------------------------
	
	/**
	 *  When true, scrolling past the last element will scroll to the first element. 
	 * 
	 *  @default true
	 */
	public function get wrapElements():Boolean
	{
		if (forceNoWrapElements)
			return false;
		else
			return requestedWrapElements;
	}
	
	//--------------------------------------------------------------------------
	//
	//  Overridden methods
	//
	//--------------------------------------------------------------------------
		
	override public function measure():void
	{					
		var preferredWidth:Number = 0;  // max of the elt preferred widths
		
		var element:ILayoutElement;
		var startIndex:int = 0;
        
		var iter:LayoutIterator = new LayoutIterator(target, startIndex);
        
		if (useVirtualLayout)
		{
			if (typicalLayoutElement)
				preferredWidth = typicalLayoutElement.getPreferredBoundsWidth();
		}
		else
		{
            do
            {
                element = iter.getCurrentElement();
                if (element && element.includeInLayout)
                    preferredWidth = Math.max(Math.ceil(element.getPreferredBoundsWidth()), preferredWidth);
                iter.next();
            } 
            while (startIndex != iter.currentIndex); // Loop until we are back at the start
                
		}
		        
		var rowsToMeasure:int = getRowsToMeasure(target.numElements);
		
		// Calculate the height by multiplying the number of elements time the row height
		target.measuredHeight = Math.ceil(rowsToMeasure * Math.max(5, rowHeight));
		target.measuredWidth = preferredWidth;
	}
	
    override public function updateDisplayList(width:Number, height:Number):void
    {
        var element:ILayoutElement;
        var numElements:int = target.numElements;
        
        var oldForceNoWrapElements:Boolean = forceNoWrapElements;
        
        // If there are fewer elements than will fit, we need to set wrapElements = false
        if (requestedWrapElements && (height > numElements * rowHeight))
            forceNoWrapElements = true;
        else
            forceNoWrapElements = false;
        
        if (forceNoWrapElements != oldForceNoWrapElements)
            dispatchEvent(new Event(FORCE_NO_WRAP_ELEMENTS_CHANGE));
        
        var scrollPosition:Number = verticalScrollPosition;
		
        var itemIndex:int = Math.floor(scrollPosition / rowHeight);
        var yPos:Number;
        var yPosMax:Number;
        
        var foundLastVisibleElement:Boolean = false;
        var numVisibleElements:int = 0;
        var numVisitedElements:int = 0;
        
        // Translate the vsp to the item index
        if (!wrapElements)
        {
            if (!useVirtualLayout)
                itemIndex = 0;
            else
                itemIndex = Math.max(Math.min(itemIndex, numElements - 1), 0);           
        }		
        
        yPos = itemIndex * rowHeight + yOffset;
        
        // Calculate the y position of the bottom of the viewable area
        yPosMax = yPos + rowHeight + height;
        
        // Normalize the itemIndex
        if (wrapElements)
            itemIndex = normalizeItemIndex(itemIndex);
        
        // Start at the top index
        var iter:LayoutIterator = new LayoutIterator(target, itemIndex);
        
        if (numElements > 0)
        {
            do
            {
                element = iter.getCurrentElement();
                if (element && element.includeInLayout)
                {
                    numVisitedElements++;
                    
                    element.setLayoutBoundsSize(width, rowHeight);
                    element.setLayoutBoundsPosition(0, yPos);
                    
                    yPos += rowHeight;
                    
                    // If we are using virtual layout, only size and position 
                    // the visible elements
                    if (yPos > yPosMax && !foundLastVisibleElement)
                    {
                        foundLastVisibleElement = true;
                        // Keep track of the number of elements visible in the viewing area
                        numVisibleElements = numVisitedElements;
                        if (useVirtualLayout)
                            break;
                    }
                }
                
                // Make sure to not wrap if wrapElements = false
                if (!wrapElements && iter.currentIndex == numElements - 1)
                    break;
                
                iter.next();
            } 
            while (itemIndex != iter.currentIndex)
        }
        
        setRowCount(numVisibleElements);
        
        // Set the contentWidth and contentHeight
        target.setContentSize(target.width, Math.ceil(numElements * rowHeight));
    }
    
    override public function updateScrollRect(w:Number, h:Number):void
    {
        var g:GroupBase = target;
        if (!g)
            return;
        
        if (clipAndEnableScrolling)
        {
            var hsp:Number = horizontalScrollPosition;
            var vsp:Number = verticalScrollPosition;
            
            // If the verticalScrollPosition exceeds the max/min y value, then the
            // renderers will not be properly positioned. In which case,
            // we offset the y position of the renderers by the verticalScrollPosition
            if (((vsp + yOffset + g.getPreferredBoundsHeight()) > MAX_Y_VALUE) ||
                ((vsp + yOffset) < MIN_Y_VALUE))
                yOffset = -vsp;
            g.scrollRect = new Rectangle(hsp, vsp + yOffset, w, h);
        }
        else
            g.scrollRect = null;
    }

	override public function getElementBounds(index:int):Rectangle
	{		
		return new Rectangle(0, index * rowHeight, target.measuredWidth, rowHeight); 
	}
	
	//--------------------------------------------------------------------------
	//
	//  Overridden scroll methods
	//
	//--------------------------------------------------------------------------
	
	override protected function scrollPositionChanged():void
	{        
        var g:GroupBase = target;
        if (!g)
            return;
        
        updateScrollRect(g.width, g.height);
        
        var n:int = g.numElements - 1;
        if (n < 0) 
        {
            setIndexInView(-1, -1);
            return;
        }
        
        var scrollR:Rectangle = getScrollRect();
        if (!scrollR)
        {
            setIndexInView(0, n);
            return;    
        }
        
        // Apply the offset        
        var y0:Number = scrollR.top + yOffset;
        var y1:Number = scrollR.bottom + yOffset - .0001; 
        if (y1 <= y0)
        {
            setIndexInView(-1, -1);
            return;
        }
        
        var i0:int;
        var i1:int;
        
        if (wrapElements)
        {
            i0 = normalizeItemIndex(Math.floor(y0 / rowHeight));
            i1 = normalizeItemIndex(Math.floor(y1 / rowHeight));
        }
        else
        {
            i0 = Math.min(Math.max(Math.floor(y0 / rowHeight), 0),n);
            i1 = Math.min(Math.max(Math.floor(y1 / rowHeight), 0),n);
        }
        
        setIndexInView(i0, i1);
        
        var firstElement:ILayoutElement = g.getElementAt(firstIndexInView);
        var lastElement:ILayoutElement = g.getElementAt(lastIndexInView);
        
        if (wrapElements)
        {
            if (!firstElement || !lastElement || 
                y0 < firstElement.getLayoutBoundsY() || 
                y1 >= (lastElement.getLayoutBoundsY() + lastElement.getLayoutBoundsHeight()))
            {
                g.invalidateDisplayList();
            }
        }
        else
        {
            if (!firstElement || !lastElement || 
                (y0 < firstElement.getLayoutBoundsY() && firstIndexInView != 0) || 
                (y1 >= (lastElement.getLayoutBoundsY() + lastElement.getLayoutBoundsHeight()) && lastIndexInView != n))
            {
                g.invalidateDisplayList();
            }
        }
	}
	
	override public function getHorizontalScrollPositionDelta(navigationUnit:uint):Number
	{
		return 0;
	}
	
	override public function getVerticalScrollPositionDelta(navigationUnit:uint):Number
	{		
		return 0;
	}
	
	override mx_internal function getElementNearestScrollPosition(
		position:Point,elementComparePoint:String = "center"):int
	{
		var index:int = Math.floor(position.y / rowHeight); // may be larger than numElements to indicate wrapping
		
        var item:Object;
		var startIndex:int = index % target.numElements;
        var distance:int = 0;
        var direction:int = autoScrollAscending ? 1 : -1;
        var dataGroup:DataGroup = target as DataGroup;
        
		if (startIndex < 0)
            startIndex += target.numElements;
		
		// If the element at index % numElements) is not selectable, find the nearest one that is              
        var iter:LayoutIterator = new LayoutIterator(target, startIndex);
        
        if (dataGroup && dataGroup.dataProvider && dataGroup.dataProvider.length > 0)
        {
            while (Math.abs(distance) <= (target.numElements / 2) + 1)
            {
                // Try searching in one direction
                iter.currentIndex = startIndex + distance * direction;

                item = dataGroup.dataProvider.getItemAt(normalizeItemIndex(iter.currentIndex));
                
                if (isElementEnabled(item))
                    break;
                
                if (distance != 0)
                {
                    // Flip the direction
                    direction *= -1;
                    
                    // Try searching in the other direction
                    iter.currentIndex = startIndex + distance * direction;
                    item = dataGroup.dataProvider.getItemAt(normalizeItemIndex(iter.currentIndex));   
                    
                    if (isElementEnabled(item))
                        break;
                    
                    // Flip the direction back
                    direction *= -1;
                }
                
                distance++;
            }
        }
        
		// If we don't allow wrapping, then cap the max index
		if(!wrapElements)
			index = Math.max(0, Math.min(index, target.numElements - 1));
		
		return index + distance * direction;
	}
		
	//--------------------------------------------------------------------------
	//
	//  Methods
	//
	//--------------------------------------------------------------------------
	
	/**
	 *  Returns the index of the element intersected by the vertical center of the viewable area
	 */ 
	public function getIndexAtVerticalCenter():int
	{
        var midY:Number = target.getLayoutBoundsHeight() / 2;
		var vsp:Number = wrapElements ? normalizeScrollPosition(verticalScrollPosition + midY) : verticalScrollPosition + midY;
        
		return getElementNearestScrollPosition(new Point(0, vsp), "center"); 
	}
    
	/**
	 *  Takes an index between 0 and numElements and returns the closest index 
     *  to the current position, taking wrapping into account
	 */   
    public function getClosestUnwrappedElementIndex(index:int):int
    {
        if (wrapElements)
        {
            // Figure out the wrapCount of the center index
            var midVSP:Number = target.getLayoutBoundsHeight() / 2 + verticalScrollPosition;
            var wrapCount:int = Math.floor(midVSP / totalHeight);
            
            // Get unwrapped middle index
            var centerIndex:int = getElementNearestScrollPosition(new Point(0, midVSP), "center");
            
            // Get the unwrapped indicies near the center index
            var prevIndex:int = index + (wrapCount - 1) * target.numElements;
            var midIndex:int = prevIndex + target.numElements;
            var nextIndex:int = midIndex + target.numElements;
            
            var prevDistance:int = Math.abs(centerIndex - prevIndex);
            var midDistance:int = Math.abs(midIndex - centerIndex);
            var nextDistance:int = Math.abs(nextIndex - centerIndex)
                        
            // Figure out which index is closer to the centerIndex and return that value
            if (prevDistance < midDistance)
                index = prevIndex;                    
            else if (midDistance < nextDistance)
                index = midIndex;
            else
                index = nextIndex;
        }
        
        return index;
    }
    
	// Helper function to calculate the non-wrapped, non-negative scroll position
	private function normalizeScrollPosition(vsp:int):int
	{
		// Normalize the scrollPosition
 		if (!isNaN(totalHeight))
		{
			vsp %= totalHeight;
			
			if (vsp < 0)
				vsp += totalHeight;
		}
		
		return vsp;
	}
    
    // Helper function to normalize the item index
    private function normalizeItemIndex(index:int):int
    {
        if (target)
        {
            index %= target.numElements;
            
            if (index < 0)
                index += target.numElements;
        }
        
        return index;
    }
    
    // Helper function to return whether an element is enabled or not
    private function isElementEnabled(element:Object):Boolean
    {       
        var result:Boolean = true;
        
        // If data is a String or other primitive, this call will fail
        try 
        {
            result = element["_enabled_"] == undefined || element["_enabled_"];
        }
        catch (e:Error)
        {
            
        }
        
        return result;
    }
}
}

////////////////////////////////////////////////////////////////////////////////
//
//  Helper class: LayoutIterator
//
////////////////////////////////////////////////////////////////////////////////

import mx.core.ILayoutElement;

import spark.components.supportClasses.GroupBase;

/**
 *  Layout helper class. Iterates over a set of items. The iterator can optionally wrap around the 
 *  end of the set back to the beginning of the set.  
 */ 
class LayoutIterator 
{
	/**
	 *  Constructor. Takes a layout target and the starting index for the iterator
	 *  
	 *  @param target The GroupBase target that contains the elements
	 *  @param index The starting index for the iterator  
	 */ 
	public function LayoutIterator(target:GroupBase, index:int = 0):void
	{
		totalElements = target.numElements;
		_target = target;
		_curIndex = index;
		_useVirtual = _target.layout.useVirtualLayout;
	}
	
	//--------------------------------------------------------------------------
	//
	//  Variables
	//
	//--------------------------------------------------------------------------
	
	private var _curIndex:int;
	private var _target:GroupBase;
	private var _useVirtual:Boolean;
	private var totalElements:int;
	
	//--------------------------------------------------------------------------
	//
	//  Properties
	//
	//--------------------------------------------------------------------------
	
	/**
	 *  Returns the index that the iterator is currently pointing
	 */ 
	public function get currentIndex():int
	{
		return _curIndex;
	}
    
    public function set currentIndex(value:int):void
    {
        _curIndex = value;
    }
		
	//--------------------------------------------------------------------------
	//
	//  Methods
	//
	//--------------------------------------------------------------------------
	/**
     *  Get the element at the currentIndex 
     */ 
    public function getCurrentElement():ILayoutElement
    {
        return _useVirtual ? _target.getVirtualElementAt(_curIndex) :
                             _target.getElementAt(_curIndex);
    }
    
    /**
     *  Move the currentIndex to the next index. If the currentIndex is at
     *  the last index, then it is set to the first index. 
     */
    public function next():int
    {
        if (_curIndex == totalElements - 1)
            _curIndex = 0;
        else
            _curIndex++;
        
        return _curIndex;
    }
    
    /**
     *  Move the currentIndex to the previous index. If the currentIndex is at
     *  the fist index, then it is set to the last index. 
     */
    public function prev():int
    {
        if (_curIndex == 0)
            _curIndex = totalElements - 1;
        else
            _curIndex--;
        
        return _curIndex;
    }

}