using System;
using System.Collections.Generic;

namespace Algorithms.Numeric
{
    /// <summary>
    ///     In numerical analysis, the Runge–Kutta methods are a family of implicit and explicit iterative methods,
    ///     used in temporal discretization for the approximate solutions of simultaneous nonlinear equations.
    ///     The most widely known member of the Runge–Kutta family is generally referred to as
    ///     "RK4", the "classic Runge–Kutta method" or simply as "the Runge–Kutta method".
    ///     </summary>
    public static class RungeKuttaMethod
    {
        /// <summary>
        ///     Loops through all the steps until xEnd is reached, adds a point for each step and then
        ///     returns all the points.
        /// </summary>
        /// <param name="xStart">Initial conditions x-value.</param>
        /// <param name="xEnd">Last x-value.</param>
        /// <param name="stepSize">Step-size on the x-axis.</param>
        /// <param name="yStart">Initial conditions y-value.</param>
        /// <param name="function">The right hand side of the differential equation.</param>
        /// <returns>The solution of the Cauchy problem.</returns>
        public static List<double[]> ClassicRungeKuttaMethod(
            double xStart,
            double xEnd,
            double stepSize,
            double yStart,
            Func<double, double, double> function)
        {
            if (xStart >= xEnd)
            {
                throw new ArgumentOutOfRangeException(
                    nameof(xEnd),
                    $"{nameof(xEnd)} should be greater than {nameof(xStart)}");
            }

            if (stepSize <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    nameof(stepSize),
                    $"{nameof(stepSize)} should be greater than zero");
            }

            List<double[]> points = new();
            double[] firstPoint = { xStart, yStart };
            points.Add(firstPoint);

            var yCurrent = yStart;
            var xCurrent = xStart;

            while (xCurrent < xEnd)
            {
                var k1 = function(xCurrent, yCurrent);
                var k2 = function(xCurrent + 0.5 * stepSize, yCurrent + 0.5 * stepSize * k1);
                var k3 = function(xCurrent + 0.5 * stepSize, yCurrent + 0.5 * stepSize * k2);
                var k4 = function(xCurrent + stepSize, yCurrent + stepSize * k3);

                yCurrent += (1.0 / 6.0) * stepSize * (k1 + 2 * k2 + 2 * k3 + k4);
                xCurrent += stepSize;

                double[] newPoint = { xCurrent, yCurrent };
                points.Add(newPoint);
            }

            return points;
        }
    }
}