/*
 * NumSharp
 * Copyright (C) 2018 Haiping Chen
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the Apache License 2.0 as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Apache License 2.0
 * along with this program.  If not, see <http://www.apache.org/licenses/LICENSE-2.0/>.
 */

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Globalization;

namespace NumSharp
{
    /// <summary>
    /// A powerful N-dimensional array object
    /// Inspired from https://www.numpy.org/devdocs/user/quickstart.html
    /// </summary>
    public partial class NDArray<T>
    {
        /// <summary>
        /// 1 dim array data storage
        /// </summary>
        public T[] Data { get; set; }

        /// <summary>
        /// Data length of every dimension
        /// </summary>
        public Shape Shape { get; set; }

        /// <summary>
        /// Dimension count
        /// </summary>
        public int NDim => Shape.Length;

        /// <summary>
        /// Total of elements
        /// </summary>
        public int Size => Data.Length;

        public NDArray()
        {
            // set default shape as 1 dim and 0 elements.
            Shape = new Shape(new int[] { 0 });
            Data = new T[] { };
        }

        /// <summary>
        /// Index accessor
        /// </summary>
        /// <param name="select"></param>
        /// <returns></returns>
        public T this[params int[] select]
        {
            get
            {
                return Data[GetIndexInShape(select)];
            }

            set
            {
                Data[GetIndexInShape(select)] = value;
            }
        }

        public NDArray<T> Vector(params int[] select)
        {
            if (select.Length == NDim)
            {
                throw new Exception("Please use NDArray[m, n] to access element.");
            }
            else
            {
                int start = GetIndexInShape(select);
                int length = Shape.DimOffset[select.Length - 1];

                var n = new NDArray<T>();
                //n.Shape = shape.Skip(select.Length).ToList();
                Span<T> data = Data;
                n.Data = data.Slice(start, length).ToArray();
                // Since n.Shape is a IList it cannot be converted to Span<T>
                // This is a lot of hoops to jump throught to get it into a span
                // shape.Skip(select.Length).ToList() may be more efficient - not sure
                n.Shape = new Shape(Shape.Shapes.ToArray().AsSpan().Slice(select.Length).ToArray());
                return n;
            }
        }

        public void Vector(Shape shape, T value)
        {
            if (shape.Length == NDim)
            {
                throw new Exception("Please use NDArray[m, n] to access element.");
            }
            else
            {
                int start = GetIndexInShape(shape.Shapes.ToArray());
                int length = Shape.DimOffset[shape.Length - 1];

                Span<T> data = Data;
                var elements = data.Slice(start, length);

                for (int i = 0; i < elements.Length; i++)
                {
                    elements[i] = value;
                }
            }
        }

        /// <summary>
        /// Filter specific elements through select.
        /// </summary>
        /// <param name="select"></param>
        /// <returns>Return a new NDArray with filterd elements.</returns>
        public NDArray<T> this[IList<int> select]
        {
            get
            {
                var n = new NDArray<T>();
                if (NDim == 1)
                {
                    n.Data = new T[select.Count()];
                    n.Shape = new Shape(select.Count());
                    for (int i = 0; i < select.Count(); i++)
                    {
                        n[i] = this[select[i]];
                    }
                }
                else if (NDim == 2)
                {
                    n.Data = new T[select.Count() * Shape[1]];
                    n.Shape = new Shape(select.Count(), Shape[1]);
                    for (int i = 0; i < select.Count(); i++)
                    {
                        for (int j = 0; j < Shape[1]; j++)
                        {
                            n[i, j] = this[select[i], j];
                        }
                    }
                }
                else
                {
                    throw new NotImplementedException();
                }

                return n;
            }
        }

        /// <summary>
        /// Overload
        /// </summary>
        /// <param name="select"></param>
        /// <returns></returns>
        public NDArray<T> this[NDArray<int> select] => this[select.Data.ToList()];

        private int GetIndexInShape(params int[] select)
        {
            int idx = 0;
            for (int i = 0; i < select.Length; i++)
            {
                idx += Shape.DimOffset[i] * select[i];
            }

            return idx;
        }

        public override string ToString()
        {
            string output = "";

            if (this.NDim == 2)
            {
                output = this._ToMatrixString();
            }
            else
            {
                output = "array([";

                // loop
                for (int r = 0; r < Data.Length; r++)
                {
                    output += (r == 0) ? Data[r] + "" : ", " + Data[r];
                }

                output += "])";
            }

            return output;
        }

        public override bool Equals(object obj)
        {
            return Data[0].Equals(obj);
        }

        public static bool operator ==(NDArray<T> np, object obj)
        {
            return np.Data[0].Equals(obj);
        }

        public static bool operator !=(NDArray<T> np, object obj)
        {
            return np.Data[0].Equals(obj);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                var result = 1337;
                result = (result * 397) ^ this.NDim;
                result = (result * 397) ^ this.Size;
                return result;
            }
        }

        public TCast ToDotNetArray<TCast>()
        {
            dynamic dotNetArray = null;
            switch (this.NDim)
            {
                case 1 : dotNetArray = new T[this.Shape.Shapes[0]].ToArray();break;
                case 2 : dotNetArray = new T[this.Shape.Shapes[0]][].Select(x => new T[this.Shape.Shapes[1]].ToArray()).ToArray();break;
                case 3 : dotNetArray = new T[this.Shape.Shapes[0]][][].Select(x => new T[this.Shape.Shapes[1]][].Select(y => new T[this.Shape.Shapes[2]].ToArray().ToArray()).ToArray()).ToArray();break;
            }

            switch (this.NDim)
            {
                case 1 : 
                {
                    dotNetArray = this.Data.ToArray();
                    break;
                }
                case 2 : 
                {
                    for(int idx = 0; idx < this.Shape.Shapes[0];idx++)
                    {
                        for(int jdx = 0; jdx < this.Shape.Shapes[1];jdx++)
                        {
                            dotNetArray[idx][jdx] = this[idx,jdx];
                        }
                    }
                    break;
                }
                case 3 : 
                {
                    for(int idx = 0; idx < this.Shape.Shapes[0];idx++)
                    {
                        for(int jdx = 0; jdx < this.Shape.Shapes[1];jdx++)
                        {
                            for(int kdx = 0; kdx < this.Shape.Shapes[2];kdx++)
                            {
                                dotNetArray[idx][jdx][kdx] = this[idx,jdx,kdx];
                            }
                        }
                    }
                    break;
                }
            }
            TCast castedDotNetArray = (TCast)dotNetArray;
            return castedDotNetArray;
        }
        protected string _ToMatrixString()
        {
            string returnValue = "array([[";

            int digitBefore = 0;
            int digitAfter = 0;

           var dataParsed =  Data.Select(x => _ParseNumber(x,ref digitBefore,ref digitAfter)).ToArray();

            string elementFormatStart = "{0:";
            
            string elementFormatEnd = "";
            for(int idx = 0; idx < digitAfter;idx++)
                elementFormatEnd += "0";

            elementFormatEnd += "}";
            
            int missingDigits;
            string elementFormat;

            for (int idx = 0; idx < (Data.Length-1);idx++)
            {   
                missingDigits =  digitBefore - dataParsed[idx].Replace(" ","").Split('.')[0].Length;
                
                elementFormat = elementFormatStart + new string(Enumerable.Repeat<char>(' ',missingDigits).ToArray()) + "0." + elementFormatEnd; 

                if( ((idx+1) % Shape.Shapes[1] ) == 0 )
                {
                    returnValue += (String.Format(new CultureInfo("en-us"),elementFormat, Data[idx]) + "],   \n       [");    
                }
                else 
                {
                    returnValue += (String.Format(new CultureInfo("en-us"),elementFormat, Data[idx]) + ", ");
                }
                
            }
            missingDigits =  digitBefore - dataParsed.Last().Replace(" ","").Split('.')[0].Length;
                
            elementFormat = elementFormatStart + new string(Enumerable.Repeat<char>(' ',missingDigits).ToArray()) + "." + elementFormatEnd; 

            returnValue += (String.Format(new CultureInfo("en-us"),elementFormat, Data.Last()) + "]])");

            return returnValue;    
        }
        protected string _ParseNumber(T number, ref int  noBefore,ref int noAfter)
        {
            string parsed = string.Format(new CultureInfo("en-us"),"{0:0.00000000}",number);
            
            parsed = (parsed.StartsWith("-")) ? parsed : (" " + parsed); 

            int noBefore_local = parsed.Split('.')[0].Length;
            int noAfter_local = parsed.Split('.')[1].ToCharArray().Reverse().SkipWhile(x => x == '0').ToArray().Length;

            noBefore = (noBefore_local > noBefore) ? noBefore_local : noBefore;
            noAfter  = (noAfter_local  > noAfter ) ? noAfter_local  : noAfter;

            return parsed;
        }
    }
}