// Copyright 2005, 2006 - Morten Nielsen (www.iter.dk)
//
// This file is part of SharpMap.
// SharpMap 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 of the License, or
// (at your option) any later version.
// 
// SharpMap 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 SharpMap; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 

using System;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using SharpMap.Data;
using SharpMap.Data.Providers;
using GeoAPI.Geometries;
using SharpMap.Rendering;
using SharpMap.Rendering.Thematics;
using SharpMap.Styles;
using System.Collections.Generic;
using Common.Logging;

namespace SharpMap.Layers
{
    /// <summary>
    /// Class for vector layer properties
    /// </summary>
    [Serializable]
    public class VectorLayer : Layer, ICanQueryLayer, ICloneable
    {
        static readonly ILog _logger = LogManager.GetLogger(typeof(VectorLayer));

        private bool _clippingEnabled;
        private bool _isQueryEnabled = true;
        private IBaseProvider _dataSource;
        private SmoothingMode _smoothingMode;
        private ITheme _theme;
        private Envelope _envelope;

        /// <summary>
        /// Initializes a new layer
        /// </summary>
        /// <param name="layername">Name of layer</param>
        public VectorLayer(string layername)
            : base(new VectorStyle())
        {
            LayerName = layername;
            SmoothingMode = SmoothingMode.AntiAlias;
        }

        /// <summary>
        /// Initializes a new layer with a specified datasource
        /// </summary>
        /// <param name="layername">Name of layer</param>
        /// <param name="dataSource">Data source</param>
        public VectorLayer(string layername, IBaseProvider dataSource) : this(layername)
        {
            _dataSource = dataSource;
        }
        /// <summary>
        /// Gets or sets a Dictionary with themes suitable for this layer. A theme in the dictionary can be used for rendering be setting the Theme Property using a delegate function
        /// </summary>
        public Dictionary<string, ITheme> Themes
        {
            get;
            set;
        }



        /// <summary>
        /// Gets or sets thematic settings for the layer. Set to null to ignore thematics
        /// </summary>
        public ITheme Theme
        {
            get { return _theme; }
            set { _theme = value; }
        }

        /// <summary>
        /// Specifies whether polygons should be clipped prior to rendering
        /// </summary>
        /// <remarks>
        /// <para>Clipping will clip <see cref="GeoAPI.Geometries.IPolygon"/> and
        /// <see cref="GeoAPI.Geometries.IMultiPolygon"/> to the current view prior
        /// to rendering the object.</para>
        /// <para>Enabling clipping might improve rendering speed if you are rendering 
        /// only small portions of very large objects.</para>
        /// </remarks>
        public bool ClippingEnabled
        {
            get { return _clippingEnabled; }
            set { _clippingEnabled = value; }
        }

        /// <summary>
        /// Render whether smoothing (antialiasing) is applied to lines and curves and the edges of filled areas
        /// </summary>
        public SmoothingMode SmoothingMode
        {
            get { return _smoothingMode; }
            set { _smoothingMode = value; }
        }

        /// <summary>
        /// Gets or sets the datasource
        /// </summary>
        public IBaseProvider DataSource
        {
            get { return _dataSource; }
            set
            {
                _dataSource = value;
                _envelope = null;
            }
        }

        /// <summary>
        /// Gets or sets the rendering style of the vector layer.
        /// </summary>
        public new VectorStyle Style
        {
            get { return base.Style as VectorStyle; }
            set { base.Style = value; }
        }

        /// <summary>
        /// Returns the extent of the layer
        /// </summary>
        /// <returns>Bounding box corresponding to the extent of the features in the layer</returns>
        public override Envelope Envelope
        {
            get
            {
                if (DataSource == null)
                    throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));

                if (_envelope != null && CacheExtent)
                    return ToTarget(_envelope.Copy());

                Envelope box;
                lock (_dataSource)
                {
                    // Is datasource already open?
                    bool wasOpen = DataSource.IsOpen;
                    if (!wasOpen) { DataSource.Open(); }

                    box = DataSource.GetExtents();

                    if (!wasOpen) { DataSource.Close(); }
                }

                if (CacheExtent)
                    _envelope = box;

                return ToTarget(box);
            }
        }
        /// <summary>
        /// Gets or sets a value indicating whether the layer envelope should be treated as static or not.
        /// </summary>
        /// <remarks>
        /// When CacheExtent is enabled the layer Envelope will be calculated only once from DataSource, this 
        /// helps to speed up the Envelope calculation with some DataProviders. Default is false for backward
        /// compatibility.
        /// </remarks>
        public virtual bool CacheExtent { get; set; }

        /// <summary>
        /// Gets or sets the SRID of this VectorLayer's data source
        /// </summary>
        public override int SRID
        {
            get
            {
                if (DataSource == null)
                    throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));

                return DataSource.SRID;
            }
            set
            {
                DataSource.SRID = value;
                base.SRID = value;
            }
        }

        #region IDisposable Members

        /// <summary>
        /// Disposes the object
        /// </summary>
        protected override void ReleaseManagedResources()
        {
            if (DataSource != null)
                DataSource.Dispose();
            base.ReleaseManagedResources();
        }

        #endregion

        /// <summary>
        /// Renders the layer to a graphics object, using the given map viewport
        /// </summary>
        /// <param name="g">Graphics object reference</param>
        /// <param name="mvp">Map view port</param>
        public override void Render(Graphics g, MapViewport mvp)
        {
            if (mvp.Center == null)
                throw (new ApplicationException("Cannot render map. View center not specified"));

            g.SmoothingMode = SmoothingMode;
            var envelope = ToSource(mvp.Envelope); //View to render

            if (DataSource == null)
                throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));

            //If thematics is enabled, we use a slighty different rendering approach
            if (Theme != null)
                RenderInternal(g, mvp, envelope, Theme);
            else
                RenderInternal(g, mvp, envelope);


            //OnLayerRendered(g);
            // Obsolete (and will cause infinite loop)
            base.Render(g, mvp);
        }

        /// <summary>
        /// Method to render this layer to the map, applying <paramref name="theme"/>.
        /// </summary>
        /// <param name="g">The graphics object</param>
        /// <param name="map">The map object</param>
        /// <param name="envelope">The envelope to render</param>
        /// <param name="theme">The theme to apply</param>
        protected void RenderInternal(Graphics g, MapViewport map, Envelope envelope, ITheme theme)
        {
            var canvasArea = RectangleF.Empty;
            var combinedArea = RectangleF.Empty;

            var ds = new FeatureDataSet();
            lock (_dataSource)
            {
                // Is datasource already open?
                bool wasOpen = DataSource.IsOpen;
                if (!wasOpen) { DataSource.Open(); }

                DataSource.ExecuteIntersectionQuery(envelope, ds);

                if (!wasOpen) { DataSource.Close(); }
            }

            double scale = map.GetMapScale((int)g.DpiX);
            double zoom = map.Zoom;

            Func<MapViewport, FeatureDataRow, IStyle> evalStyle;


            if (theme is IThemeEx)
                evalStyle = new ThemeExEvaluator((IThemeEx)theme).GetStyle;
            else
                evalStyle = new ThemeEvaluator(theme).GetStyle;
            
            foreach (FeatureDataTable features in ds.Tables)
            {
                // Transform geometries if necessary
                if (CoordinateTransformation != null)
                {
                    for (int i = 0; i < features.Count; i++)
                    {
                        features[i].Geometry = ToTarget(features[i].Geometry);
                    }
                }

                //Linestring outlines is drawn by drawing the layer once with a thicker line
                //before drawing the "inline" on top.
                if (Style.EnableOutline)
                {
                    for (int i = 0; i < features.Count; i++)
                    {
                        var feature = features[i];
                        var outlineStyle = evalStyle(map, feature) as VectorStyle;
                        if (outlineStyle == null) continue;
                        if (!(outlineStyle.Enabled && outlineStyle.EnableOutline)) continue;

                        var compare = outlineStyle.VisibilityUnits == VisibilityUnits.ZoomLevel ? zoom : scale;

                        if (!(outlineStyle.MinVisible <= compare && compare <= outlineStyle.MaxVisible)) continue;

                        using (outlineStyle = outlineStyle.Clone())
                        {
                            if (outlineStyle != null)
                            {
                                //Draw background of all line-outlines first
                                if (feature.Geometry is ILineString)
                                {
                                    canvasArea = VectorRenderer.DrawLineStringEx(g, feature.Geometry as ILineString, outlineStyle.Outline,
                                                                        map, outlineStyle.LineOffset);
                                }
                                else if (feature.Geometry is IMultiLineString)
                                {
                                    canvasArea = VectorRenderer.DrawMultiLineStringEx(g, feature.Geometry as IMultiLineString,
                                                                        outlineStyle.Outline, map, outlineStyle.LineOffset);
                                }
                                combinedArea = canvasArea.ExpandToInclude(combinedArea);
                            }
                        }
                    }
                }


                for (int i = 0; i < features.Count; i++)
                {
                    var feature = features[i];
                    var style = evalStyle(map, feature);
                    if (style == null) continue;
                    if (!style.Enabled) continue;

                    double compare = style.VisibilityUnits == VisibilityUnits.ZoomLevel ? zoom : scale;

                    if (!(style.MinVisible <= compare && compare <= style.MaxVisible)) continue;


                    IEnumerable<IStyle> stylesToRender = GetStylesToRender(style);

                    if (stylesToRender == null)
                        return;

                    foreach (var vstyle in stylesToRender)
                    {
                        if (!(vstyle is VectorStyle) || !vstyle.Enabled)
                            continue;

                        using (var clone = (vstyle as VectorStyle).Clone())
                        {
                            if (clone != null)
                            {
                                canvasArea = RenderGeometryEx(g, map, feature.Geometry, clone);
                                combinedArea = canvasArea.ExpandToInclude(combinedArea);
                            }
                        }
                    }
                }
            }

            CanvasArea = combinedArea;
        }

        /// <summary>
        /// Method to render this layer to the map, applying <see cref="Style"/>.
        /// </summary>
        /// <param name="g">The graphics object</param>
        /// <param name="map">The map object</param>
        /// <param name="envelope">The envelope to render</param>
        protected void RenderInternal(Graphics g, MapViewport map, Envelope envelope)
        {
            //if style is not enabled, we don't need to render anything
            if (!Style.Enabled) return;

            IEnumerable<IStyle> stylesToRender = GetStylesToRender(Style);

            if (stylesToRender == null)
                return;

            var canvasArea = RectangleF.Empty;
            var combinedArea = RectangleF.Empty;

            Collection<IGeometry> geoms = null;

            foreach (var style in stylesToRender)
            {
                if (!(style is VectorStyle) || !style.Enabled)
                    continue;
                using (var vStyle = (style as VectorStyle).Clone())
                {
                    if (vStyle != null)
                    {
                        if (geoms == null)
                        {
                            lock (_dataSource)
                            {
                                // Is datasource already open?
                                bool wasOpen = DataSource.IsOpen;
                                if (!wasOpen) { DataSource.Open(); }

                                // Read data
                                geoms = DataSource.GetGeometriesInView(envelope);

                                if (!wasOpen) { DataSource.Close(); }
                            }

                            if (_logger.IsDebugEnabled)
                            {
                                _logger.DebugFormat("Layer {0}, NumGeometries {1}", LayerName, geoms.Count);
                            }

                            // Transform geometries if necessary
                            if (CoordinateTransformation != null)
                            {
                                for (int i = 0; i < geoms.Count; i++)
                                {
                                    geoms[i] = ToTarget(geoms[i]);
                                }
                            }
                        }

                        if (vStyle.LineSymbolizer != null)
                        {
                            vStyle.LineSymbolizer.Begin(g, map, geoms.Count);
                        }
                        else
                        {
                            //Linestring outlines is drawn by drawing the layer once with a thicker line
                            //before drawing the "inline" on top.
                            if (vStyle.EnableOutline)
                            {
                                foreach (var geom in geoms)
                                {
                                    if (geom != null)
                                    {
                                        //Draw background of all line-outlines first
                                        if (geom is ILineString)
                                            canvasArea = VectorRenderer.DrawLineStringEx(g, geom as ILineString, vStyle.Outline, map, vStyle.LineOffset);
                                        else if (geom is IMultiLineString)
                                            canvasArea = VectorRenderer.DrawMultiLineStringEx(g, geom as IMultiLineString, vStyle.Outline, map, vStyle.LineOffset);
                                        combinedArea = canvasArea.ExpandToInclude(combinedArea);
                                    }
                                }
                            }
                        }

                        foreach (IGeometry geom in geoms)
                        {
                            if (geom != null)
                            {
                                canvasArea = RenderGeometryEx(g, map, geom, vStyle);
                                combinedArea = canvasArea.ExpandToInclude(combinedArea);
                            }
                        }

                        if (vStyle.LineSymbolizer != null)
                        {
                            vStyle.LineSymbolizer.Symbolize(g, map);
                            vStyle.LineSymbolizer.End(g, map);
                        }
                    }
                }
            }

            CanvasArea = combinedArea;
        }

        /// <summary>
        /// Unpacks styles to render (can be nested group-styles)
        /// </summary>
        /// <param name="style"></param>
        /// <returns></returns>
        public static IEnumerable<IStyle> GetStylesToRender(IStyle style)
        {
            IStyle[] stylesToRender = null;
            if (style is GroupStyle)
            {
                var gs = style as GroupStyle;
                var styles = new List<IStyle>();
                for (var i = 0; i < gs.Count; i++)
                {
                    styles.AddRange(GetStylesToRender(gs[i]));
                }
                stylesToRender = styles.ToArray();
            }
            else if (style is VectorStyle)
            {
                stylesToRender = new[] { style };
            }

            return stylesToRender;
        }

        /// <summary>
        /// Method to render <paramref name="feature"/> using <paramref name="style"/>
        /// </summary>
        /// <param name="g">The graphics object</param>
        /// <param name="map">The map</param>
        /// <param name="feature">The feature's geometry</param>
        /// <param name="style">The style to apply</param>
        protected void RenderGeometry(Graphics g, MapViewport map, IGeometry feature, VectorStyle style)
        {
            RenderGeometryEx(g, map, feature, style);
        }

        /// <summary>
        /// Function to render <paramref name="feature"/> using <paramref name="style"/> and returning the area covered.
        /// </summary>
        /// <param name="g">The graphics object</param>
        /// <param name="map">The map</param>
        /// <param name="feature">The feature's geometry</param>
        /// <param name="style">The style to apply</param>
        protected RectangleF RenderGeometryEx(Graphics g, MapViewport map, IGeometry feature, VectorStyle style)
        {
            if (feature == null) return RectangleF.Empty;

            var geometryType = feature.OgcGeometryType;
            switch (geometryType)
            {
                case OgcGeometryType.Polygon:
                    if (style.EnableOutline)
                        return VectorRenderer.DrawPolygonEx(g, (IPolygon)feature, style.Fill, style.Outline, _clippingEnabled,
                                                   map);
                    else
                        return VectorRenderer.DrawPolygonEx(g, (IPolygon)feature, style.Fill, null, _clippingEnabled, map);

                case OgcGeometryType.MultiPolygon:
                    if (style.EnableOutline)
                        return VectorRenderer.DrawMultiPolygonEx(g, (IMultiPolygon)feature, style.Fill, style.Outline, _clippingEnabled, map);
                    return VectorRenderer.DrawMultiPolygonEx(g, (IMultiPolygon)feature, style.Fill, null, _clippingEnabled, map);
                case OgcGeometryType.LineString:
                    if (style.LineSymbolizer != null)
                    {
                         style.LineSymbolizer.Render(map, (ILineString)feature, g);
                         return RectangleF.Empty;
                    }
                    return VectorRenderer.DrawLineStringEx(g, (ILineString)feature, style.Line, map, style.LineOffset);

                case OgcGeometryType.MultiLineString:
                    if (style.LineSymbolizer != null)
                    {
                        style.LineSymbolizer.Render(map, (IMultiLineString)feature, g);
                        return RectangleF.Empty;
                    }
                    return VectorRenderer.DrawMultiLineStringEx(g, (IMultiLineString)feature, style.Line, map, style.LineOffset);
                    

                case OgcGeometryType.Point:
                    if (style.PointSymbolizer != null)
                        return VectorRenderer.DrawPointEx(style.PointSymbolizer, g, (IPoint)feature, map);

                    if (style.Symbol != null || style.PointColor == null)
                        return VectorRenderer.DrawPointEx(g, (IPoint)feature, style.Symbol, style.SymbolScale, style.SymbolOffset,
                                                 style.SymbolRotation, map);

                    return VectorRenderer.DrawPointEx(g, (IPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map);

                case OgcGeometryType.MultiPoint:
                    if (style.PointSymbolizer != null)
                        return VectorRenderer.DrawMultiPointEx(style.PointSymbolizer, g, (IMultiPoint)feature, map);
                    
                    if (style.Symbol != null || style.PointColor == null)
                        return VectorRenderer.DrawMultiPointEx(g, (IMultiPoint)feature, style.Symbol, style.SymbolScale, style.SymbolOffset, style.SymbolRotation, map);

                    return VectorRenderer.DrawMultiPointEx(g, (IMultiPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map);

                case OgcGeometryType.GeometryCollection:
                    var coll = (IGeometryCollection)feature;
                    var combinedArea = RectangleF.Empty;
                    for (var i = 0; i < coll.NumGeometries; i++)
                    {
                        IGeometry geom = coll[i];
                        var canvasArea = RenderGeometryEx(g, map, geom, style);
                        combinedArea = canvasArea.ExpandToInclude(combinedArea);
                    }
                    return combinedArea;
                
            }
            throw new NotSupportedException();
        }

        #region Implementation of ICanQueryLayer

        /// <summary>
        /// Returns the data associated with all the geometries that are intersected by 'geom'
        /// </summary>
        /// <param name="box">Geometry to intersect with</param>
        /// <param name="ds">FeatureDataSet to fill data into</param>
        public void ExecuteIntersectionQuery(Envelope box, FeatureDataSet ds)
        {
            box = ToSource(box);

            int tableCount = ds.Tables.Count;

            lock (_dataSource)
            {
                // Is datasource already open?
                bool wasOpen = _dataSource.IsOpen;
                if (!wasOpen) { _dataSource.Open(); }

                _dataSource.ExecuteIntersectionQuery(box, ds);

                if (!wasOpen) { DataSource.Close(); }
            }

            if (ds.Tables.Count > tableCount)
            {
                //We added a table, name it according to layer
                ds.Tables[ds.Tables.Count - 1].TableName = LayerName;
            }
        }

        /// <summary>
        /// Returns the data associated with all the geometries that are intersected by 'geom'
        /// </summary>
        /// <param name="geometry">Geometry to intersect with</param>
        /// <param name="ds">FeatureDataSet to fill data into</param>
        public void ExecuteIntersectionQuery(IGeometry geometry, FeatureDataSet ds)
        {
            geometry = ToSource(geometry);

            int tableCount = ds.Tables.Count;

            lock (_dataSource)
            {
                // Is datasource already open?
                bool wasOpen = DataSource.IsOpen;
                if (!wasOpen) { DataSource.Open(); }

                _dataSource.ExecuteIntersectionQuery(geometry, ds);

                if (!wasOpen) { DataSource.Close(); }
            }

            if (ds.Tables.Count > tableCount)
            {
                //We added a table, name it according to layer
                ds.Tables[ds.Tables.Count - 1].TableName = LayerName;
            }
        }

        /// <summary>
        /// Whether the layer is queryable when used in a SharpMap.Web.Wms.WmsServer, ExecuteIntersectionQuery() will be possible in all other situations when set to FALSE
        /// </summary>
        public bool IsQueryEnabled
        {
            get { return _isQueryEnabled; }
            set { _isQueryEnabled = value; }
        }

        #endregion

        /// <inheritdoc cref="ICloneable.Clone()"/>>
        public object Clone()
        {
            var res = (VectorLayer)MemberwiseClone();
            res.Style = Style.Clone();
            if (Theme is ICloneable)
                res.Theme = (ITheme)((ICloneable)Theme).Clone();
            return res;
        }

        #region Theme evaluators
        private abstract class ThemeEvaluatorBase
        {
            public abstract IStyle GetStyle(MapViewport mvp, FeatureDataRow feature);
        }

        private class ThemeEvaluator : ThemeEvaluatorBase
        {
            private readonly ITheme _theme;

            public ThemeEvaluator(ITheme theme)
            {
                _theme = theme;
            }
            public sealed override IStyle GetStyle(MapViewport mvp, FeatureDataRow feature)
            {
                return _theme.GetStyle(feature);
            }
        }

        private class ThemeExEvaluator : ThemeEvaluatorBase
        {
            private readonly IThemeEx _theme;

            public ThemeExEvaluator(IThemeEx theme)
            {
                _theme = theme;
            }
            public sealed override IStyle GetStyle(MapViewport mvp, FeatureDataRow feature)
            {
                return _theme.GetStyle(mvp, feature);
            }
        }
        #endregion
    }
}