// 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.Drawing;
using GeoAPI.Geometries;
using NetTopologySuite.Geometries.Utilities;

namespace SharpMap.Utilities
{
    /// <summary>
    /// Class for transforming between world and image coordinate
    /// </summary>
    public class Transform
    {
        /// <summary>
        /// Am abbreviated transform from world coordinate system (WCS) to image coordinates
        /// for use ONLY when MapTransformRotation == 0
        /// </summary>
        /// <param name="coordinates">Coordinate array in WCS</param>
        /// <param name="worldLeft">Minimum X value of non-rotated viewport in world coordinates</param>
        /// <param name="worldTop">Maximum Y value of non-rotated viewport in world coordinates</param>
        /// <param name="pixelWidth">Apparent width of pixel in world units</param>
        /// <param name="pixelHeight">Apparent height of pixel in world units</param>
        /// <returns>Point array in image coordinates</returns>
        internal static PointF[] WorldToMap(Coordinate[] coordinates, double worldLeft, double worldTop,
            double pixelWidth, double pixelHeight)
        {
            // ONLY when MapTransFormRotation == 0
            var points = new PointF[coordinates.Length];
            for (var i = 0; i < coordinates.Length; i++)
            {
                var coord = coordinates[i];
                if (coord.IsEmpty() || double.IsNaN(coord.X) || double.IsNaN(coord.Y))
                {
                    points[i] = PointF.Empty;
                }
                else
                {
                    double x = (coord.X - worldLeft) / pixelWidth;
                    double y = (worldTop - coord.Y) / pixelHeight;
                    points[i] = new PointF((float) x, (float) y);
                }
            }
            return points;
        }

        /// <summary>
        /// Full affine transformation from world coordinate system (WCS) to image coordinates taking into 
        /// account Zoom, Pixel Width/Height, and MapTransformRotation. 
        /// </summary>
        /// <param name="coordinates">Coordinate array in WCS</param>
        /// <param name="matrix">Appropriate affine transformation as defined by <see cref="WorldToMapMatrix"/></param>
        /// <returns>Point array in image coordinates</returns>
        public static PointF[] WorldToMap(Coordinate[] coordinates, AffineTransformation matrix)
        {
            var points = new PointF[coordinates.Length];
            var transformed = new Coordinate();
            for (var i = 0; i < coordinates.Length; i++)
            {
                matrix.Transform(coordinates[i], transformed);
                points[i] = new PointF((float)transformed.X, (float)transformed.Y);
            }
            return points;
        }

        /// <summary>
        /// Affine transformation defining complete transformation from world coordinate system (WCS) to image coordinates taking into 
        /// account Zoom, Pixel Width/Height, and MapTransformRotation. Additionally, if <paramref name="careAboutTransform"/> = false,
        /// the viewport rotation will be reverted at the end of the transformation, to be re-applied by Graphics object when rendering. 
        /// </summary>
        /// <param name="worldCenter">Map center in WCS</param>
        /// <param name="pixelWidth">Width of pixel in world units</param>
        /// <param name="pixelHeight">Height of pixel in world units</param>
        /// <param name="mapTransformRotation">map rotation in degrees</param>
        /// <param name="imageSize">Map Size when rendered</param>
        /// <param name="careAboutTransform">True for coordinate calculations, False if Graphics object will apply MapTransform</param>
        /// <returns>Affine Transformation</returns>
        public static AffineTransformation WorldToMapMatrix(Coordinate worldCenter, 
            double pixelWidth, double pixelHeight, float mapTransformRotation, Size imageSize,
            bool careAboutTransform)
        {
            var rad = NetTopologySuite.Utilities.Degrees.ToRadians(mapTransformRotation);
            var trans = new AffineTransformation();
            trans.Compose(AffineTransformation.TranslationInstance(-worldCenter.X, -worldCenter.Y));
            trans.Compose(AffineTransformation.RotationInstance(-rad));
            trans.Compose(AffineTransformation.ScaleInstance(1 / pixelWidth, -1 / pixelHeight));
            trans.Compose(AffineTransformation.TranslationInstance(imageSize.Width * 0.5, imageSize.Height * 0.5));

            if (!careAboutTransform)
            {
                // if we DON'T care about transform (implies that rotation in image space WILL be performed by graphics
                // object once drawing of ALL objects has been completed) then need to revert rotation (ie MapTransform).
                trans.Compose(AffineTransformation.RotationInstance(-rad, imageSize.Width * 0.5, imageSize.Height * 0.5));
            }
            return trans;
        }

        /// <summary>
        /// Am abbreviated transform from image coordinates to world coordinate system (WCS) 
        /// for use ONLY when MapTransformRotation == 0
        /// </summary>
        /// <param name="points">Point array in image coordinates</param>
        /// <param name="map">Map defining current view properties</param>
        public static Coordinate[] MapToWorld(PointF[] points, Map map)
        {
            return MapToWorld(points, map.Center, map.Zoom, map.MapHeight, map.PixelWidth, map.PixelHeight);
        }


        /// <summary>
        /// Am abbreviated transform from image coordinates to world coordinate system (WCS) 
        /// for use ONLY when MapTransformRotation == 0
        /// </summary>
        /// <param name="points">Point array in image coordinates</param>
        /// <param name="worldCenter">Map center in WCS</param>
        /// <param name="mapZoom">current map zoom (width) in world units</param>
        /// <param name="mapHeight">current map height in world units</param>
        /// <param name="pixelWidth">Apparent width of pixel in world units</param>
        /// <param name="pixelHeight">Apparent height of pixel in world units</param>
        internal static Coordinate[] MapToWorld(PointF[] points, Coordinate worldCenter, double mapZoom,
            double mapHeight, double pixelWidth, double pixelHeight)
        {
            var coords = new Coordinate[points.Length];
            if (worldCenter.IsEmpty() || double.IsNaN(mapHeight))
                for (var i = 0; i < points.Length; i++)
                    coords[i] = new Coordinate(0, 0);
            else
            {
                var ul = new Coordinate(worldCenter.X - mapZoom * .5,worldCenter.Y + mapHeight * .5);
                for (var i = 0; i < points.Length; i++)
                    coords[i] = new Coordinate(ul.X + points[i].X * pixelWidth,ul.Y - points[i].Y * pixelHeight);
            }

            return coords;
        }

        /// <summary>
        /// Transforms from world coordinate system (WCS) to image coordinates
        /// NOTE: This method is only applicable when MapTransformRotation = 0.
        /// </summary>
        /// <param name="p">Point in WCS</param>
        /// <param name="map">Map reference</param>
        /// <returns>Point in image coordinates</returns>
        [Obsolete("Use WorldToMap(Coordinate[], Map)")]
        public static PointF WorldToMap(Coordinate p, Map map)
        {
            var left = map.Center.X - map.Zoom * 0.5;
            var top = map.Center.Y + map.MapHeight * 0.5;
            var points = WorldToMap(new [] {p}, left, top, map.PixelWidth, map.PixelHeight);
            return points[0];
        }

        /// <summary>
        /// Transforms from image coordinates to world coordinate system (WCS).
        /// NOTE: This method is only applicable when MapTransformRotation = 0.
        /// </summary>
        /// <param name="p">Point in image coordinate system</param>
        /// <param name="map">Map reference</param>
        /// <returns>Point in WCS</returns>
        [Obsolete("Use MapToWorld(PointF[], Map)")]
        public static Coordinate MapToWorld(PointF p, Map map)
        {
            var coords = MapToWorld(new [] {p}, map);
            return coords[0];
        }
        
        /// <summary>
        /// Transforms from image coordinates to world coordinate system (WCS).
        /// NOTE: This method is only applicable when MapTransformRotation = 0.
        /// </summary>
        /// <param name="p">Point in image coordinate system</param>
        /// <param name="map">Map reference</param>
        /// <returns>Point in WCS</returns>
        [Obsolete("Use MapToWorld(PointF[], MapViewport)")]
        public static Coordinate MapToWorld(PointF p, MapViewport map)
        {
            var coords = MapToWorld(new [] {p}, map.Center, map.Zoom, map.MapHeight, map.PixelWidth, map.PixelHeight);
            return coords[0];
        }
    }
}