/*----------------    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.Geometry;
import nl.idgis.giclient.geoma.NullGeometry;
import nl.idgis.giclient.gui.mapviewer.GeometryLayer;
import nl.idgis.giclient.gis.Feature;
import nl.idgis.giclient.gis.FeatureGeometryListener;
import nl.idgis.giclient.gui.mapviewer.MapGeometry;
import nl.idgis.giclient.event.StateEvent;
import nl.idgis.giclient.event.StateEventListener;
import nl.idgis.giclient.config.Colors;
import nl.idgis.giclient.gui.mapviewer.MapIcon;

class nl.idgis.giclient.gui.mapviewer.MapFeature implements FeatureGeometryListener, StateEventListener {
    
    private var feature:Feature = null;
    private var geometryLayer:GeometryLayer = null;
    private var mapGeometry:MapGeometry = null;
    private var mapIcon:MapIcon = null;
    
    private var mapGeometryActive:Boolean = false;
    
    private var normalColor:Number = 0x803A9E;
    private var selectionColor:Number = 0x000000;
    private var activeColor:Number = 0x803A9E;
    private var highlightColor:Number = 0x0000E6;
    private var activeTextColor:Number = 0x803A9E;
    private var normalTextColor:Number = 0xFFFFFF;
    private var opacity:Number = 60;
    
    function MapFeature(feature:Feature, geometryLayer:GeometryLayer) {
        this.feature = feature;
        this.geometryLayer = geometryLayer;
        
        feature.featureEventDispatcher.addFeatureGeometryListener(this);
        feature.addEventListener(this, "Feature", StateEvent.CHANGE, "editingStatus");        
        
        addMapGeometry();
        addMapIcon();
    }
    
    function remove():Void {
        feature.featureEventDispatcher.removeFeatureGeometryListener(this);
        feature.removeEventListener(this, "Feature", StateEvent.CHANGE, "editingStatus");
        
        removeMapGeometry();
        removeMapIcon();
    }
    
    function onChangeFeatureGeometry(feature:Feature):Void {
    	removeMapIcon();        
        removeMapGeometry();
        addMapGeometry();
        addMapIcon();        
    }
    
    function onStateEvent(stateEvent:StateEvent):Void {
        var sourceClassName:String = stateEvent.getSourceClassName();
        var actionType:Number = stateEvent.getActionType();
        var propertyName:String = stateEvent.getPropertyName();
        
        if (sourceClassName + "_" + actionType + "_" + propertyName == "Feature_" + StateEvent.CHANGE + "_editingStatus") {
            setMapGeometryLabelText(getLabelText());
            setMapGeometryAnnotationText(feature.getAnnotation());
        }
    }
    
    function getFeature():Feature {
        return feature;
    }
    
    private function addMapIcon():Void {
    	mapIcon = geometryLayer.addMapIcon(feature, mapGeometry);
    }
    
    private function addMapGeometry():Void {
        if (mapGeometry != null) {
            // EXCEPTION;
            return;
        }
        
        var geometry:Geometry = feature.getGeometry();
        if (geometry instanceof NullGeometry) {
            return;
        }
        if (mapGeometryActive) {
            mapGeometry = geometryLayer.addMapGeometry(geometry, MapGeometry.ACTIVE, 
            	Colors.currentColor, getLabelText(), feature.getAnnotation());
        } else {
            mapGeometry = geometryLayer.addMapGeometry(geometry, MapGeometry.NORMAL, 
            	Colors.editColor, getLabelText(), feature.getAnnotation());
        }
    }
    
    private function removeMapIcon():Void {
    	if(mapIcon == null) {
    		return;
    	}
    	
    	geometryLayer.removeMapIcon(mapIcon);
    	mapIcon = null;
    }
    
    private function removeMapGeometry():Void {
        if (mapGeometry == null) {
            return;
        }
        
        geometryLayer.removeMapGeometry(mapGeometry);
        mapGeometry = null;
    }
    
    function getMapGeometry():MapGeometry {
        return mapGeometry;
    }
    
    function setMapGeometryActive(mapGeometryActive:Boolean):Void {
        this.mapGeometryActive = mapGeometryActive;
        if (mapGeometry != null) {
            if (mapGeometryActive) {
                mapGeometry.setType(MapGeometry.ACTIVE);
                mapGeometry.setColor(Colors.currentColor);
            } else {
                mapGeometry.setType(MapGeometry.NORMAL);
                mapGeometry.setColor(Colors.editColor);
            }
        }
    }
    
    function setMapGeometryAnnotationText(annotation:String):Void {
        //this.mapGeometryActive = mapGeometryActive;
        if (mapGeometry != null) {
            mapGeometry.setAnnotationText(annotation);
        }
    }
    
    function setMapGeometryLabelText(labelText:String):Void {
        //this.mapGeometryActive = mapGeometryActive;
        if (mapGeometry != null) {
            mapGeometry.setLabelText(labelText);
        }
    }
    
    private function getLabelText():String {
        var featureID:String = feature.getID();
        var editingStatus:Number = feature.getEditingStatus();
        if (editingStatus == Feature.ADDED) {
            return "+" + featureID;
        } else if (editingStatus == Feature.UNCHANGED) {
            return "" + featureID;
        } else if (editingStatus == Feature.CHANGED) {
            return "*" + featureID;
        } else if (editingStatus == Feature.REMOVED) {
            return "x" + featureID;
        } else if (editingStatus == Feature.WAITING) {
            return "~" + featureID;
        }
        return null;
    }
    
    function toString():String {
        return "MapFeature(" + feature.getID() + ")";
    }
}