using System;
using System.Drawing;
using GeoAPI.Geometries;

namespace SharpMap
{
    /// <summary>
    /// Utility class that checks Viewport min/max Zoom and constraint
    /// </summary>
    [Serializable]
    public class MapViewPortGuard
    {
        private double _minimumZoom;
        private double _maximumZoom;
        private Envelope _maximumExtents;
        private double _pixelAspectRatio;
        const double MinMinZoomValue = 2d * double.Epsilon;

        /// <summary>
        /// Gets or sets a value indicating the minimum zoom level.
        /// </summary>
        public double MinimumZoom
        {
            get { return _minimumZoom; }
            set
            {
                if (value < MinMinZoomValue)
                    value = MinMinZoomValue;
                _minimumZoom = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating the maximum zoom level.
        /// </summary>
        public double MaximumZoom
        {
            get { return _maximumZoom; }
            set
            {
                if (value < _minimumZoom)
                    value = _minimumZoom;
                _maximumZoom = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating the maximum extents
        /// </summary>
        public Envelope MaximumExtents
        {
            get { return _maximumExtents ?? (_maximumExtents = new Envelope()); }
            set { _maximumExtents = value; }
        }

        /// <summary>
        /// Gets or sets the size of the Map in device units (Pixel)
        /// </summary>
        public Size Size { get; set; }

        /// <summary>
        /// Gets or sets the aspect-ratio of the pixel scales. A value less than 
        /// 1 will make the map streach 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 { return _pixelAspectRatio; }
            set
            {
                if (value <= 0)
                    throw new ArgumentException("Invalid Pixel Aspect Ratio");
                _pixelAspectRatio = value;
            }
        }

        /// <summary>
        /// Creates an instance of this class
        /// </summary>
        internal MapViewPortGuard(Size size, double minZoom, double maxZoom)
        {
            Size = size;
            MinimumZoom = minZoom;
            MaximumZoom = maxZoom;
            PixelAspectRatio = 1d;
        }

        /// <summary>
        /// Gets or sets a value indicating if <see cref="Map.MaximumExtents"/> should be enforced or not.
        /// </summary>
        public bool EnforceMaximumExtents { get; set; }

        /// <summary>
        /// Verifies the zoom level and center of the map
        /// </summary>
        /// <param name="zoom">The zoom level to test</param>
        /// <param name="center">The center of the map. This coordinate might change so you <b>must</b> provide a copy if you want to preserve the old value</param>
        /// <returns>The zoom level, might have changed</returns>
        public double VerifyZoom(double zoom, Coordinate center)
        {
            // Zoom within valid region
            if (zoom < _minimumZoom)
                zoom = _minimumZoom;
            else if (zoom > _maximumZoom)
                zoom = _maximumZoom;

            if (!EnforceMaximumExtents)
                return zoom;

            double arWidth = (double)Size.Width/Size.Height;

            if (zoom > _maximumExtents.Width)
                zoom = _maximumExtents.Width;
            if (zoom > arWidth * _maximumExtents.Height)
                zoom = arWidth * _maximumExtents.Height;
            zoom = VerifyValidViewport(zoom, center);

            return zoom;
        }

        /// <summary>
        /// Verifies the valid viewport, makes adjustments if required
        /// </summary>
        /// <param name="zoom">The current zoom</param>
        /// <param name="center">The </param>
        /// <returns>The verified zoom level</returns>
        private double VerifyValidViewport(double zoom, Coordinate center)
        {
            var maxExtents = MaximumExtents ?? new Envelope();
            if (maxExtents.IsNull)
                return zoom;

            double halfWidth = 0.5d * zoom;
            double halfHeight = halfWidth * PixelAspectRatio * ((double)Size.Height / Size.Width);

            double maxZoomHeight = _maximumZoom < double.MaxValue ? _maximumZoom : double.MaxValue;
            if (2 * halfHeight > maxZoomHeight)
            {
                halfHeight = 0.5d*maxZoomHeight;
                halfWidth = halfHeight / (_pixelAspectRatio * ((double)Size.Height / Size.Width));
                zoom = 2 * halfWidth;
            }

            var testEnvelope = new Envelope(center.X - halfWidth, center.X + halfWidth,
                                            center.Y - halfHeight, center.Y + halfHeight);

            if (maxExtents.Contains(testEnvelope))
                return zoom;

            double dx = testEnvelope.MinX < maxExtents.MinX
                            ? maxExtents.MinX - testEnvelope.MinX
                            : testEnvelope.MaxX > maxExtents.MaxX 
                                ? maxExtents.MaxX - testEnvelope.MaxX 
                                : 0;

            double dy = testEnvelope.MinY < maxExtents.MinY
                            ? maxExtents.MinY - testEnvelope.MinY
                            : testEnvelope.MaxY > maxExtents.MaxY 
                                ? maxExtents.MaxY - testEnvelope.MaxY 
                                : 0;

            center.X += dx;
            center.Y += dy;

            return zoom;
        }
    }


    /// <summary>
    /// Utility class to lock a map's viewport so it cannot be changed
    /// </summary>
    public class MapViewportLock
    {
        private readonly Map _map;
        private double _minimumZoom;
        private double _maximumZoom;
        private Envelope _maximumExtents;
        private bool _enforce;

        /// <summary>
        /// Creates an instance of this class
        /// </summary>
        /// <param name="map"></param>
        public MapViewportLock(Map map)
        {
            _map = map;
        }

        /// <summary>
        /// Lock the viewport of the map
        /// </summary>
        public void Lock()
        {
            if (IsLocked)
                return;

            // Signal the viewport as locked
            IsLocked = true;

            // store the current extent settings
            _minimumZoom = _map.MinimumZoom;
            _maximumZoom = _map.MaximumZoom;
            _maximumExtents = _map.MaximumExtents;
            _enforce = _map.EnforceMaximumExtents;

            // Lock the viewport
            _map.MinimumZoom = _map.MaximumZoom = _map.Zoom;
            _map.MaximumExtents = _map.Envelope;
            _map.EnforceMaximumExtents = true;
        }

        /// <summary>
        /// Gets a value indicating that the map's viewport is locked
        /// </summary>
        public bool IsLocked { get; private set; }

        /// <summary>
        /// Unlock the viewport of the map
        /// </summary>
        public void Unlock()
        {
            // Unlock the viewport
            _map.EnforceMaximumExtents = _enforce;
            _map.MaximumExtents = _maximumExtents;
            _map.MinimumZoom = _minimumZoom;
            _map.MaximumZoom = _maximumZoom;

            // Signal the viewport as unlocked
            IsLocked = false;
        }
    }
}