/* ====================================================================
   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.Constant
{
    using System;
    using System.Text;
    using HH.WMS.Utils.NPOI.Util;
    using HH.WMS.Utils.NPOI.HSSF.Record;



    /**
     * To support Constant Values (2.5.7) as required by the CRN record.
     * This class is also used for two dimensional arrays which are encoded by 
     * EXTERNALNAME (5.39) records and Array tokens.<p/>
     * 
     * @author Josh Micich
     */
    public class ConstantValueParser
    {
        // note - these (non-combinable) enum values are sParse.
        private const int TYPE_EMPTY = 0;
        private const int TYPE_NUMBER = 1;
        private const int TYPE_STRING = 2;
        private const int TYPE_BOOLEAN = 4;
        private const int TYPE_ERROR_CODE = 16; // TODO - update OOO document to include this value

        private const int TRUE_ENCODING = 1;
        private const int FALSE_ENCODING = 0;

        // TODO - is this the best way to represent 'EMPTY'?
        private const object EMPTY_REPRESENTATION = null;

        private ConstantValueParser()
        {
            // no instances of this class
        }

        public static object[] Parse(ILittleEndianInput in1, int nValues)
        {
            object[] result = new Object[nValues];
            for (int i = 0; i < result.Length; i++)
            {
                result[i]=ReadAConstantValue(in1);
            }
            return result;
        }

        private static object ReadAConstantValue(ILittleEndianInput in1)
        {
            byte grbit = (byte)in1.ReadByte();
            switch (grbit)
            {
                case TYPE_EMPTY:
                    in1.ReadLong(); // 8 byte 'not used' field
                    return EMPTY_REPRESENTATION;
                case TYPE_NUMBER:
                    return in1.ReadDouble();
                case TYPE_STRING:
                    return StringUtil.ReadUnicodeString(in1);
                case TYPE_BOOLEAN:
                    return ReadBoolean(in1);
                case TYPE_ERROR_CODE:
                    int errCode = in1.ReadUShort();
                    // next 6 bytes are Unused
                    in1.ReadUShort();
                    in1.ReadInt();
                    return ErrorConstant.ValueOf(errCode);
            }
            throw new Exception("Unknown grbit value (" + grbit + ")");
        }

        private static Object ReadBoolean(ILittleEndianInput in1)
        {
            byte val = (byte)in1.ReadLong(); // 7 bytes 'not used'
            switch (val)
            {
                case FALSE_ENCODING:
                    return false;
                case TRUE_ENCODING:
                    return true;
            }
            // Don't tolerate Unusual bool encoded values (unless it becomes evident that they occur)
            throw new Exception("unexpected bool encoding (" + val + ")");
        }

        public static int GetEncodedSize(Array values)
        {
            // start with one byte 'type' code for each value
            int result = values.Length * 1;
            for (int i = 0; i < values.Length; i++)
            {
                result += GetEncodedSize(values.GetValue(i));
            }
            return result;
        }

        /**
         * @return encoded size without the 'type' code byte
         */
        private static int GetEncodedSize(Object obj)
        {
            if (obj == EMPTY_REPRESENTATION)
            {
                return 8;
            }
            Type cls = obj.GetType();

            if (cls == typeof(bool) || cls == typeof(double) || cls == typeof(ErrorConstant))
            {
                return 8;
            }
            String strVal = (String)obj;
            return StringUtil.GetEncodedSize(strVal);
        }

        public static void Encode(ILittleEndianOutput out1, Array values)
        {
            for (int i = 0; i < values.Length; i++)
            {
                EncodeSingleValue(out1, values.GetValue(i));
            }
        }

        private static void EncodeSingleValue(ILittleEndianOutput out1, Object value)
        {
            if (value == EMPTY_REPRESENTATION)
            {
                out1.WriteByte(TYPE_EMPTY);
                out1.WriteLong(0L);
                return;
            }
            if (value is bool)
            {
                bool bVal = ((bool)value);
                out1.WriteByte(TYPE_BOOLEAN);
                long longVal = bVal ? 1L : 0L;
                out1.WriteLong(longVal);
                return;
            }
            if (value is double)
            {
                double dVal = (double)value;
                out1.WriteByte(TYPE_NUMBER);
                out1.WriteDouble(dVal);
                return;
            }
            if (value is String)
            {
                String val = (String)value;
                out1.WriteByte(TYPE_STRING);
                StringUtil.WriteUnicodeString(out1, val);
                return;
            }
            if (value is ErrorConstant)
            {
                ErrorConstant ecVal = (ErrorConstant)value;
                out1.WriteByte(TYPE_ERROR_CODE);
                long longVal = ecVal.ErrorCode;
                out1.WriteLong(longVal);
                return;
            }

            throw new Exception("Unexpected value type (" + value.GetType().Name + "'");
        }
    }
}