/* ====================================================================
   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.PTG
{

    using System;
    using System.IO;
    using System.Runtime.Serialization.Formatters.Binary;
    using System.Collections;
    using System.Collections.Generic;

    using HH.WMS.Utils.NPOI.Util;
    using HH.WMS.Utils.NPOI.HSSF.Record;

    using HH.WMS.Utils.NPOI.SS.Util;


    /**
     * <c>Ptg</c> represents a syntactic token in a formula.  'PTG' is an acronym for 
     * '<b>p</b>arse <b>t</b>hin<b>g</b>'.  Originally, the name referred to the single 
     * byte identifier at the start of the token, but in POI, <c>Ptg</c> encapsulates
     * the whole formula token (initial byte + value data).
     * 
     * 
     * <c>Ptg</c>s are logically arranged in a tree representing the structure of the
     * Parsed formula.  However, in BIFF files <c>Ptg</c>s are written/Read in 
     * <em>Reverse-Polish Notation</em> order. The RPN ordering also simplifies formula
     * evaluation logic, so POI mostly accesses <c>Ptg</c>s in the same way.
     *
     * @author  andy
     * @author avik
     * @author Jason Height (jheight at chariot dot net dot au)
     */
    [Serializable]
    public abstract class Ptg : ICloneable
    {
        public static Ptg[] EMPTY_PTG_ARRAY = { };

        /**
         * Reads <c>size</c> bytes of the input stream, to Create an array of <c>Ptg</c>s.
         * Extra data (beyond <c>size</c>) may be Read if and <c>ArrayPtg</c>s are present.
         */
        public static Ptg[] ReadTokens(int size, ILittleEndianInput in1)
        {
            ArrayList temp = new ArrayList(4 + size / 2);
            int pos = 0;
            bool hasArrayPtgs = false;
            while (pos < size)
            {
                Ptg ptg = Ptg.CreatePtg(in1);
                if (ptg is ArrayPtg.Initial)
                {
                    hasArrayPtgs = true;
                }
                pos += ptg.Size;
                temp.Add(ptg);
            }
            if (pos != size)
            {
                throw new Exception("Ptg array size mismatch");
            }
            if (hasArrayPtgs)
            {
                Ptg[] result = ToPtgArray(temp);
                for (int i = 0; i < result.Length; i++)
                {
                    if (result[i] is ArrayPtg.Initial)
                    {
                        result[i] = ((ArrayPtg.Initial)result[i]).FinishReading(in1);
                    }
                }
                return result;
            }
            return ToPtgArray(temp);
        }

        public static Ptg CreatePtg(ILittleEndianInput in1)
        {
            byte id = (byte)in1.ReadByte();

            if (id < 0x20)
            {
                return CreateBasePtg(id, in1);
            }

            Ptg retval = CreateClassifiedPtg(id, in1);

            if (id >= 0x60)
            {
                retval.PtgClass = CLASS_ARRAY;
            }
            else if (id >= 0x40)
            {
                retval.PtgClass = CLASS_VALUE;
            }
            else
            {
                retval.PtgClass = CLASS_REF;
            }

            return retval;
        }
        private static Ptg CreateClassifiedPtg(byte id, ILittleEndianInput in1)
        {

            int baseId = id & 0x1F | 0x20;

            switch (baseId)
            {
                case ArrayPtg.sid: return new ArrayPtg.Initial(in1);    // 0x20, 0x40, 0x60
                case FuncPtg.sid: return FuncPtg.Create(in1);     // 0x21, 0x41, 0x61
                case FuncVarPtg.sid: return FuncVarPtg.Create(in1);  // 0x22, 0x42, 0x62
                case NamePtg.sid: return new NamePtg(in1);     // 0x23, 0x43, 0x63
                case RefPtg.sid: return new RefPtg(in1);      // 0x24, 0x44, 0x64
                case AreaPtg.sid: return new AreaPtg(in1);     // 0x25, 0x45, 0x65
                case MemAreaPtg.sid: return new MemAreaPtg(in1);  // 0x26, 0x46, 0x66
                case MemErrPtg.sid: return new MemErrPtg(in1);   // 0x27, 0x47, 0x67
                case MemFuncPtg.sid: return new MemFuncPtg(in1);  // 0x29, 0x49, 0x69
                case RefErrorPtg.sid: return new RefErrorPtg(in1);// 0x2a, 0x4a, 0x6a
                case AreaErrPtg.sid: return new AreaErrPtg(in1);  // 0x2b, 0x4b, 0x6b
                case RefNPtg.sid: return new RefNPtg(in1);     // 0x2c, 0x4c, 0x6c
                case AreaNPtg.sid: return new AreaNPtg(in1);    // 0x2d, 0x4d, 0x6d

                case NameXPtg.sid: return new NameXPtg(in1);    // 0x39, 0x49, 0x79
                case Ref3DPtg.sid: return new Ref3DPtg(in1);   // 0x3a, 0x5a, 0x7a
                case Area3DPtg.sid: return new Area3DPtg(in1);   // 0x3b, 0x5b, 0x7b
                case DeletedRef3DPtg.sid: return new DeletedRef3DPtg(in1);   // 0x3c, 0x5c, 0x7c
                case DeletedArea3DPtg.sid: return new DeletedArea3DPtg(in1); // 0x3d, 0x5d, 0x7d
            }
            throw new NotSupportedException(" Unknown Ptg in Formula: 0x" +
                       StringUtil.ToHexString(id) + " (" + (int)id + ")");
        }

        private static Ptg CreateBasePtg(byte id, ILittleEndianInput in1)
        {
            switch (id)
            {
                case 0x00: return new UnknownPtg(); // TODO - not a real Ptg
                case ExpPtg.sid: return new ExpPtg(in1);          // 0x01
                case TblPtg.sid: return new TblPtg(in1);          // 0x02
                case AddPtg.sid: return AddPtg.instance;         // 0x03
                case SubtractPtg.sid: return SubtractPtg.instance;    // 0x04
                case MultiplyPtg.sid: return MultiplyPtg.instance;    // 0x05
                case DividePtg.sid: return DividePtg.instance;      // 0x06
                case PowerPtg.sid: return PowerPtg.instance;       // 0x07
                case ConcatPtg.sid: return ConcatPtg.instance;      // 0x08
                case LessThanPtg.sid: return LessThanPtg.instance;    // 0x09
                case LessEqualPtg.sid: return LessEqualPtg.instance;   // 0x0a
                case EqualPtg.sid: return EqualPtg.instance;       // 0x0b
                case GreaterEqualPtg.sid: return GreaterEqualPtg.instance;// 0x0c
                case GreaterThanPtg.sid: return GreaterThanPtg.instance; // 0x0d
                case NotEqualPtg.sid: return NotEqualPtg.instance;    // 0x0e
                case IntersectionPtg.sid: return IntersectionPtg.instance;// 0x0f
                case UnionPtg.sid: return UnionPtg.instance;       // 0x10
                case RangePtg.sid: return RangePtg.instance;       // 0x11
                case UnaryPlusPtg.sid: return UnaryPlusPtg.instance;   // 0x12
                case UnaryMinusPtg.sid: return UnaryMinusPtg.instance;  // 0x13
                case PercentPtg.sid: return PercentPtg.instance;     // 0x14
                case ParenthesisPtg.sid: return ParenthesisPtg.instance; // 0x15
                case MissingArgPtg.sid: return MissingArgPtg.instance;  // 0x16

                case StringPtg.sid: return new StringPtg(in1);       // 0x17
                case AttrPtg.sid: return new AttrPtg(in1); // 0x19
                case ErrPtg.sid: return new ErrPtg(in1);          // 0x1c
                case BoolPtg.sid: return new BoolPtg(in1);         // 0x1d
                case IntPtg.sid: return new IntPtg(in1);          // 0x1e
                case NumberPtg.sid: return new NumberPtg(in1);       // 0x1f
            }
            throw new Exception("Unexpected base token id (" + id + ")");
        }
        private static Ptg[] ToPtgArray(ArrayList l)
        {
            if (l.Count == 0)
            {
                return EMPTY_PTG_ARRAY;
            }

            Ptg[] result = (Ptg[])l.ToArray(typeof(Ptg));
            return result;
        }
        /**
         * @return a distinct copy of this <c>Ptg</c> if the class is mutable, or the same instance
         * if the class is immutable.
         */
        //[Obsolete]
        //public Ptg Copy()
        //{
        //    // TODO - all base tokens are logically immutable, but AttrPtg needs some clean-up 
        //    if (this is ValueOperatorPtg)
        //    {
        //        return this;
        //    }
        //    if (this is ScalarConstantPtg)
        //    {
        //        return this;
        //    }
        //    return (Ptg)Clone();
        //}
        public virtual object Clone()
        {
            using (MemoryStream stream = new MemoryStream())
            {

                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, this);
                stream.Position = 0;
                return formatter.Deserialize(stream);
            }

        }

        /**
	 * This method will return the same result as {@link #getEncodedSizeWithoutArrayData(Ptg[])}
	 * if there are no array tokens present.
	 * @return the full size taken to encode the specified <c>Ptg</c>s
	 */
        public static int GetEncodedSize(Ptg[] ptgs)
        {
            int result = 0;
            for (int i = 0; i < ptgs.Length; i++)
            {
                result += ptgs[i].Size;
            }
            return result;
        }
        /**
 * Used to calculate value that should be encoded at the start of the encoded Ptg token array;
 * @return the size of the encoded Ptg tokens not including any trailing array data.
 */
        public static int GetEncodedSizeWithoutArrayData(Ptg[] ptgs)
        {
            int result = 0;
            for (int i = 0; i < ptgs.Length; i++)
            {
                Ptg ptg = ptgs[i];
                if (ptg is ArrayPtg)
                {
                    result += ArrayPtg.PLAIN_TOKEN_SIZE;
                }
                else
                {
                    result += ptg.Size;
                }
            }
            return result;
        }

        /**
         * Writes the ptgs to the data buffer, starting at the specified offset.  
         *
         * <br/>
         * The 2 byte encode Length field is <b>not</b> written by this method.
         * @return number of bytes written
         */
        public static int SerializePtgs(Ptg[] ptgs, byte[] array, int offset)
        {
            int size = ptgs.Length;

            LittleEndianByteArrayOutputStream out1 = new LittleEndianByteArrayOutputStream(array, offset);

            ArrayList arrayPtgs = null;

            for (int k = 0; k < size; k++)
            {
                Ptg ptg = ptgs[k];

                ptg.Write(out1);
                if (ptg is ArrayPtg)
                {
                    if (arrayPtgs == null)
                    {
                        arrayPtgs = new ArrayList(5);
                    }
                    arrayPtgs.Add(ptg);

                }
            }
            if (arrayPtgs != null)
            {
                for (int i = 0; i < arrayPtgs.Count; i++)
                {
                    ArrayPtg p = (ArrayPtg)arrayPtgs[i];
                    p.WriteTokenValueBytes(out1);
                }
            }
            return out1.WriteIndex - offset; ;
        }

        /**
         * @return the encoded Length of this Ptg, including the initial Ptg type identifier byte. 
         */
        public abstract int Size { get; }
        /**
 * @return <c>false</c> if this token is classified as 'reference', 'value', or 'array'
 */
        public abstract bool IsBaseToken { get; }


        /** Write this Ptg to a byte array*/
        public abstract void Write(ILittleEndianOutput out1);

        /**
         * return a string representation of this token alone
         */
        public abstract String ToFormulaString();

        /** Overridden toString method to Ensure object hash is not printed.
         * This helps Get rid of gratuitous diffs when comparing two dumps
         * Subclasses may output more relevant information by overriding this method
         **/
        public override String ToString()
        {
            return this.GetType().ToString();
        }

        public const byte CLASS_REF = 0x00;
        public const byte CLASS_VALUE = 0x20;
        public const byte CLASS_ARRAY = 0x40;

        private byte ptgClass = CLASS_REF; //base ptg

        /**
         *  @return the 'operand class' (REF/VALUE/ARRAY) for this Ptg
         */
        public byte PtgClass
        {
            get { return ptgClass; }
            set
            {
                if (IsBaseToken)
                {
                    throw new Exception("SetClass should not be called on a base token");
                }
                ptgClass = value;
            }
        }

        public abstract byte DefaultOperandClass { get; }

        /**
 * Debug / diagnostic method to get this token's 'operand class' type.
 * @return 'R' for 'reference', 'V' for 'value', 'A' for 'array' and '.' for base tokens
 */
        public char RVAType
        {
            get
            {
                if (IsBaseToken)
                {
                    return '.';
                }
                switch (ptgClass)
                {
                    case Ptg.CLASS_REF: return 'R';
                    case Ptg.CLASS_VALUE: return 'V';
                    case Ptg.CLASS_ARRAY: return 'A';
                }
                throw new InvalidOperationException("Unknown operand class (" + ptgClass + ")");
            }
        }

        #region ICloneable Members

        object ICloneable.Clone()
        {
            throw new NotImplementedException();
        }

        #endregion

        public static bool DoesFormulaReferToDeletedCell(Ptg[] ptgs)
        {
            for (int i = 0; i < ptgs.Length; i++)
            {
                if (IsDeletedCellRef(ptgs[i]))
                {
                    return true;
                }
            }
            return false;
        }

        private static bool IsDeletedCellRef(Ptg ptg)
        {
            if (ptg == ErrPtg.REF_INVALID)
            {
                return true;
            }
            if (ptg is DeletedArea3DPtg)
            {
                return true;
            }
            if (ptg is DeletedRef3DPtg)
            {
                return true;
            }
            if (ptg is AreaErrPtg)
            {
                return true;
            }
            if (ptg is RefErrorPtg)
            {
                return true;
            }
            return false;
        }
    }
}