/*----------------    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.geoma.Envelope;
import nl.idgis.giclient.geoma.GeometryTools;
import nl.idgis.giclient.gis.Layer;
import nl.idgis.giclient.gis.GILayer;
import nl.idgis.giclient.query.QueryAspect;
import nl.idgis.giclient.io.XMLServer;
import nl.idgis.giclient.gis.AnimationLayer;
import nl.idgis.giclient.gis.TimeRangeScale;
import nl.idgis.giclient.gis.TimeRange;

class nl.idgis.giclient.gis.Map {

    private var name:String = "";
    private var title:String = "";
    private var unboundFeatureLayer:Boolean = false;
    private var layers:Array = null;
    private var srs:String = null;
    private var mapUnits:String = null;
    private var webMapPrintServiceURL:String = null;
    private var initialTimeRangeScale:TimeRangeScale = null;
   	private var currentTimeRangeScale:TimeRangeScale = null;
   	private var timeLimit:TimeRange = null;
    
    private var initEnvelope:Envelope = null;
    private var envelope:Envelope = null;
    private var queryAspects:Array = null;
    private var currentQueryAspect:QueryAspect = null;
    private var minScale:Number = -1;
    private var maxScale:Number = -1;
    private var zoomToScale : Number = 2000;
    private var powerScale:Number = -1;
    private var stigmaURL:String = null;
    private var webMapPrintServiceEmail:String = "";
    
    private var supportedSRS:Array;
    private var scales:Array = null;
    
    private var disableInvisible:Boolean = true;
    
    private var printTemplates:Array = null; 
    private var reports:Array = null;


	function Map(name:String, title:String, unboundFeatureLayer:Boolean, disableInvisible:Boolean,
        	layers:Array, printTemplates:Array, reports:Array,
        	supportedSRS:Array, mapUnits:String, webMapPrintServiceURL:String) {
        this.name = name;
        this.title = title;
        this.unboundFeatureLayer = unboundFeatureLayer;
        this.disableInvisible = disableInvisible;
        this.layers = layers;
        this.printTemplates = printTemplates;
        this.reports = reports;        
        this.supportedSRS = supportedSRS;
        this.mapUnits = mapUnits;
        this.webMapPrintServiceURL = webMapPrintServiceURL;
        
        initialTimeRangeScale = new TimeRangeScale();
        currentTimeRangeScale = new TimeRangeScale();        
    }
    
    function setSRS(srs:String):Void {
    	for(var i:Number = 0; i < supportedSRS.length; i++)
    	{
    		if(srs == supportedSRS[i])
    		{
    			this.srs = srs;    			
    			for(var j:Number = 0; j < layers.length; j++)    			
    				Layer(layers[j]).setSRS(srs);    			    			
    			return;
    		}
    	}
    }
    
    function getSupportedSRS():Array {
    		return this.supportedSRS.concat();
    }

    function getName():String {
        return name;
    }

    function getTitle():String {
        return title;
    }

    function getUnboundFeatureLayer():Boolean {
        return unboundFeatureLayer;
    }

    function getLayers():Array {
        return layers;
    }

    function setQueryAspects(queryAspects:Array):Void {
        this.queryAspects = queryAspects;
    }
    
    function setEnvelope(envelope:Envelope):Void {
    	this.envelope = envelope;
    }
    
    function setInitEnvelope(initEnvelope:Envelope):Void {
        this.initEnvelope = initEnvelope;        
    }

    function getQueryAspects():Array{
        return queryAspects;
    }


    function setCurrentQueryAspect(queryAspect:QueryAspect):Void {
          this.currentQueryAspect = queryAspect;
      }

    function getCurrentQueryAspect():QueryAspect{
          return currentQueryAspect;
    }

    function setMinScale(minScale:Number):Void {
        this.minScale = minScale;
    }

    function getMinScale():Number {
        return minScale;
    }

    function setMaxScale(maxScale:Number):Void {
        this.maxScale = maxScale;
    }

    function getMaxScale():Number {
        return maxScale;
    }
    
    public function setZoomToScale(zoomToScale : Number) : Void {
		this.zoomToScale = zoomToScale;
	}
	
	public function getZoomToScale() : Number {
		return zoomToScale;
	}

    function setPowerScale(powerScale:Number):Void {
        this.powerScale = powerScale;
    }

    function getPowerScale():Number {
        return powerScale;
    }

    function setStigmaURL(stigmaURL:String):Void {
        this.stigmaURL = stigmaURL;
    }

    function getStigmaURL():String {
        return stigmaURL;
    }
    
    function getEnvelope():Envelope {
    	return envelope;
    }

    function getInitEnvelope():Envelope {
        if (initEnvelope != null) {
            return initEnvelope.clone();
        } else {
            var allLayers:Array = getAllLayers();
            var envelope:Envelope = null;
            var envelopes:Array = new Array();
            for (var i:String in allLayers) {
                envelope = allLayers[i].getEnvelope();
                envelopes.push(envelope);
            }
            
            return GeometryTools.getEnvelope(envelopes);
        }
    }

    function getAllLayers():Array {
        var allLayers:Array = new Array();
        for (var i:Number = 0; i < layers.length; i++) {
            populateAllLayers(allLayers, layers[i]);
        }
        return allLayers;
    }

    function getLayerByName(layerName:String):Layer {
    	  //trace("Map.getLayersByName!");
        for (var i:Number = 0; i < layers.length; i++) {
            if(layers[i].getName()==layerName){
              return layers[i];
              break;
            }
        }
    }

	function getPrintTemplates():Array{
		return this.printTemplates;
	}
	
	function getReports():Array {
		return this.reports;
	}	
	
	function getSRS():String{
		return this.srs;
	}
	
	function getMapUnits():String{
		return mapUnits;
	}
	
	function getWebMapPrintServiceURL():String{
	 	return webMapPrintServiceURL;
	}
	
	function setWebMapPrintServiceEmail(email:String):Void{
		if (email != null) { //default = ""
	 		this.webMapPrintServiceEmail = email;
		}
	}

	function getWebMapPrintServiceEmail():String{
	 	return webMapPrintServiceEmail;
	}
	
    private function populateAllLayers(allLayers:Array, layer:Layer) {
        allLayers.push(layer);

        var subLayers:Array = layer.getLayers();
        for (var i:Number = 0; i < subLayers.length; i++) {
            populateAllLayers(allLayers, subLayers[i]);
        }
    }

    function moveLayerBackward(layer:Layer, end:Boolean):Void {
        if (layer.getSuperLayer() == null) { // If the layer serves directly under the map.
            var i:Number = 0;
            while (layers[i] != layer) {
                i++;
            }
            if (i < layers.length - 1) {
                if (end) {
                    layers.splice(i, 1);
                    layers.push(layer);
                } else {
                    layers[i] = layers[i + 1];
                    layers[i + 1] = layer;
                }
            }
        } else {
            layer.getSuperLayer().moveLayerBackward(layer, end);
        }
    }

    function moveLayerFrontward(layer:Layer, end:Boolean):Void {
        if (layer.getSuperLayer() == null) { // If the layer serves directly under the map.
            var i:Number = 0;
            while (layers[i] != layer) {
                i++;
            }
            if ((layers.length > 1) && (i > 0)) {
                if (end) {
                    layers.splice(i, 1);
                    layers.unshift(layer);
                } else {
                    layers[i] = layers[i - 1];
                    layers[i - 1] = layer;
                }
            }
        } else {
            layer.getSuperLayer().moveLayerFrontward(layer, end);
        }
    }

    function moveLayerTo(fromLayer:Layer, toLayer:Layer):Void { //only exchanges now
        if ((fromLayer.getSuperLayer() == null) && (toLayer.getSuperLayer() == null)) { // Whether the layers are in this particular map is not checked now.
            if (fromLayer != toLayer) {
                var layerFromIndex:Number = 9999;    // nonexistent
                for (var i = 0; i < layers.length; i++) {
                    if (layers[i] == fromLayer) {
                        layerFromIndex = i;
                    }
                }
                var layerToIndex:Number = 9999;    //nonexistent
                for (var i = 0; i < layers.length; i++) {
                    if (layers[i] == toLayer) {
                        layerToIndex = i;
                    }
                }
                if ((layerFromIndex == 9999) || (layerToIndex == 9999)) {
                    //state("Given layer does not exist.", true);
                    return;
                }

                layers[layerToIndex] = fromLayer;
                layers[layerFromIndex] = toLayer;
            } else {
                //state("Layer " + fromLayer.getName() + " cannot be moved, because it is source and target at the same time.", true);
            }
        } else {
            fromLayer.getSuperLayer().moveLayerTo(fromLayer, toLayer);
        }
    }
    
    function setInitialTimeRange(begin:Date, end:Date):Void {
    	this.initialTimeRangeScale.setBegin(begin);
    	this.initialTimeRangeScale.setEnd(end);  	    	
    }
    
    function setInitialTimeRangeScale(timeRangeScale:TimeRangeScale):Void{
    	this.initialTimeRangeScale = timeRangeScale;
    }
    
    function setCurrentTimeRangeScale(timeRangeScale:TimeRangeScale):Void{
     	this.currentTimeRangeScale = timeRangeScale;
    }
    
    function setTimeLimit(timeLimit:TimeRange){
    	this.timeLimit = timeLimit;
    }
    
    function getCurrentTimeRangeScale():TimeRangeScale{
    	return currentTimeRangeScale;
    }
    
     function getInitialTimeRangeScale():TimeRangeScale{
    	return initialTimeRangeScale;
    }
    	
        
	function getInitialTimeRangeBegin():Date {
		return this.initialTimeRangeScale.getBegin();
    }
    
	function getInitialTimeRangeEnd():Date {
		return this.initialTimeRangeScale.getEnd();
    }
    
    function getInitialTimeScale():Number {
    	return this.initialTimeRangeScale.getTimeScale();
    }

    function getInitialFPS():Number {
    	return this.initialTimeRangeScale.getFPS();
    }
    
    function getCurrentTimeRangeBegin():Date {
		return this.currentTimeRangeScale.getBegin();
    }
    
	function getCurrentTimeRangeEnd():Date {
		return this.currentTimeRangeScale.getEnd();
    }
    
    function getCurrentTimeScale():Number {
    	return this.currentTimeRangeScale.getTimeScale();
    }

    function getCurrentFPS():Number {
    	return this.currentTimeRangeScale.getFPS();
    }
    
    function getTimeLimit():TimeRange{
    	return timeLimit;
    }
    
    function recalcCurrentTimeRange() {
    	var newBeginTime:Date = null;
    	var newEndTime:Date = null;		
    	for (var i = 0; i < layers.length; i++ ) {
    		var layer:Layer = Layer(layers[i]);
    		var timeStart:Date = layer.getTimeRangeStart();
    		if (timeStart != null && layer.isVisible() && layer.areSuperLayersVisible()) {
    			if (newBeginTime==null) {
    				newBeginTime = timeStart;
    			} else {
    				if(timeStart < newBeginTime){
    					newBeginTime = timeStart;
    				}  
    			}
    		}
    		var timeEnd:Date = layer.getTimeRangeEnd();
    		if (timeEnd != null && layer.isVisible() && layer.areSuperLayersVisible()) {
    			if (newEndTime==null) {
    				newBeginTime = timeEnd;
    			} else {
    				if(timeEnd > newEndTime){
    					newEndTime = timeEnd;
    				}  
    			}
    		}
    	}
    	
    	if(newBeginTime!=null && newEndTime!=null){
    	   	var minBeginTime:Date = null;
    		var maxEndTime:Date = null; 
    		if(timeLimit != null){
    			minBeginTime = timeLimit.getBegin();
    			maxEndTime = timeLimit.getEnd();
    		} else {
    	    	minBeginTime = new Date(Number.MAX_VALUE);
    			maxEndTime = new Date(Number.MIN_VALUE);
    		}
    		//check if the new timeRange is within limits:
    		if(newBeginTime < minBeginTime){
    			newBeginTime = minBeginTime;
    		}
    		if(newEndTime > maxEndTime){
    			newEndTime = maxEndTime;
    		}	
    		this.currentTimeRangeScale.setBegin(newBeginTime);
    		this.currentTimeRangeScale.setEnd(newEndTime);
    	}	
    }
    
    
    function setInitialTimeScale(scale:Number):Void {
    	this.initialTimeRangeScale.setTimeScale(scale);
    }
    
    function setInitialFPS(fps:Number):Void {
    	this.initialTimeRangeScale.setFPS(fps);
    }
    
    function setScales(scales:Array):Void {
    	this.scales = scales;
    }   
    
    function getScales():Array {
    	return scales;
    } 
    
    function getDisableInvisible():Boolean {
    	return disableInvisible;
	}
	
	function addLayer(layer:Layer) : Void {
		this.layers.splice(0, 0, layer);
	}
}