/*
 * NPlot - A charting library for .NET
 * 
 * Utils.cs
 * Copyright (C) 2003-2006 Matt Howlett and others.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Neither the name of NPlot nor the names of its contributors may
 *    be used to endorse or promote products derived from this software without
 *    specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

using System;
using System.Collections;
using System.Data;
using System.Drawing;

namespace NPlot
{
    /// <summary>
    /// General purpose utility functions used internally.
    /// </summary>
    internal class Utils
    {
        /// <summary>
        /// Numbers less than this are considered insignificant. This number is
        /// bigger than double.Epsilon.
        /// </summary>
        public const double Epsilon = double.Epsilon*1000.0;

        /// <summary>
        /// Returns true if the absolute difference between parameters is less than Epsilon
        /// </summary>
        /// <param name="a">first number to compare</param>
        /// <param name="b">second number to compare</param>
        /// <returns>true if equal, false otherwise</returns>
        public static bool DoubleEqual(double a, double b)
        {
            if (Math.Abs(a - b) < Epsilon)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// Swaps the value of two doubles.
        /// </summary>
        /// <param name="a">first value to swap.</param>
        /// <param name="b">second value to swap.</param>
        public static void Swap(ref double a, ref double b)
        {
            double c = a;
            a = b;
            b = c;
        }

        /// <summary>
        /// Calculate the distance between two points, a and b.
        /// </summary>
        /// <param name="a">First point</param>
        /// <param name="b">Second point</param>
        /// <returns>Distance between points a and b</returns>
        public static float Distance(PointF a, PointF b)
        {
            return (float) Math.Sqrt((a.X - b.X)*(a.X - b.X) + (a.Y - b.Y)*(a.Y - b.Y));
        }

        /// <summary>
        /// Calculate the distance between two points, a and b.
        /// </summary>
        /// <param name="a">First point</param>
        /// <param name="b">Second point</param>
        /// <returns>Distance between points a and b</returns>
        public static int Distance(Point a, Point b)
        {
            return (int) Math.Sqrt((a.X - b.X)*(a.X - b.X) + (a.Y - b.Y)*(a.Y - b.Y));
        }

        /// <summary>
        /// Converts an object of type DateTime or IConvertible to double representation.
        /// Mapping is 1:1. Note: the System.Convert.ToDouble method can not convert a boxed
        /// DateTime to double. This implementation can - but the "is" check probably makes
        /// it much slower.
        /// </summary>
        /// <remarks>Compare speed with System.Convert.ToDouble and revise code that calls this if significant speed difference.</remarks>
        /// <param name="o">The object to convert to double.</param>
        /// <returns>double value associated with the object.</returns>
        public static double ToDouble(object o)
        {
            if (o is DateTime)
            {
                return (((DateTime) o).Ticks);
            }

            else if (o is IConvertible)
            {
                return Convert.ToDouble(o);
            }

            throw new NPlotException("Invalid datatype");
        }

        /// <summary>
        /// Returns the minimum and maximum values in an IList. The members of the list
        /// can be of different types - any type for which the function Utils.ConvertToDouble
        /// knows how to convert into a double.
        /// </summary>
        /// <param name="a">The IList to search.</param>
        /// <param name="min">The minimum value.</param>
        /// <param name="max">The maximum value.</param>
        /// <returns>true if min max set, false otherwise (a == null or zero length).</returns>
        public static bool ArrayMinMax(IList a, out double min, out double max)
        {
            if (a == null || a.Count == 0)
            {
                min = 0.0;
                max = 0.0;
                return false;
            }

            min = ToDouble(a[0]);
            max = ToDouble(a[0]);

            foreach (object o in a)
            {
                double e = ToDouble(o);

                if ((min.Equals(double.NaN)) && (!e.Equals(double.NaN)))
                {
                    // if min/max are double.NaN and the current value not, then
                    // set them to the current value.
                    min = e;
                    max = e;
                }
                if (!double.IsNaN(e))
                {
                    if (e < min)
                    {
                        min = e;
                    }
                    if (e > max)
                    {
                        max = e;
                    }
                }
            }

            if (min.Equals(double.NaN))
            {
                // if min == double.NaN, then max is also double.NaN
                min = 0.0;
                max = 0.0;
                return false;
            }

            return true;
        }

        /// <summary>
        /// Returns the minimum and maximum values in a DataRowCollection.
        /// </summary>
        /// <param name="rows">The row collection to search.</param>
        /// <param name="min">The minimum value.</param>
        /// <param name="max">The maximum value.</param>
        /// <param name="columnName">The name of the column in the row collection to search over.</param>
        /// <returns>true is min max set, false otherwise (a = null or zero length).</returns>
        public static bool RowArrayMinMax(DataRowCollection rows,
                                          out double min, out double max, string columnName)
        {
            // double[] is a reference type and can be null, if it is then I reckon the best
            // values for min and max are also null. double is a value type so can't be set
            //	to null. So min an max return object, and we understand that if it is not null
            // it is a boxed double (same trick I use lots elsewhere in the lib). The 
            // wonderful comment I didn't write at the top should explain everything.
            if (rows == null || rows.Count == 0)
            {
                min = 0.0;
                max = 0.0;
                return false;
            }

            min = ToDouble((rows[0])[columnName]);
            max = ToDouble((rows[0])[columnName]);

            foreach (DataRow r in rows)
            {
                double e = ToDouble(r[columnName]);

                if ((min.Equals(double.NaN)) && (!e.Equals(double.NaN)))
                {
                    // if min/max are double.NaN and the current value not, then
                    // set them to the current value.
                    min = e;
                    max = e;
                }

                if (!double.IsNaN(e))
                {
                    if (e < min)
                    {
                        min = e;
                    }
                    if (e > max)
                    {
                        max = e;
                    }
                }
            }
            if (min.Equals(double.NaN))
            {
                // if min == double.NaN, then max is also double.NaN
                min = 0.0;
                max = 0.0;
                return false;
            }

            return true;
        }

        /// <summary>
        /// Returns the minimum and maximum values in a DataView.
        /// </summary>
        /// <param name="data">The DataView to search.</param>
        /// <param name="min">The minimum value.</param>
        /// <param name="max">The maximum value.</param>
        /// <param name="columnName">The name of the column in the row collection to search over.</param>
        /// <returns>true is min max set, false otherwise (a = null or zero length).</returns>
        public static bool DataViewArrayMinMax(DataView data,
                                               out double min, out double max, string columnName)
        {
            // double[] is a reference type and can be null, if it is then I reckon the best
            // values for min and max are also null. double is a value type so can't be set
            //	to null. So min an max return object, and we understand that if it is not null
            // it is a boxed double (same trick I use lots elsewhere in the lib). The 
            // wonderful comment I didn't write at the top should explain everything.
            if (data == null || data.Count == 0)
            {
                min = 0.0;
                max = 0.0;
                return false;
            }

            min = ToDouble((data[0])[columnName]);
            max = ToDouble((data[0])[columnName]);

            for (int i = 0; i < data.Count; ++i)
            {
                double e = ToDouble(data[i][columnName]);

                if (e < min)
                {
                    min = e;
                }

                if (e > max)
                {
                    max = e;
                }
            }

            return true;
        }

        /// <summary>
        /// Returns unit vector along the line  a->b.
        /// </summary>
        /// <param name="a">line start point.</param>
        /// <param name="b">line end point.</param>
        /// <returns>The unit vector along the specified line.</returns>
        public static PointF UnitVector(PointF a, PointF b)
        {
            PointF dir = new PointF(b.X - a.X, b.Y - a.Y);
            double dirNorm = Math.Sqrt(dir.X*dir.X + dir.Y*dir.Y);
            if (dirNorm > 0.0f)
            {
                dir = new PointF(
                    (float) ((1.0f/dirNorm)*dir.X),
                    (float) ((1.0f/dirNorm)*dir.Y)); // normalised axis direction vector
            }
            return dir;
        }

        /// <summary>
        /// Get a Font exactly the same as the passed in one, except for scale factor.
        /// </summary>
        /// <param name="initial">The font to scale.</param>
        /// <param name="scale">Scale by this factor.</param>
        /// <returns>The scaled font.</returns>
        public static Font ScaleFont(Font initial, double scale)
        {
            FontStyle fs = initial.Style;
            GraphicsUnit gu = initial.Unit;
            double sz = initial.Size;
            sz = sz*scale;
            string nm = initial.Name;
            return new Font(nm, (float) sz, fs, gu);
        }

        /// <summary>
        /// Creates a bitmap from another that is tiled size times in each direction.
        /// </summary>
        /// <param name="image">bitmap to tile</param>
        /// <param name="size">number of times to tile in each direction.</param>
        /// <returns>the tiled bitmap.</returns>
        public static System.Drawing.Bitmap TiledImage(System.Drawing.Bitmap image, Size size)
        {
            System.Drawing.Bitmap final = new System.Drawing.Bitmap(size.Width, size.Height);

            for (int i = 0; i < (size.Width/image.Width) + 1; ++i)
            {
                for (int j = 0; j < (size.Height/image.Height) + 1; ++j)
                {
                    Graphics.FromImage(final).DrawImage(image, i*image.Width, j*image.Height);
                }
            }

            return final;
        }
    }
}