/*----------------    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.util.ArrayTools;
import nl.idgis.giclient.geoma.Envelope;
import nl.idgis.giclient.geoma.Geometry;
import nl.idgis.giclient.gis.Column;
import nl.idgis.giclient.gis.Feature;
import nl.idgis.giclient.gis.Layer;
import nl.idgis.giclient.gis.LayerEventDispatcher;
import nl.idgis.giclient.util.SynchListener;
import nl.idgis.giclient.gis.SelectableLayer;

class nl.idgis.giclient.gis.UnboundFeatureLayer extends SelectableLayer {

    private var geometryType:String = null;
    private var addedFeatures:Array = null;
    private var addedFeatureIDIndex:Number = 1;
    private var subSelectedFeatures:Array = null;
    private var currentFeature:Feature = null;

    var layerEventDispatcher:LayerEventDispatcher = null;

    function UnboundFeatureLayer() {
        addedFeatures = new Array();
        subSelectedFeatures = new Array();
        this.undoStack = new Array();

        layerEventDispatcher = new LayerEventDispatcher();
    }

    function getName():String {
        return "RedliningLayer";
    }

    function getTitle():String {
        return "Red-lining Layer";
    }

    function setVisible(visible:Boolean):Void {
    }

    function isVisible():Boolean {
        return true;
    }

   function isSelectable():Boolean {
        return true;
    }

    function areSuperLayersVisible():Boolean {
        return true;
    }

    function setExpanded(expanded:Boolean):Void {
    }

    function isExpanded():Boolean {
        return false;
    }

    function getMinScale():Number {
        return 1;
    }

    function getMaxScale():Number {
        return 999999999;
    }

    function getType():String {
        return "Feature";
    }

    function setEnvelope(envelope:Envelope):Void {
    }

    function getEnvelope():Envelope {
        return null; // TODO envelopes for all subselected features
    }

    function setColumns(columns:Array):Void {
    }

    function getColumns():Array {
        return new Array();
    }

    function getColumn(columnPath:String):Column {
        return null;
    }

    function setMapTipColumn(mapTipColumn:Column):Void {
    }

    function getMapTipColumn():Column {
        return null;
    }

    function setHyperlinkColumn(hyperlinkColumn:Column):Void {
    }

    function getHyperlinkColumn():Column {
        return null;
    }

    function setAttrInfoColumns(attrInfoColumns:Array):Void {
    }

    function getAttrInfoColumns():Array {
        return new Array();
    }

    function getSuperLayer():UnboundFeatureLayer {
        return null;
    }

    function getSuperLayers():Array {
        return new Array();
    }

    function setLayers(layers:Array) {
    }

    function getLayers():Array {
        return new Array();
    }

    function getAllLayers():Array {
        return new Array();
    }

    function setGeometryType(geometryType:String):Void {
        this.geometryType = geometryType;
    }

    function getGeometryType():String {
        return geometryType;
    }

    function setGeometryColumn(geometryColumn:String):Void {
    }

    function getGeometryColumn():String {
        return "GEOMETRY";
    }

    function setNoLegendLayer(noLegendLayer:Boolean):Void {
    }

    function getNoLegendLayer():Boolean {
        return null;
    }

    function setSubSelectingEnabled(subSelectingEnabled:Boolean):Void {
        if (!subSelectingEnabled) {
            var subSelectedChanged:Boolean = false;
            var currentChanged:Boolean = false;

            addedFeatures = new Array();
            if (subSelectedFeatures.length > 0) {
                //do not nullify geometry when stop editing
                //for (var i:String in subSelectedFeatures) {
                //    Feature(subSelectedFeatures[i]).setGeometry(null);
                //}
                subSelectedFeatures = new Array();
                subSelectedChanged = true;
                if (currentFeature != null) {
                    currentFeature = null;
                    currentChanged = true;
                }
            }

            undoStack = new Array();
            layerEventDispatcher.changeSelectedFeatures(this, false, subSelectedChanged, currentChanged);
        }
    }

    function isSubSelectingEnabled():Boolean {
        return true;
    }

    function addFeature(geometry:Geometry, id:String):Feature {
    	var fId:String = id;
    	if(fId == null) {
    		fId = String(addedFeatureIDIndex++);
    	}
        var feature:Feature = new Feature(fId, this, null, false, true);
        feature.setGeometry(geometry);
        addedFeatures.push(feature);
        subSelectedFeatures.push(feature);
        currentFeature = feature;
        layerEventDispatcher.changeSelectedFeatures(this, false, true, true);
        
        return feature;
    }
    
    function removeFeature(feature:Feature):Void {    	
    	for(var i:Number = 0; i < addedFeatures.length; i++) {
    		if(addedFeatures[i] == feature) {
    			addedFeatures.splice(i, 1);
    			break;
    		}
    	}
    	
    	for(var i:Number = 0; i < subSelectedFeatures.length; i++) {
    		if(subSelectedFeatures[i] == feature) {
    			subSelectedFeatures.splice(i, 1);
    			break;
    		}
    	}
    	
    	if(currentFeature == feature) {
    		currentFeature = null;
    	}
    	
    	feature.remove();
    	
    	layerEventDispatcher.changeSelectedFeatures(this, false, true, true);
    }

    function setFilteredFeatures(ids:Array, cumulatively:Boolean):Void {
    }

    function setSelectedFeatures(ids:Array, cumulatively:Boolean, synchListener:SynchListener):Void {
    }

    function setCurrentFeature(ids:Array, cumulatively):Void {
        setFeatures(CURRENT, ids, false, null);
    }

    function setNearbyFeatures(ids:Array):Void {
    }

    private function setFeatures(action:Number, whereFeaturesIDs:Array, cumulatively:Boolean, synchListener:SynchListener):Void {
        if (action != CURRENT) {
            // EXCEPTION
            return;
        }
        if (whereFeaturesIDs == null) {
            whereFeaturesIDs = new Array();
        }
        if ((whereFeaturesIDs.length == 0) && (cumulatively)) { // Not much to do in that case...
            return;
            // TODO synchlistener???
        }

        ArrayTools.makeUnique(whereFeaturesIDs);

        var subSelectedChanged:Boolean = false;
        var currentChanged:Boolean = false;

        if (whereFeaturesIDs.length > 0) {
            var subSelectedIDs:Array = Layer.getFeatureIDs(subSelectedFeatures);
            var toBeAdded:Array = ArrayTools.getLeftOver(whereFeaturesIDs, subSelectedIDs);
            var feature:Feature = null;
            for (var i:Number = 0; i < toBeAdded.length; i++) {
                feature = getFeature(toBeAdded[i]);
                if (feature != null) {
                    subSelectedFeatures.push(feature);
                    subSelectedChanged = true;
                }
            }
            if (action == CURRENT) {
                if (((currentFeature == null) && (getFeature(whereFeaturesIDs[0]) != null))
                      || ((currentFeature != null) && (currentFeature.getID() != whereFeaturesIDs[0]))) {
                    currentFeature = getFeature(whereFeaturesIDs[0]);
                    currentChanged = true;
                }
            }
        }
        layerEventDispatcher.changeSelectedFeatures(this, false, subSelectedChanged, currentChanged);
    }

    function getFeatures():Array {
        return addedFeatures;
    }

    private function getFeature(id:String):Feature {
        var feature:Feature = null;
        for (var i:String in addedFeatures) {
            feature = Feature(addedFeatures[i]);
            if (feature.getID() == id) {
                return feature;
            }
        }
        return null;
    }

    function getFilteredFeatures():Array {
        return new Array();
    }

    function getFilteredFeature(id:String):Feature {
        return null;
    }

    function getSelectedFeatures():Array {
    	if(currentFeature != null) {
        	return [currentFeature];
    	} else {
    		return new Array();
    	}
    }

    function getSelectedFeature(id:String):Feature {
        return null;
    }

    function getSubSelectedFeatures():Array {
        return subSelectedFeatures;
    }

    function getSubSelectedFeature(id:String):Feature {
        var feature:Feature = null;
        for (var i:String in subSelectedFeatures) {
            feature = Feature(subSelectedFeatures[i]);
            if (feature.getID() == id) {
                return feature;
            }
        }
        return null;
    }

    function getCurrentFeature():Feature {
        return currentFeature;
    }

    function getNearbyFeatures():Array {
        return new Array();
    }

    function getNearbyFeature(id:String):Feature {
        return null;
    }

    function setSelectedAttrInfoFeatureIDs(featureIDs:Array):Void {
    }

    function getSelectedAttrInfoFeatureIDs():Array {
        return new Array();
    }

    function getAttrInfoFeatureIDs():Array {
        return new Array();
    }

    function clearAttrInfoFeaturesIDs():Void {
    }

    function loadFeatureEnvelopes(features:Array, synchListener:SynchListener):Void {
        synchListener.onSynch(this, "ENVELOPES");
    }

    function getLevel():Number {
        return 0;
    }

    function moveLayerBackward(layer:UnboundFeatureLayer, end:Boolean):Void {
    }

    function moveLayerFrontward(layer:UnboundFeatureLayer, end:Boolean):Void {
    }

    function moveLayerTo(fromLayer:UnboundFeatureLayer, toLayer:UnboundFeatureLayer):Void { //only exchanges now
    }
    
    function hasAnnotations():Boolean {
  		return true;
  	}
}