using System;
using System.Drawing;
using GeoAPI.Geometries;
using NetTopologySuite.Geometries.Utilities;
using SharpMap.Utilities;

namespace SharpMap
{
    /// <summary>
    /// A <see cref="SharpMap.Map"/> utility class, that encapsulates all data required for rendering.
    /// </summary>
    /// <remarks>This is a value class</remarks>
    public class MapViewport
    {
        private readonly Envelope _envelope;
        private readonly Coordinate _center;
        private Coordinate _centerOfInterest;

        private readonly float[] _mapTransformElements;
        private readonly float[] _mapTransformInvertedElements;

        private readonly double[] _worldToMapElements;
        private readonly double[] _worldToMapElementsCareAboutTransform;

        private double _mapScale;
        private int _lastDpi;

        private readonly object _lockMapScale = new object();

        /// <summary>
        /// Creates an instance of this class
        /// </summary>
        /// <param name="mapId">The id of the map</param>
        /// <param name="srid">The spatial reference</param>
        /// <param name="zoom">current map zoom</param>
        /// <param name="mapHeight">map height</param>
        /// <param name="env">The envelope containing the viewport</param>
        /// <param name="size">The size of the viewport</param>
        /// <param name="pixelAspectRatio">A ratio between width and height</param>
        /// <param name="mapTransform">An affine map transform matrix</param>
        /// <param name="mapTransformInverted">The affine map transformation that inverts <paramref name="mapTransform"/></param>
        /// <param name="mapTransformRotation">The rotation in degrees applied by <paramref name="mapTransform"/></param>
        public MapViewport(Guid mapId, int srid, double zoom, double mapHeight, Envelope env, Size size, double pixelAspectRatio, 
            System.Drawing.Drawing2D.Matrix mapTransform, System.Drawing.Drawing2D.Matrix mapTransformInverted,
            float mapTransformRotation)
        {
            ID = mapId;
            SRID = srid;

            Zoom = zoom;
            MapHeight = mapHeight;

            _envelope = env.Copy();
            Size = size;
            _center = env.Centre;

            PixelAspectRatio = pixelAspectRatio;
            PixelWidth = Zoom / size.Width; 
            PixelHeight = PixelWidth * pixelAspectRatio;

            _mapTransformElements = mapTransform.Elements;
            _mapTransformInvertedElements = mapTransformInverted.Elements;
            MapTransformRotation = mapTransformRotation;

            // pre-calculated for use when MapTransformRotation == 0
            Left = Center.X - Zoom * 0.5;
            Top = Center.Y + mapHeight * 0.5;

            // pre-defined for use when MapTransformation != 0
            if (!mapTransformRotation.Equals(0f))
            {
                _worldToMapElements = Transform.WorldToMapMatrix(
                    Center, PixelWidth, PixelHeight, MapTransformRotation, Size, false).MatrixEntries;

                _worldToMapElementsCareAboutTransform = Transform.WorldToMapMatrix(
                    Center, PixelWidth, PixelHeight, MapTransformRotation, Size, true).MatrixEntries;
            }
        }

        /// <summary>
        /// Creates an instance of this class based on the provided map
        /// </summary>
        /// <param name="map">The Map</param>
        public MapViewport(Map map)
            : this(map.ID, map.SRID, map.Zoom, map.MapHeight, map.Envelope, map.Size, map.PixelAspectRatio,
                map.MapTransform, map.MapTransformInverted, map.MapTransformRotation)
        {
            CenterOfInterest = map.CenterOfInterest;
        }

        /// <summary>
        /// Gets a value indicating the which <see cref="Map"/> this viewport belongs to.
        /// </summary>
        public Guid ID { get; }

        /// <summary>
        /// Gets a value indicating the spatial reference id of the map
        /// </summary>
        public int SRID { get; /*set;*/ }

        /// <summary>
        /// Gets a value indicating the size of the map
        /// </summary>
        public Size Size { get; }

        /// <summary>
        /// <para>Gets the rectilinear extents of the map based on the current <see cref="Zoom"/>,
        /// <see cref="Center"/>, map <see cref="Size"/>, and (optionally) the <see cref="MapTransform"/></para>
        /// <para>If a <see cref="MapTransform"/> is applied, the envelope CONTAINING the rotated view
        /// will be returned (used by layers to spatially select data) and the aspect ratio will NOT be the
        /// same as map <see cref="Size"/>. If aspect ratio is important then refer to <see cref="Zoom"/>
        /// and <see cref="MapHeight"/></para> 
        /// </summary>
        public Envelope Envelope => _envelope.Copy();

        /// <summary>
        /// Gets a value indicating the transformation that has to be applied when
        /// rendering the map
        /// </summary>
        public System.Drawing.Drawing2D.Matrix MapTransform
        {
            get
            {
                return new System.Drawing.Drawing2D.Matrix(
                    _mapTransformElements[0],
                    _mapTransformElements[1],
                    _mapTransformElements[2],
                    _mapTransformElements[3],
                    _mapTransformElements[4],
                    _mapTransformElements[5]
                );
            }
        }

        /// <summary>
        /// Gets a value indicating the inverse transformation that is applied when
        /// rendering the map
        /// </summary>
        public System.Drawing.Drawing2D.Matrix MapTransformInverted
        {
            get
            {
                return new System.Drawing.Drawing2D.Matrix(
                    _mapTransformInvertedElements[0],
                    _mapTransformInvertedElements[1],
                    _mapTransformInvertedElements[2],
                    _mapTransformInvertedElements[3],
                    _mapTransformInvertedElements[4],
                    _mapTransformInvertedElements[5]
                );
            }
        }

        /// <summary>
        /// Map rotation in degrees (defined by <see cref="MapTransform"/>)
        /// </summary>
        public float MapTransformRotation { get; }

        /// <summary>
        /// Cached affine transformation used to transform world coordinates from apparent rotated coordinate frame (ie MapTransformRotation != 0)
        /// to image space. Unlike MapTransform, this matrix defines a complete transformation from World to Image taking into account MapRotation.
        /// 2 variants are available, depending on whether or not map rotation has already been applied.
        /// </summary>
        internal AffineTransformation WorldToMapTransform(bool careAboutTransform)
        {
            if (careAboutTransform)
                return new AffineTransformation(
                    _worldToMapElementsCareAboutTransform[0],
                    _worldToMapElementsCareAboutTransform[1],
                    _worldToMapElementsCareAboutTransform[2],
                    _worldToMapElementsCareAboutTransform[3],
                    _worldToMapElementsCareAboutTransform[4],
                    _worldToMapElementsCareAboutTransform[5]
                );
            else
                return new AffineTransformation(
                    _worldToMapElements[0],
                    _worldToMapElements[1],
                    _worldToMapElements[2],
                    _worldToMapElements[3],
                    _worldToMapElements[4],
                    _worldToMapElements[5]
                );
        }
        
        /// <summary>
        /// Gets a value indicating the center of the map viewport
        /// </summary>
        public Coordinate Center => _center.Copy();

        /// <summary>
        /// Gets a value indicating the center of the map viewport
        /// </summary>
        public Coordinate CenterOfInterest
        {
            get => _centerOfInterest?.Copy() ?? Center;
            set => _centerOfInterest = value;
        }

        /// <summary>
        /// Gets a value indicating the zoom of the map viewport
        /// </summary>
        /// <remarks>This value is identical to <see cref="MapWidth"/></remarks>
        public double Zoom { get; /*set;*/ }

        /// <summary>
        /// Gets a value indicating the height of the map viewport in world units
        /// </summary>
        public double MapHeight { get; }

        /// <summary>
        /// Gets a value indicating the width of the map viewport in world units
        /// </summary>
        /// <remarks>This value is equal to <see cref="Zoom"/></remarks>
        private double MapWidth => Zoom;

        /// <summary>
        /// Applicable to non-rotated views only, returning the minimum X value of the map viewport in world units
        /// </summary>
        public double Left { get; }
        
        /// <summary>
        /// Applicable to non-rotated views only, returning the maximum Y value of the map viewport in world units
        /// </summary>
        public double Top { get; }

        /// <summary>
        /// Gets or sets the aspect-ratio of the pixel scales. A value less than 
        /// 1 will make the map stretch upwards, and larger than 1 will make it smaller.
        /// </summary>
        /// <exception cref="ArgumentException">Throws an argument exception when value is 0 or less.</exception>
        public double PixelAspectRatio { get; }

        /// <summary>
        /// Returns the width of a pixel in world coordinate units.
        /// </summary>
        public double PixelWidth { get; }

        /// <summary>
        /// Returns the height of a pixel in world coordinate units.
        /// </summary>
        public double PixelHeight { get; }

        /// <summary>
        /// Function to compute the denominator of the viewport's scale when using a given <paramref name="dpi"/> resolution.
        /// </summary>
        /// <param name="dpi">The resolution</param>
        /// <returns>The scale's denominator</returns>
        public double GetMapScale(int dpi)
        {
            if (_lastDpi != dpi)
            {
                lock (_lockMapScale)
                    if (_lastDpi != dpi)
                    {
                        _mapScale = ScaleCalculations.CalculateScaleNonLatLong(Zoom, Size.Width, 1, dpi);
                        _lastDpi = dpi;
                    }
            }

            return _mapScale;
        }

        /// <summary>
        /// Converts an array of world coordinates to image coordinates based on the current <see cref="Zoom"/>, <see cref="Center"/>,
        /// map <see cref="Size"/>, and (optionally) the <see cref="MapTransform"/>.
        /// </summary>
        /// <param name="coordinates">Coordinate array in world coordinates</param>
        /// <param name="careAboutMapTransform">Indicates whether <see cref="MapTransform"/> should be applied. True for typical coordinate calcs,
        /// False when rendering to image as the Graphics object has already applied the MapTransform</param>
        /// <returns>PointF array in image coordinates</returns>
        public PointF[] WorldToImage(Coordinate[] coordinates, bool careAboutMapTransform = false)
        {
            // see WorldToImage discussion in Map.cs. This is a slightly shortened form using cached values.
            if (MapTransformRotation.Equals(0f))
                return Transform.WorldToMap(coordinates, Left, Top, PixelWidth, PixelHeight);

            var matrix = WorldToMapTransform(careAboutMapTransform);
            return Transform.WorldToMap(coordinates, matrix);
        }
        
        /// <summary>
        /// Converts a point in world coordinates to image coordinates based on the current <see cref="Zoom"/>, <see cref="Center"/>,
        /// map <see cref="Size"/>, and (optionally) the <see cref="MapTransform"/>.
        /// </summary>
        /// <param name="p">Point in world coordinates</param>
        /// <param name="careAboutMapTransform">Indicates whether <see cref="MapTransform"/> should be applied. When rendering to image,
        /// the Graphics object has usually applied MapTransform</param>
        /// <returns>PointF in image coordinates</returns>
        public PointF WorldToImage(Coordinate p, bool careAboutMapTransform = false)
        {
            var points = WorldToImage(new Coordinate[] {p}, careAboutMapTransform);
            return points[0];
        }

        /// <summary>
        /// Converts a point array from image coordinates to world coordinates based on the current <see cref="Zoom"/>, <see cref="Center"/>,
        /// map <see cref="Size"/>, and (optionally) the <see cref="MapTransform"/>.
        /// </summary>
        /// <param name="points">Point array in image coordinates. Note: if you wish to preserve the input values then
        /// you must clone the point array as it will be modified if a MapTransform is applied</param>
        /// <param name="careAboutMapTransform">Indicates whether <see cref="MapTransform"/> should be applied. </param>
        /// <returns>Point array in world coordinates</returns>
        public Coordinate[] ImageToWorld(PointF[] points, bool careAboutMapTransform = false)
        {
            if (careAboutMapTransform && !MapTransformRotation.Equals(0f))
                using (var transformInv = MapTransformInverted)
                    transformInv.TransformPoints(points);

            return Transform.MapToWorld(points, Center, Zoom, MapHeight, PixelWidth, PixelHeight);
        }

        /// <summary>
        /// Converts a point from image coordinates to world coordinates based on the current <see cref="Zoom"/>, <see cref="Center"/>,
        /// map <see cref="Size"/>, and (optionally) the <see cref="MapTransform"/>.
        /// </summary>
        /// <param name="p">Point in image coordinates. Note: if you wish to preserve the input value then
        /// you must clone the point as it will be modified if a MapTransform is applied</param>
        /// <param name="careAboutMapTransform">Indicates whether <see cref="MapTransform"/> should be applied. </param>
        /// <returns>Point in world coordinates</returns>
        public Coordinate ImageToWorld(PointF p, bool careAboutMapTransform = false)
        {
            var pts = ImageToWorld(new PointF[] {p}, careAboutMapTransform);
            return pts[0];
        }

        /// <summary>
        /// Creates a map viewport from a given map
        /// </summary>
        /// <param name="map">The map</param>
        /// <returns></returns>
        public static implicit operator MapViewport(Map map)
        {
            return new MapViewport(map);
        }
    }
}