using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Collections.Generic;
using Chernobyl.Extensions;
using MoreLinq;

namespace Chernobyl.Mathematics.Space
{
    /// <summary>
    /// Utilities for working with waves.
    /// </summary>
    public static class Wave
    {
        /// <summary>
        /// Returns <see cref="Math.Sin"/> as a <see cref="Func{T, TResult}"/>.
        /// </summary>
        public static Func<double, double> Sin => Math.Sin;

        /// <summary>
        /// Returns <see cref="Math.Cos"/> as a <see cref="Func{T, TResult}"/>.
        /// </summary>
        public static Func<double, double> Cos => Math.Cos;

        /// <summary>
        /// Creates a method that generates a square wave whose waves are defined by the points
        /// specified.
        /// </summary>
        /// <param name="source">Defines the structure of the wave. The first value of the tuple
        /// is the the value of the wave. The second value is the number of times the returned method
        /// must be invoked before the wave changes.</param>
        /// <returns>The method that generates the wave.</returns>
        public static Func<double> Square(this Func<Tuple<double, int>> source)
        {
            var current = source();
            var invokeCount = 0;

            return Func.StaticFactory(0).Select(_ =>
            {
                invokeCount++;

                while (current.Item2 < invokeCount)
                {
                    current = source();
                    invokeCount = 1;
                }

                return current.Item1;
            });
        }

        /// <summary>
        /// Returns a method whose return value increases by the result of <paramref name="step"/>
        /// each time the returned method is invoked.
        /// </summary>
        /// <param name="step">The method that determines the difference between each invocation of
        /// the returned method.</param>
        /// <param name="start">The starting value for the returned method.</param>
        /// <param name="reset">Returns true if the current value should be returned to the start.
        /// Set to null if </param>
        public static Func<double> Step(double step, double start = 0, Func<double, bool> reset = null)
        {
            return Step(() => step, () => start, reset);
        }

        /// <summary>
        /// Returns a method whose return value increases by the result of <paramref name="step"/>
        /// each time the returned method is invoked.
        /// </summary>
        /// <param name="step">The method that determines the difference between each invocation of
        /// the returned method.</param>
        /// <param name="start">The starting value for the returned method.</param>
        /// <param name="reset">Returns true if the current value should be returned to the start.
        /// Set to null if </param>
        public static Func<double> Step(Func<double> step, Func<double> start = null, Func<double, bool> reset = null)
        {
            reset = reset ?? (curr => false);
            start = start ?? (() => 0);
            double current = start();

            return () =>
            {
                var input = current;
                current += step();
                if (reset(current)) current = start();
                return input;
            };
        }

        /// <summary>
        /// Applies a multiplicative factor onto the wave produced by <paramref name="waveFunction"/>.
        /// This will increase (if <paramref name="operand"/> is greater than one), decrease (if
        /// <paramref name="operand"/> is greater than zero or less than one), or 'silence' (if
        /// <paramref name="operand"/> is zero) the verticality of the wave (operand). If
        /// <paramref name="operand"/> is negative, it will flip the wave vertically.
        /// </summary>
        /// <param name="waveFunction">The function whose result is to be multiplied against
        /// <paramref name="operand"/>.</param>
        /// <param name="operand">The value to multiply the <paramref name="waveFunction"/> result by.</param>
        /// <returns>The method that returns the multiplied result.</returns>
        public static Func<double> Multiply(this Func<double> waveFunction, double operand) =>
            waveFunction.Multiply(() => operand);

        /// <summary>
        /// Applies a multiplicative factor onto the wave produced by <paramref name="waveFunction"/>.
        /// This will increase (if <paramref name="operand"/> is greater than one), decrease (if
        /// <paramref name="operand"/> is greater than zero or less than one), or 'silence' (if
        /// <paramref name="operand"/> is zero) the verticality of the wave (operand). If
        /// <paramref name="operand"/> is negative, it will flip the wave vertically.
        /// </summary>
        /// <param name="waveFunction">The function whose result is to be multiplied against
        /// <paramref name="operand"/>.</param>
        /// <param name="operand">The value to multiply the <paramref name="waveFunction"/> result by.</param>
        /// <returns>The method that returns the multiplied result.</returns>
        public static Func<double> Multiply(this Func<double> waveFunction, Func<double> operand) =>
            waveFunction.Select(value => value * operand());
    }
}