/*----------------    FILE HEADER ---------------------------------------
 This file is part of Geoide.
 Copyright (C) 2005-2006 by:
 IDgis B.V.
 http://www.idgis.nl

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

 Contact:

 Herman Assink
 IDgis bv
 P.O. Box 15
 7450 AA Holten
 The Netherlands
 E-Mail: herman.assink@idgis.nl

 * @version 1.4.0
 * @author IDgis team
 * 
 ------------------------------------------------------------------------*/
import nl.idgis.giclient.gui.ContainerContent;
import nl.idgis.giclient.geoma.Envelope;
import nl.idgis.giclient.gis.ActiveMapListener;
import nl.idgis.giclient.gis.CentreScale;
import nl.idgis.giclient.gis.Layer;
import nl.idgis.giclient.gis.GILayer;
import nl.idgis.giclient.gis.ShuffleListener;
import nl.idgis.giclient.gis.ZoomListener;
import nl.idgis.giclient.webserviceconnector.MapConnector;
import nl.idgis.giclient.gis.SRSChangeListener;
import nl.idgis.giclient.gis.Map;
import nl.idgis.giclient.event.StateEventListener;
import nl.idgis.giclient.event.StateEvent;
import nl.idgis.giclient.framework.SinglePaneComponent;

class nl.idgis.giclient.gui.overviewer.OverViewer extends ContainerContent 
      implements ActiveMapListener, ShuffleListener, ZoomListener, SRSChangeListener, StateEventListener {

    private var mapWidth:Number = 0;
    private var mapHeight:Number = 0;
    private var mapViewerWidth:Number = 0;
    private var mapViewerHeight:Number = 0;
    private var normalColor:Number = 0x949FC8;
    private var darkColor:Number = 0x404040;
    private var defaultScaleFactor:Number = 30;
    private var scaleFactor:Number = 0;
    private var type:String = "Feature";

    private var dragging:Boolean = false;
    private var startDraggingX:Number = 0;
    private var startDraggingY:Number = 0;
    private var overviewVisible:Boolean = true;
  
    function onLoad():Void {
        mapViewerWidth = Stage.width;
        mapViewerHeight = Stage.height;

        Stage.addListener(this);
        ruler.getGIS().gisEventDispatcher.addActiveMapListener(this);
        ruler.getGIS().gisEventDispatcher.addShuffleListener(this);
        ruler.getGIS().gisEventDispatcher.addZoomListener(this);
        ruler.getGIS().gisEventDispatcher.addSRSChangeListener(this);
		var overviewerComp:SinglePaneComponent = 
			SinglePaneComponent(ruler.getGIClientConfig().getGIComponent("OverViewer"));

        overviewerComp.addEventListener(this, StateEvent.CHANGE, "visible");

        mapWidth = this._parent.width + 4;
        mapHeight = this._parent.height + 4;

        setScaleFactor();

        drawAll();
		this.overviewVisible = true;
	}

    function onResize():Void {
        mapViewerWidth = Stage.width;
        mapViewerHeight = Stage.height;
    }

    function beforeChangeActiveMap():Void {
        clearAll();
    }

    function afterChangeActiveMap():Void {
        setScaleFactor();

        drawAll();
    }

    function onShuffle(Void):Void {
    	if (!overviewVisible) {
    		return;
    	}
        var visibleLayers:Array = ruler.getGIS().getZoomVisibleLayersForScale(getCentreScale().getScale());
        var layerName:String = "";
        var connectorID:String = "";
        
        for (var i:Number = 0; i < visibleLayers.length; i++) {
            layerName = visibleLayers[visibleLayers.length - 1 - i].getName();
            connectorID = Layer(visibleLayers[visibleLayers.length - 1 - i]).getMapConnector().getID();
            this[connectorID + layerName].swapDepths(i);
        }

    }

    function onZoom():Void {
    	if (!overviewVisible) {
    		return;
    	}
        setScaleFactor();

        setTypeSelectorVisible(); // Called method is "no stuwing", must therefore be called before createOverViewLayers.

        removeOverViewLayers();
        createOverViewLayers();
    }

    private function setScaleFactor():Void {
        var map:Map = ruler.getGIS().getActiveMap();
        var coordPixFactor:Number = ruler.getGIS().getCoordPixFactor();
        var gisScale:Number = ruler.getGIS().getCurrentCentreScale().getScale();

        // minScale en maxScale limit the zoom extent for the overviewer. They are based on the bounding envelope of the active map.
        var initOverviewScale:Number = map.getInitEnvelope().toCentreScale(mapWidth, mapHeight, coordPixFactor).getScale();
        var minScale:Number = 0.3 * initOverviewScale;
        var maxScale:Number = 0;
        if (map.getEnvelope() == null) {
        	maxScale = 2.0 * initOverviewScale;
        } else {
        	maxScale = 2.0 * map.getEnvelope().toCentreScale(mapWidth, mapHeight, coordPixFactor).getScale();
        }
        if (gisScale * defaultScaleFactor < minScale) {
            scaleFactor = minScale / gisScale;
        } else if (gisScale * defaultScaleFactor > maxScale) {
            scaleFactor = maxScale / gisScale;
        } else {
            scaleFactor = defaultScaleFactor;
        }
        //trace("gisScale = " + gisScale + " minScale = " + minScale + " maxScale = " + maxScale + " scaleFactor = " + scaleFactor);
    }

    private function drawAll():Void {
        createEmptyMovieClip("hitter", 2000);
        this["hitter"]._visible = false;
        this["hitter"].beginFill(0x000000, 100);
        this["hitter"].moveTo(0, 0);
        this["hitter"].lineTo(mapWidth, 0);
        this["hitter"].lineTo(mapWidth, mapHeight);
        this["hitter"].lineTo(0, mapHeight);
        this["hitter"].endFill();
        //this.hitArea = this["hitter"];

        this._parent.refreshPane();
        this._parent.setScrollPosition(4, 4);

        attachMovie("CustomCursor", "customCursor", 2004, {intervaltime:50});
        this["customCursor"].updateCustomCursor("lib://Verschuiven", true, 0, 0, false);

        createEmptyMovieClip("typeSelector", 2001);
        this["typeSelector"]._x = 5;
        this["typeSelector"]._y = 10;
        this["typeSelector"].beginFill(normalColor, 100);
        this["typeSelector"].lineStyle(1, darkColor, 100);
        this["typeSelector"].moveTo(0, 0);
        this["typeSelector"].lineTo(10, 0);
        this["typeSelector"].lineTo(10, 10);
        this["typeSelector"].lineTo(0, 10);
        this["typeSelector"].endFill();
        this["typeSelector"].onRelease = function() {
            this._parent.toggleType();
        };
        setTypeSelectorVisible();

        createOverViewLayers();
    }

    private function toggleType():Void {
        if (type == "Feature") {
            type = "Image";
        } else {
            type = "Feature";
        }

        removeOverViewLayers();
        createOverViewLayers();
    }

    private function setTypeSelectorVisible():Void {
        var scale:Number = getCentreScale().getScale();
        var visibleLayers:Array = ruler.getGIS().getZoomVisibleLayersForScale(scale);
        var imageLayersPresent:Boolean = false;
        for (var i:Number = 0; i < visibleLayers.length; i++) {
            if (visibleLayers[i].getType().toUpperCase() == "IMAGE") {
                imageLayersPresent = true;
                break;
            }

        }
        //trace("imageLayersPresent = " + imageLayersPresent);
        if (imageLayersPresent) {
            this["typeSelector"]._visible = true;
            type = "Image";
        } else {
            this["typeSelector"]._visible = false;
            type = "Feature";
            // NO STUWING!!
        }

    }

    private function removeOverViewLayers():Void {
        var layers:Array = ruler.getGIS().getLayers();
        for (var i:Number = 0; i < layers.length; i++) {
            this[Layer(layers[i]).getMapConnector().getID() + layers[i].getName()].removeMovieClip();
        }

        //numLoadingOverViewLayers = 0;
    }

    private function createOverViewLayers():Void {
        var centreScale:CentreScale = getCentreScale();
        var visibleLayers:Array = ruler.getGIS().getZoomVisibleLayersForScale(centreScale.getScale());
        //trace("scale = " + centreScale.getScale() + " visibleLayers# = " + visibleLayers.length);
		var layer:Layer = null;
        var layerName:String = "";
        var envelope:Envelope = centreScale.toEnvelope(mapWidth, mapHeight, ruler.getGIS().getCoordPixFactor());
        removeLocator();
        for (var i:Number = 0; i < visibleLayers.length; i++) {
            layer = visibleLayers[visibleLayers.length - 1 - i];
            if (layer.getType().toUpperCase() == type.toUpperCase()) {
                layerName = layer.getName();
                createEmptyMovieClip(layer.getMapConnector().getID() + layerName, i);
                //var url:String = ruler.getGIClientConfig().getServerURLPrefix();
                /*var url:String = GILayer(layer).getServerURL();
                url += "request=GetMap&layer=" + layerName + "&width=" + mapWidth + "&height=" + mapHeight;
                url += "&envelope=" + envelope.getMinX() + "," + envelope.getMinY();
                url += "," + envelope.getMaxX() + "," + envelope.getMaxY(); */
                var mapConnector:MapConnector = layer.getMapConnector();
                var url:String = mapConnector.getMap(layer, centreScale, mapWidth, 
                	mapHeight, ruler.getGIS());
                this[layer.getMapConnector().getID() + layerName].loadMovie(url);
                drawLocator();
            }
        }
    }


    private function drawLocator():Void {
        var locatorWidth:Number = mapViewerWidth / scaleFactor;
        var locatorHeight:Number = mapViewerHeight / scaleFactor;
        if ((locatorWidth > 7) || (locatorHeight > 7)) {
            createEmptyMovieClip("locator", 2002);
            this["locator"]._x = (mapWidth / 2) - (locatorWidth / 2);
            this["locator"]._y = (mapHeight / 2) - (locatorHeight / 2);
            this["locator"].clear();
            this["locator"].beginFill(0, 0);
            this["locator"].lineStyle(2, darkColor, 100);
            this["locator"].moveTo(0, 0);
            this["locator"].lineTo(locatorWidth, 0);
            this["locator"].lineTo(locatorWidth, locatorHeight);
            this["locator"].lineTo(0, locatorHeight);
            this["locator"].lineTo(0, 0);
            this["locator"].endFill();
        } else {
            attachMovie("NailBox", "locator", 2002, {_width: 6, _height: 6});
            this["locator"]._x = mapWidth / 2;
            this["locator"]._y = mapHeight / 2;
        }
        this["locator"].useHandCursor = false;
        this["locator"].onPress = function() {
            this._parent.dragging = true;
            this._parent.startDraggingX = this._parent._xmouse;
            this._parent.startDraggingY = this._parent._ymouse;
        };
        this["locator"].onRollOver = function() {
            this._parent["customCursor"].showCustomCursor();
            this._parent["customCursor"].setDragging(true);
        };
        this["locator"].onRollOut = function() {
            this._parent["customCursor"].setDragging(false);
            this._parent["customCursor"].hideCustomCursor();
        };
    }

    private function removeLocator():Void {
        if (this["locator"] != null) {
            this["locator"].removeMovieClip();
        }
    }

    private function getCentreScale():CentreScale {
        var centreScale:CentreScale = ruler.getGIS().getCurrentCentreScale().clone();
        centreScale.setScale(centreScale.getScale() * scaleFactor);
        return centreScale;
    }

    function onMouseMove():Void {
        if (dragging) {
            var locatorWidth:Number = mapViewerWidth / scaleFactor;
            var locatorHeight:Number = mapViewerHeight / scaleFactor;

            if ((locatorWidth > 7) || (locatorHeight > 7)) {
                this["locator"]._x = (mapWidth / 2) - (locatorWidth / 2) + _xmouse - startDraggingX;
                this["locator"]._y = (mapHeight / 2) - (locatorHeight / 2) + _ymouse - startDraggingY;
            } else {
                this["locator"]._x = (mapWidth / 2) + _xmouse - startDraggingX;
                this["locator"]._y = (mapHeight / 2) + _ymouse - startDraggingY;
            }
        }
    }

    function onMouseUp():Void {
        if (dragging) {
            dragging = false;
            var pixX:Number = _xmouse;
            var pixY:Number = _ymouse;
            var centreScale:CentreScale = getCentreScale();
            var newCentreX:Number = (pixX - startDraggingX) + (mapWidth/2);
            var newCentreY:Number = (pixY - startDraggingY) + (mapHeight/2);
            var coordX:Number = centreScale.getCoordX(mapWidth, newCentreX, ruler.getGIS().getCoordPixFactor());
            var coordY:Number = centreScale.getCoordY(mapHeight, newCentreY, ruler.getGIS().getCoordPixFactor());
            ruler.getGIS().pan(coordX, coordY);

            this["customCursor"].setDragging(false);
            this["customCursor"].hideCustomCursor();
        }
    }

	function onSRSChange():Void {
		onZoom();
	}
	
	function onStateEvent(stateEvent:StateEvent):Void {
		if(stateEvent.getActionType() == StateEvent.CHANGE &&
			stateEvent.getPropertyName() == "visible" &&
			stateEvent.getSourceClassName() == "SinglePaneComponent") {
			if(SinglePaneComponent(stateEvent.getSource()).getPane() == null) {
				overviewVisible = false;
			} else {
				overviewVisible = true;
				onZoom();
			}
		}
	}
}