/*
* Licensed to the Apache Software Foundation (ASF) Under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for Additional information regarding copyright ownership.
* The ASF licenses this file to You Under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed Under the License is distributed on an "AS Is" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations Under the License.
*/

namespace HH.WMS.Utils.NPOI.SS.Formula.Functions
{
    using System;
    using System.Collections.Generic;
    using HH.WMS.Utils.NPOI.SS.Formula.Eval;
    using HH.WMS.Utils.NPOI.SS.Formula;

    /**
     * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
     * This Is the base class for all excel function evaluator
     * classes that take variable number of operands, and
     * where the order of operands does not matter
     */
    public abstract class MultiOperandNumericFunction : Function
    {
        static double[] EMPTY_DOUBLE_ARRAY = { };
        private bool _isReferenceBoolCounted;
        private bool _isBlankCounted;

        protected MultiOperandNumericFunction(bool isReferenceBoolCounted, bool isBlankCounted)
        {
            _isReferenceBoolCounted = isReferenceBoolCounted;
            _isBlankCounted = isBlankCounted;
        }
        protected internal abstract double Evaluate(double[] values);

        public ValueEval Evaluate(ValueEval[] args, int srcCellRow, int srcCellCol)
        {

            double d;
            try
            {
                double[] values = GetNumberArray(args);
                d = Evaluate(values);
            }
            catch (EvaluationException e)
            {
                return e.GetErrorEval();
            }

            if (Double.IsNaN(d) || Double.IsInfinity(d))
                return ErrorEval.NUM_ERROR;

            return new NumberEval(d);
        }

        private class DoubleList
        {
            private double[] _array;
            private int _Count;

            public DoubleList()
            {
                _array = new double[8];
                _Count = 0;
            }

            public double[] ToArray()
            {
                if (_Count < 1)
                {
                    return EMPTY_DOUBLE_ARRAY;
                }
                double[] result = new double[_Count];
                Array.Copy(_array, 0, result, 0, _Count);
                return result;
            }

            public void Add(double[] values)
            {
                int AddLen = values.Length;
                EnsureCapacity(_Count + AddLen);
                Array.Copy(values, 0, _array, _Count, AddLen);
                _Count += AddLen;
            }

            private void EnsureCapacity(int reqSize)
            {
                if (reqSize > _array.Length)
                {
                    int newSize = reqSize * 3 / 2; // grow with 50% extra
                    double[] newArr = new double[newSize];
                    Array.Copy(_array, 0, newArr, 0, _Count);
                    _array = newArr;
                }
            }

            public void Add(double value)
            {
                EnsureCapacity(_Count + 1);
                _array[_Count] = value;
                _Count++;
            }
        }

        private static int DEFAULT_MAX_NUM_OPERANDS = 30;

        /**
         * Maximum number of operands accepted by this function.
         * Subclasses may override to Change default value.
         */
        protected int MaxNumOperands
        {
            get
            {
                return DEFAULT_MAX_NUM_OPERANDS;
            }
        }
        /**
     *  Whether to count nested subtotals.
     */
        public virtual bool IsSubtotalCounted
        {
            get
            {
                return true;
            }
        }
        /**
 * Collects values from a single argument
 */
        private void CollectValues(ValueEval operand, DoubleList temp)
        {

            if (operand is TwoDEval)
            {
                TwoDEval ae = (TwoDEval)operand;
                int width = ae.Width;
                int height = ae.Height;
                for (int rrIx = 0; rrIx < height; rrIx++)
                {
                    for (int rcIx = 0; rcIx < width; rcIx++)
                    {
                        ValueEval ve = ae.GetValue(rrIx, rcIx);
                        if (!IsSubtotalCounted && ae.IsSubTotal(rrIx, rcIx)) continue;
                        CollectValue(ve, true, temp);
                    }
                }
                return;
            }
            if (operand is RefEval)
            {
                RefEval re = (RefEval)operand;
                CollectValue(re.InnerValueEval, true, temp);
                return;
            }
            CollectValue((ValueEval)operand, false, temp);
        }
        private void CollectValue(ValueEval ve, bool isViaReference, DoubleList temp)
        {
            if (ve == null)
            {
                throw new ArgumentException("ve must not be null");
            }
            if (ve is NumberEval)
            {
                NumberEval ne = (NumberEval)ve;
                temp.Add(ne.NumberValue);
                return;
            }
            if (ve is ErrorEval)
            {
                throw new EvaluationException((ErrorEval)ve);
            }
            if (ve is StringEval)
            {
                if (isViaReference)
                {
                    // ignore all ref strings
                    return;
                }
                String s = ((StringEval)ve).StringValue;
                Double d = OperandResolver.ParseDouble(s);
                if (double.IsNaN(d))
                {
                    throw new EvaluationException(ErrorEval.VALUE_INVALID);
                }
                temp.Add(d);
                return;
            }
            if (ve is BoolEval)
            {
                if (!isViaReference || _isReferenceBoolCounted)
                {
                    BoolEval boolEval = (BoolEval)ve;
                    temp.Add(boolEval.NumberValue);
                }
                return;
            }
            if (ve == BlankEval.instance)
            {
                if (_isBlankCounted)
                {
                    temp.Add(0.0);
                }
                return;
            }
            throw new InvalidOperationException("Invalid ValueEval type passed for conversion: ("
                    + ve.GetType() + ")");
        }
        /**
         * Returns a double array that contains values for the numeric cells
         * from among the list of operands. Blanks and Blank equivalent cells
         * are ignored. Error operands or cells containing operands of type
         * that are considered invalid and would result in #VALUE! error in
         * excel cause this function to return <c>null</c>.
         *
         * @return never <c>null</c>
         */
        protected double[] GetNumberArray(ValueEval[] operands)
        {
            if (operands.Length > MaxNumOperands)
            {
                throw EvaluationException.InvalidValue();
            }
            DoubleList retval = new DoubleList();

            for (int i = 0, iSize = operands.Length; i < iSize; i++)
            {
                CollectValues(operands[i], retval);
            }
            return retval.ToArray();
        }
        /**
         * Ensures that a two dimensional array has all sub-arrays present and the same Length
         * @return <c>false</c> if any sub-array Is missing, or Is of different Length
         */
        protected static bool AreSubArraysConsistent(double[][] values)
        {

            if (values == null || values.Length < 1)
            {
                // TODO this doesn't seem right.  Fix or Add comment.
                return true;
            }

            if (values[0] == null)
            {
                return false;
            }
            int outerMax = values.Length;
            int innerMax = values[0].Length;
            for (int i = 1; i < outerMax; i++)
            { // note - 'i=1' start at second sub-array
                double[] subArr = values[i];
                if (subArr == null)
                {
                    return false;
                }
                if (innerMax != subArr.Length)
                {
                    return false;
                }
            }
            return true;
        }

    }
}