//******************************************************************************************************
//  PiecewiseLinearFunction.cs - Gbtc
//
//  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  08/20/2016 - Stephen C. Wills
//       Generated original version of source code.
//
//******************************************************************************************************

using System;

namespace GSF.NumericalAnalysis.Interpolation
{
    /// <summary>
    /// Represents a piecewise linear function for
    /// calculating values between pivot points.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The conversion function returned by this class uses a
    /// binary search algorithm to find the appropriate line segment
    /// to use for the calculation. Therefore, the domain must
    /// be specified either in increasing or decreasing order.
    /// </para>
    /// 
    /// <para>
    /// Here is an example of how to use this class.
    /// </para>
    /// 
    /// <code>
    /// Func&lt;double, double&gt; piecewiseLinearFunc = new PiecewiseLinearFunction()
    ///     .SetDomain(-1, 0, 1)
    ///     .SetRange(0, 1, 0);
    ///     
    /// Console.WriteLine(piecewiseLinearFunc(-10));   // -9
    /// Console.WriteLine(piecewiseLinearFunc(-1));    // 0 
    /// Console.WriteLine(piecewiseLinearFunc(-0.5));  // 0.5
    /// Console.WriteLine(piecewiseLinearFunc(0));     // 1
    /// Console.WriteLine(piecewiseLinearFunc(0.5));   // 0.5
    /// Console.WriteLine(piecewiseLinearFunc(1));     // 0
    /// Console.WriteLine(piecewiseLinearFunc(10));    // -9
    /// </code>
    /// </remarks>
    public class PiecewiseLinearFunction
    {
        #region [ Members ]

        // Fields
        private Func<double, double> m_converter;
        private double[] m_domain;
        private double[] m_range;

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets the x-values of the pivot points in the piecewise linear function.
        /// </summary>
        public double[] Domain
        {
            get
            {
                return m_domain;
            }
        }

        /// <summary>
        /// Gets the y-values of the pivot points in the piecewise linear function.
        /// </summary>
        public double[] Range
        {
            get
            {
                return m_range;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Sets the x-values of the pivot points in the piecewise linear function.
        /// </summary>
        /// <param name="domain">The x-values of the pivot points.</param>
        /// <returns>A reference to the piecewise linear function.</returns>
        public PiecewiseLinearFunction SetDomain(params double[] domain)
        {
            m_converter = null;
            m_domain = domain;
            return this;
        }

        /// <summary>
        /// Sets the y-values of the pivot points in the piecewise linear function.
        /// </summary>
        /// <param name="range">The y-values of the pivot points.</param>
        /// <returns>A refernce to the picewise linear function.</returns>
        public PiecewiseLinearFunction SetRange(params double[] range)
        {
            m_converter = null;
            m_range = range;
            return this;
        }

        private Func<double, double> GetConverter()
        {
            double[] domain = m_domain ?? new double[0];
            double[] range = m_range ?? new double[0];

            if (domain.Length != range.Length)
                throw new InvalidOperationException($"Domain of size {domain.Length} does not match range of size {range.Length}.");

            if (domain.Length < 2)
                throw new InvalidOperationException($"At least two pivot points must be defined. Defined: {domain.Length}");

            return m_converter ?? (m_converter = x =>
            {
                int i = 0;
                int j = domain.Length - 1;
                double di = domain[i];
                double dj = domain[j];

                while (j - i > 1)
                {
                    int mid = (i + j) / 2;
                    double dmid = domain[mid];

                    if ((di < dmid && x <= dmid) || (di > dmid && x >= dmid))
                    {
                        j = mid;
                        dj = dmid;
                    }
                    else
                    {
                        i = mid;
                        di = dmid;
                    }
                }

                if (di == dj)
                    return range[i];

                double ri = range[i];
                double rj = range[j];
                return (((x - di) / (dj - di)) * (rj - ri)) + ri;
            });
        }

        #endregion

        #region [ Operators ]

        /// <summary>
        /// Converts the <see cref="PiecewiseLinearFunction"/> object to a
        /// <see cref="Func{Double, Double}"/> to start converting values.
        /// </summary>
        /// <param name="func">The piecewise linear function to be converted.</param>
        /// <exception cref="InvalidOperationException">
        /// <para>the size of the domain does not equal the size of the range</para>
        /// <para>- or -</para>
        /// <para>less than two pivot points are defined</para>
        /// </exception>
        public static implicit operator Func<double, double>(PiecewiseLinearFunction func)
        {
            return func.GetConverter();
        }

        #endregion
    }
}