[Export(typeof(IDataVisualizer))]
    public class FlareClustererVisualizer : IDataVisualizer
    {
        private readonly Symbol _symbol;

        public FlareClustererVisualizer()
        {
            _symbol = SymbolManager.GetSymbol("MediumMarkerSymbol");
        }

        public string Name
        {
            get { return "Cluster Graphics"; }
        }

        public bool CanVisualize(IEnumerable<Feature> data)
        {
            if (data != null && data.Any())
            {
                if (data.First().Geometry == null)
                    return false;

                return data.First().Geometry.GeometryType.ToUpper() == "ESRIGEOMETRYPOINT" || data.First().Geometry.GeometryType.ToUpper() == "ESRIGEOMETRYPOLYGON";
            }
            return false;
        }

        public void Visualize(IEnumerable<Feature> data)
        {
            LoadFlareClusterer(data);
            if (!MapHandler.CurrentMap.Layers.Contains(GraphicsLayer))
            { MapHandler.CurrentMap.Layers.Add(GraphicsLayer); }
        }

        public void Hide()
        { GraphicsLayer.Visible = false; }

        public void Remove()
        {
            GraphicsLayer.Graphics.Clear();
            MapHandler.CurrentMap.Layers.Remove(GraphicsLayer);
        }

        public void Show()
        { GraphicsLayer.Visible = true; }

        public void ReloadData(IEnumerable<Feature> data)
        {
            GraphicsLayer.Graphics.Clear();
            FeatureMap.Clear();
            LoadFlareClusterer(data);
        }

        public bool HasPopup
        {
            get { return false; }
        }


        private GraphicsLayer _graphicsLayer;
        private GraphicsLayer GraphicsLayer
        {
            get
            {
                if (_graphicsLayer == null)
                { _graphicsLayer = new GraphicsLayer { Clusterer = new CustomFlareClusterer { MaximumFlareCount = 9 } }; }
                return _graphicsLayer;
            }
        }


        private Dictionary<Graphic, Feature> _featureMap = null;
        private Dictionary<Graphic, Feature> FeatureMap
        {
            get
            {
                if (_featureMap == null)
                { _featureMap = new Dictionary<Graphic, Feature>(); }
                return _featureMap;
            }
        }


        #region private methods
        private void LoadFlareClusterer(IEnumerable<Feature> features)
        {
            var newFeatures = features.Except(FeatureMap.Values);

            foreach (var feature in newFeatures)
            {
                DataContracts.Geometry geometry;
                if (feature.Geometry.GeometryType.ToUpper() == "ESRIGEOMETRYPOLYGON")
                { geometry = (DataContracts.Geometry)feature.Geometry.GetCentroid(); }
                else
                { geometry = feature.Geometry; }

                var g = new Graphic { Symbol = _symbol, Geometry = GeometryTranslator.Translate(geometry) };
                //foreach (var kvp in feature.Attributes)
                //{ g.Attributes.Add(kvp.Key.Description, kvp.Value); }

                FeatureMap.Add(g, feature);
                GraphicsLayer.Graphics.Add(g);
            }

            // uncomment this one to have the map tips show on hover
            MapHandler.CurrentMap.MouseMove += new MouseEventHandler(MouseEnter);

            // uncomment this one to have the map tips show on click
            //MapHandler.CurrentMap.MouseLeftButtonUp += new MouseButtonEventHandler(MouseEnter);
        }


        private FlareMapTip _currentMapTip = null;
        private void MouseEnter(object sender, MouseEventArgs e)
        {
            if (!(e.OriginalSource is Ellipse) && !(e.OriginalSource is FlareMapTip))
            {
                if (_currentMapTip != null)
                { _currentMapTip.Hide(); }

                return;
            }
            GeneralTransform generalTransform = MapHandler.CurrentMap.TransformToVisual(Application.Current.RootVisual);
            Point transformScreenPnt = generalTransform.Transform(e.GetPosition(MapHandler.CurrentMap));
            var graphics = GraphicsLayer.FindGraphicsInHostCoordinates(transformScreenPnt);

            var flareMapTip = sender as FlareMapTip;
            if (flareMapTip != null)
            { flareMapTip.MapTip_MouseEnter(sender, e); }

            var flareClusterer = GraphicsLayer.Clusterer as CustomFlareClusterer;
            if (flareClusterer != null)
            {
                Graphic flare = null;
                if (graphics.Count() > 1)
                { flare = flareClusterer.FindGraphicByEllipse(graphics, e.OriginalSource as Ellipse); }
                else
                { flare = graphics.FirstOrDefault(); }

                if (flare != null)
                {
                    var feature = _featureMap[flare] as Feature;
                    if (feature != null)
                    {
                        feature.IsSelected = true;
                        MapHandler.MapTip.Show(e);
                    }
                }
            }
        }
        #endregion

        /// <summary>
        /// Returns true if the data visualizer has been initialized.
        /// </summary>
        public bool IsInitialized { get; private set; }

        /// <summary>
        /// Initialize the data visualizer with the provided settings.
        /// </summary>
        /// <param name="customSettings"></param>
        public void Initialize(IDictionary<string, string> customSettings)
        {
            if (!IsInitialized)
                OnInitialize(customSettings);

            IsInitialized = true;
        }

        protected virtual void OnInitialize(IDictionary<string, string> customSettings)
        { }
    }