// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
#pragma warning disable SA1003 // Symbols must be spaced correctly
#pragma warning disable SA1008 // Opening parenthesis must be spaced correctly
#pragma warning disable SA1009 // Closing parenthesis must be spaced correctly
#pragma warning disable SA1010 // Opening square brackets must be spaced correctly
#pragma warning disable SA1025 // Code must not contain multiple whitespace in a row
#pragma warning disable SA1119 // Statement must not use unnecessary parenthesis
#pragma warning disable SA1402 // File may only contain a single class
using System;
using System.Runtime.Serialization;

namespace math
{
    /// <summary>
    /// A representation of a sphere of values via Spherical Harmonics (SH).
    /// </summary>
    /// <typeparam name="TDataType">The type of data contained by the sphere</typeparam>
    [DataContract( Name = "SphericalHarmonicsGeneric")]
    public abstract class SphericalHarmonics<TDataType>
    {
        /// <summary>
        /// The maximum order supported.
        /// </summary>
        public const int MaximumOrder = 5;
        
        private int order;

        /// <summary>
        /// The order of calculation of the spherical harmonic.
        /// </summary>
        [DataMember( Order = 0 )]
        public int Order
        {
            get { return order; }
            internal set
            {
                if (order>5)
                    throw new NotSupportedException("Only orders inferior or equal to 5 are supported");
                
                order = Math.Max(1, value);
            }
        }

        /// <summary>
        /// Get the coefficients defining the spherical harmonics (the spherical coordinates x{l,m} multiplying the spherical base Y{l,m}).
        /// </summary>
        [DataMember( Order = 1 )]
        public TDataType[] Coefficients { get; internal set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="SphericalHarmonics{TDataType}"/> class (null, for serialization).
        /// </summary>
        internal SphericalHarmonics()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SphericalHarmonics{TDataType}"/> class.
        /// </summary>
        /// <param name="order">The order of the harmonics</param>
        protected SphericalHarmonics(int order)
        {
            this.order = order;
            Coefficients = new TDataType[order * order];
        }

        /// <summary>
        /// Evaluate the value of the spherical harmonics in the provided direction.
        /// </summary>
        /// <param name="direction">The direction</param>
        /// <returns>The value of the spherical harmonics in the direction</returns>
        public abstract TDataType Evaluate(Vec3 direction);

        /// <summary>
        /// Returns the coefficient x{l,m} of the spherical harmonics (the {l,m} spherical coordinate corresponding to the spherical base Y{l,m}).
        /// </summary>
        /// <param name="l">the l index of the coefficient</param>
        /// <param name="m">the m index of the coefficient</param>
        /// <returns>the value of the coefficient</returns>
        public TDataType this[int l, int m]
        {
            get
            {
                CheckIndicesValidity(l, m, order);
                return Coefficients[LmToCoefficientIndex(l, m)];
            }
            set
            {
                CheckIndicesValidity(l, m, order); 
                Coefficients[LmToCoefficientIndex(l, m)] = value;
            }
        }

        // ReSharper disable UnusedParameter.Local
        private static void CheckIndicesValidity(int l, int m, int maxOrder)
        // ReSharper restore UnusedParameter.Local
        {
            if (l > maxOrder - 1)
                throw new IndexOutOfRangeException($"'l' parameter should be between '0' and '{maxOrder-1}' (order-1).");

            if (Math.Abs(m) > l)
                throw new IndexOutOfRangeException("'m' parameter should be between '-l' and '+l'.");
        }

        private static int LmToCoefficientIndex(int l, int m)
        {
            return l * l + l + m;
        }
    }

    /// <summary>
    /// A spherical harmonics representation of a cubemap.
    /// </summary>
    [DataContract( Name = "SphericalHarmonics")]
    public class SphericalHarmonics : SphericalHarmonics<Color3>
    {
        private readonly float[] baseValues;

        private const float Pi4 = 4 * MathUtil.Pi;
        private const float Pi16 = 16 * MathUtil.Pi;
        private const float Pi64 = 64 * MathUtil.Pi;
        private static readonly float SqrtPi = (float)Math.Sqrt(MathUtil.Pi);

        /// <summary>
        /// Base coefficients for SH.
        /// </summary>
        public static readonly float[] BaseCoefficients =
        {
            (float)(1.0/(2.0*SqrtPi)),

            (float)(-Math.Sqrt(3.0/Pi4)),
            (float)(Math.Sqrt(3.0/Pi4)),
            (float)(-Math.Sqrt(3.0/Pi4)),

            (float)(Math.Sqrt(15.0/Pi4)),
            (float)(-Math.Sqrt(15.0/Pi4)),
            (float)(Math.Sqrt(5.0/Pi16)),
            (float)(-Math.Sqrt(15.0/Pi4)),
            (float)(Math.Sqrt(15.0/Pi16)),

            -(float)Math.Sqrt(70/Pi64),
            (float)Math.Sqrt(105/Pi4),
            -(float)Math.Sqrt(42/Pi64),
            (float)Math.Sqrt(7/Pi16),
            -(float)Math.Sqrt(42/Pi64),
            (float)Math.Sqrt(105/Pi16),
            -(float)Math.Sqrt(70/Pi64),

            3*(float)Math.Sqrt(35/Pi16),
            -3*(float)Math.Sqrt(70/Pi64),
            3*(float)Math.Sqrt(5/Pi16),
            -3*(float)Math.Sqrt(10/Pi64),
            (float)(1.0/(16.0*SqrtPi)),
            -3*(float)Math.Sqrt(10/Pi64),
            3*(float)Math.Sqrt(5/Pi64),
            -3*(float)Math.Sqrt(70/Pi64),
            3*(float)Math.Sqrt(35/(4*Pi64)),
        };

        /// <summary>
        /// Initializes a new instance of the <see cref="SphericalHarmonics"/> class (null, for serialization).
        /// </summary>
        internal SphericalHarmonics()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SphericalHarmonics"/> class.
        /// </summary>
        /// <param name="order">The order of the harmonics</param>
        public SphericalHarmonics(int order)
            : base(order)
        {
            baseValues = new float[order * order];
        }

        /// <summary>
        /// Evaluates the color for the specified direction.
        /// </summary>
        /// <param name="direction">The direction to evaluate.</param>
        /// <returns>The color computed for this direction.</returns>
        public override Color3 Evaluate(Vec3 direction)
        {
            var x = direction.X;
            var y = direction.Y;
            var z = direction.Z;

            var x2 = x*x;
            var y2 = y*y;
            var z2 = z*z;

            var z3 = (float)Math.Pow(z, 3.0);

            var x4 = (float)Math.Pow(x, 4.0);
            var y4 = (float)Math.Pow(y, 4.0);
            var z4 = (float)Math.Pow(z, 4.0);

            //Equations based on data from: http://ppsloan.org/publications/StupidSH36.pdf
            baseValues[ 0] =  1/(2*SqrtPi);

            if (Order > 1)
            {
                baseValues[ 1] = -(float)Math.Sqrt(3/Pi4)*y;
                baseValues[ 2] =  (float)Math.Sqrt(3/Pi4)*z;
                baseValues[ 3] = -(float)Math.Sqrt(3/Pi4)*x;
                
                if (Order > 2)
                {
                    baseValues[ 4] =  (float)Math.Sqrt(15/Pi4)*y*x;
                    baseValues[ 5] = -(float)Math.Sqrt(15/Pi4)*y*z;
                    baseValues[ 6] =  (float)Math.Sqrt(5/Pi16)*(3*z2-1);
                    baseValues[ 7] = -(float)Math.Sqrt(15/Pi4)*x*z;
                    baseValues[ 8] =  (float)Math.Sqrt(15/Pi16)*(x2-y2);
                
                    if (Order > 3)
                    {
                        baseValues[ 9] = -(float)Math.Sqrt( 70/Pi64)*y*(3*x2-y2);
                        baseValues[10] =  (float)Math.Sqrt(105/ Pi4)*y*x*z;
                        baseValues[11] = -(float)Math.Sqrt( 42/Pi64)*y*(-1+5*z2);
                        baseValues[12] =  (float)Math.Sqrt(  7/Pi16)*(5*z3-3*z);
                        baseValues[13] = -(float)Math.Sqrt( 42/Pi64)*x*(-1+5*z2);
                        baseValues[14] =  (float)Math.Sqrt(105/Pi16)*(x2-y2)*z;
                        baseValues[15] = -(float)Math.Sqrt( 70/Pi64)*x*(x2-3*y2);
                
                        if (Order > 4)
                        {
                            baseValues[16] =  3*(float)Math.Sqrt(35/Pi16)*x*y*(x2-y2);
                            baseValues[17] = -3*(float)Math.Sqrt(70/Pi64)*y*z*(3*x2-y2);
                            baseValues[18] =  3*(float)Math.Sqrt( 5/Pi16)*y*x*(-1+7*z2);
                            baseValues[19] = -3*(float)Math.Sqrt(10/Pi64)*y*z*(-3+7*z2);
                            baseValues[20] =  (105*z4-90*z2+9)/(16*SqrtPi);
                            baseValues[21] = -3*(float)Math.Sqrt(10/Pi64)*x*z*(-3+7*z2);
                            baseValues[22] =  3*(float)Math.Sqrt( 5/Pi64)*(x2-y2)*(-1+7*z2);
                            baseValues[23] = -3*(float)Math.Sqrt(70/Pi64)*x*z*(x2-3*y2);
                            baseValues[24] =  3*(float)Math.Sqrt(35/(4*Pi64))*(x4-6*y2*x2+y4);
                        }
                    }
                }
            }

            var data = new Color3();

            for (int i = 0; i < baseValues.Length; i++)
                data += Coefficients[i] * baseValues[i];

            return data;
        }
    }
}