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

    /**
     * Title: Unicode String<p/>
     * Description:  Unicode String - just standard fields that are in several records.
     *               It is considered more desirable then repeating it in all of them.<p/>
     *               This is often called a XLUnicodeRichExtendedString in MS documentation.<p/>
     * REFERENCE:  PG 264 Microsoft Excel 97 Developer's Kit (ISBN: 1-57231-498-2)<p/>
     * REFERENCE:  PG 951 Excel Binary File Format (.xls) Structure Specification v20091214 
     */
    public class UnicodeString : IComparable<UnicodeString>
    { // TODO - make this when the compatibility version is Removed
        private static POILogger _logger = POILogFactory.GetLogger(typeof(UnicodeString));

        private short field_1_charCount;
        private byte field_2_optionflags;
        private String field_3_string;
        private List<FormatRun> field_4_format_Runs;
        private ExtRst field_5_ext_rst;
        private static BitField highByte = BitFieldFactory.GetInstance(0x1);
        // 0x2 is reserved
        private static BitField extBit = BitFieldFactory.GetInstance(0x4);
        private static BitField richText = BitFieldFactory.GetInstance(0x8);

        public class FormatRun : IComparable<FormatRun>
        {
            internal short _character;
            internal short _fontIndex;

            public FormatRun(short character, short fontIndex)
            {
                this._character = character;
                this._fontIndex = fontIndex;
            }

            public FormatRun(ILittleEndianInput in1) :
                this(in1.ReadShort(), in1.ReadShort())
            {
            }

            public short CharacterPos
            {
                get
                {
                    return _character;
                }
            }

            public short FontIndex
            {
                get
                {
                    return _fontIndex;
                }
            }

            public override bool Equals(Object o)
            {
                if (!(o is FormatRun))
                {
                    return false;
                }
                FormatRun other = (FormatRun)o;

                return _character == other._character && _fontIndex == other._fontIndex;
            }
            public override int GetHashCode()
            {
                return base.GetHashCode();
            }
            public int CompareTo(FormatRun r)
            {
                if (_character == r._character && _fontIndex == r._fontIndex)
                {
                    return 0;
                }
                if (_character == r._character)
                {
                    return _fontIndex - r._fontIndex;
                }
                return _character - r._character;
            }

            public override String ToString()
            {
                return "character=" + _character + ",fontIndex=" + _fontIndex;
            }

            public void Serialize(ILittleEndianOutput out1)
            {
                out1.WriteShort(_character);
                out1.WriteShort(_fontIndex);
            }
        }

        // See page 681
        public class ExtRst : IComparable<ExtRst>
        {
            private short reserved;

            // This is a Phs (see page 881)
            private short formattingFontIndex;
            private short formattingOptions;

            // This is a RPHSSub (see page 894)
            private int numberOfRuns;
            private String phoneticText;

            // This is an array of PhRuns (see page 881)
            private PhRun[] phRuns;
            // Sometimes there's some cruft at the end
            private byte[] extraData;

            private void populateEmpty()
            {
                reserved = 1;
                phoneticText = "";
                phRuns = new PhRun[0];
                extraData = new byte[0];
            }
            public override int GetHashCode()
            {
                return base.GetHashCode();
            }
            internal ExtRst()
            {
                populateEmpty();
            }
            internal ExtRst(ILittleEndianInput in1, int expectedLength)
            {
                reserved = in1.ReadShort();

                // Old style detection (Reserved = 0xFF)
                if (reserved == -1)
                {
                    populateEmpty();
                    return;
                }

                // Spot corrupt records
                if (reserved != 1)
                {
                    _logger.Log(POILogger.WARN, "Warning - ExtRst has wrong magic marker, expecting 1 but found " + reserved + " - ignoring");
                    // Grab all the remaining data, and ignore it
                    for (int i = 0; i < expectedLength - 2; i++)
                    {
                        in1.ReadByte();
                    }
                    // And make us be empty
                    populateEmpty();
                    return;
                }

                // Carry on Reading in as normal
                short stringDataSize = in1.ReadShort();

                formattingFontIndex = in1.ReadShort();
                formattingOptions = in1.ReadShort();

                // RPHSSub
                numberOfRuns = in1.ReadUShort();
                short length1 = in1.ReadShort();
                // No really. Someone Clearly forgot to read
                //  the docs on their datastructure...
                short length2 = in1.ReadShort();
                // And sometimes they write out garbage :(
                if (length1 == 0 && length2 > 0)
                {
                    length2 = 0;
                }
                if (length1 != length2)
                {
                    throw new InvalidOperationException(
                          "The two length fields of the Phonetic Text don't agree! " +
                          length1 + " vs " + length2
                    );
                }
                phoneticText = StringUtil.ReadUnicodeLE(in1, length1);

                int RunData = stringDataSize - 4 - 6 - (2 * phoneticText.Length);
                int numRuns = (RunData / 6);
                phRuns = new PhRun[numRuns];
                for (int i = 0; i < phRuns.Length; i++)
                {
                    phRuns[i] = new PhRun(in1);
                }

                int extraDataLength = RunData - (numRuns * 6);
                if (extraDataLength < 0)
                {
                    //System.err.Println("Warning - ExtRst overran by " + (0-extraDataLength) + " bytes");
                    extraDataLength = 0;
                }
                extraData = new byte[extraDataLength];
                for (int i = 0; i < extraData.Length; i++)
                {
                    extraData[i] = (byte)in1.ReadByte();
                }
            }
            /**
             * Returns our size, excluding our 
             *  4 byte header
             */
            internal int DataSize
            {
                get
                {
                    return 4 + 6 + (2 * phoneticText.Length) +
                       (6 * phRuns.Length) + extraData.Length;
                }
            }
            internal void Serialize(ContinuableRecordOutput out1)
            {
                int dataSize = DataSize;

                out1.WriteContinueIfRequired(8);
                out1.WriteShort(reserved);
                out1.WriteShort(dataSize);
                out1.WriteShort(formattingFontIndex);
                out1.WriteShort(formattingOptions);

                out1.WriteContinueIfRequired(6);
                out1.WriteShort(numberOfRuns);
                out1.WriteShort(phoneticText.Length);
                out1.WriteShort(phoneticText.Length);

                out1.WriteContinueIfRequired(phoneticText.Length * 2);
                StringUtil.PutUnicodeLE(phoneticText, out1);

                for (int i = 0; i < phRuns.Length; i++)
                {
                    phRuns[i].Serialize(out1);
                }

                out1.Write(extraData);
            }

            public override bool Equals(Object obj)
            {
                if (!(obj is ExtRst))
                {
                    return false;
                }
                ExtRst other = (ExtRst)obj;
                return (CompareTo(other) == 0);
            }
            public int CompareTo(ExtRst o)
            {
                int result;

                result = reserved - o.reserved;
                if (result != 0) return result;
                result = formattingFontIndex - o.formattingFontIndex;
                if (result != 0) return result;
                result = formattingOptions - o.formattingOptions;
                if (result != 0) return result;
                result = numberOfRuns - o.numberOfRuns;
                if (result != 0) return result;

                //result = phoneticText.CompareTo(o.phoneticText);
                result = string.Compare(phoneticText, o.phoneticText, StringComparison.CurrentCulture);
                if (result != 0) return result;

                result = phRuns.Length - o.phRuns.Length;
                if (result != 0) return result;
                for (int i = 0; i < phRuns.Length; i++)
                {
                    result = phRuns[i].phoneticTextFirstCharacterOffset - o.phRuns[i].phoneticTextFirstCharacterOffset;
                    if (result != 0) return result;
                    result = phRuns[i].realTextFirstCharacterOffset - o.phRuns[i].realTextFirstCharacterOffset;
                    if (result != 0) return result;
                    result = phRuns[i].realTextFirstCharacterOffset - o.phRuns[i].realTextLength;
                    if (result != 0) return result;
                }

                result = extraData.Length - o.extraData.Length;
                if (result != 0) return result;

                // If we Get here, it's the same
                return 0;
            }

            internal ExtRst Clone()
            {
                ExtRst ext = new ExtRst();
                ext.reserved = reserved;
                ext.formattingFontIndex = formattingFontIndex;
                ext.formattingOptions = formattingOptions;
                ext.numberOfRuns = numberOfRuns;
                ext.phoneticText = phoneticText;
                ext.phRuns = new PhRun[phRuns.Length];
                for (int i = 0; i < ext.phRuns.Length; i++)
                {
                    ext.phRuns[i] = new PhRun(
                          phRuns[i].phoneticTextFirstCharacterOffset,
                          phRuns[i].realTextFirstCharacterOffset,
                          phRuns[i].realTextLength
                    );
                }
                return ext;
            }

            public short FormattingFontIndex
            {
                get
                {
                    return formattingFontIndex;
                }
            }
            public short FormattingOptions
            {
                get
                {
                    return formattingOptions;
                }
            }
            public int NumberOfRuns
            {
                get
                {
                    return numberOfRuns;
                }
            }
            public String PhoneticText
            {
                get
                {
                    return phoneticText;
                }
            }
            public PhRun[] PhRuns
            {
                get
                {
                    return phRuns;
                }
            }
        }
        public class PhRun
        {
            internal int phoneticTextFirstCharacterOffset;
            internal int realTextFirstCharacterOffset;
            internal int realTextLength;

            public PhRun(int phoneticTextFirstCharacterOffset,
                 int realTextFirstCharacterOffset, int realTextLength)
            {
                this.phoneticTextFirstCharacterOffset = phoneticTextFirstCharacterOffset;
                this.realTextFirstCharacterOffset = realTextFirstCharacterOffset;
                this.realTextLength = realTextLength;
            }
            internal PhRun(ILittleEndianInput in1)
            {
                phoneticTextFirstCharacterOffset = in1.ReadUShort();
                realTextFirstCharacterOffset = in1.ReadUShort();
                realTextLength = in1.ReadUShort();
            }
            internal void Serialize(ContinuableRecordOutput out1)
            {
                out1.WriteContinueIfRequired(6);
                out1.WriteShort(phoneticTextFirstCharacterOffset);
                out1.WriteShort(realTextFirstCharacterOffset);
                out1.WriteShort(realTextLength);
            }
        }

        private UnicodeString()
        {
            //Used for clone method.
        }

        public UnicodeString(String str)
        {
            String = (str);
        }



        public override int GetHashCode()
        {
            int stringHash = 0;
            if (field_3_string != null)
                stringHash = field_3_string.GetHashCode();
            return field_1_charCount + stringHash;
        }

        /**
         * Our handling of Equals is inconsistent with CompareTo.  The trouble is because we don't truely understand
         * rich text fields yet it's difficult to make a sound comparison.
         *
         * @param o     The object to Compare.
         * @return      true if the object is actually Equal.
         */
        public override bool Equals(Object o)
        {
            if (!(o is UnicodeString))
            {
                return false;
            }
            UnicodeString other = (UnicodeString)o;

            //OK lets do this in stages to return a quickly, first check the actual string
            bool eq = ((field_1_charCount == other.field_1_charCount)
                    && (field_2_optionflags == other.field_2_optionflags)
                    && field_3_string.Equals(other.field_3_string));
            if (!eq) return false;

            //OK string appears to be equal but now lets compare formatting Runs
            if ((field_4_format_Runs == null) && (other.field_4_format_Runs == null))
                //Strings are Equal, and there are not formatting Runs.
                return true;
            if (((field_4_format_Runs == null) && (other.field_4_format_Runs != null)) ||
                 (field_4_format_Runs != null) && (other.field_4_format_Runs == null))
                //Strings are Equal, but one or the other has formatting Runs
                return false;

            //Strings are Equal, so now compare formatting Runs.
            int size = field_4_format_Runs.Count;
            if (size != other.field_4_format_Runs.Count)
                return false;

            for (int i = 0; i < size; i++)
            {
                FormatRun Run1 = field_4_format_Runs[(i)];
                FormatRun run2 = other.field_4_format_Runs[(i)];

                if (!Run1.Equals(run2))
                    return false;
            }

            // Well the format Runs are equal as well!, better check the ExtRst data
            if (field_5_ext_rst == null && other.field_5_ext_rst == null)
            {
                // Good
            }
            else if (field_5_ext_rst != null && other.field_5_ext_rst != null)
            {
                int extCmp = field_5_ext_rst.CompareTo(other.field_5_ext_rst);
                if (extCmp == 0)
                {
                    // Good
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }

            //Phew!! After all of that we have finally worked out that the strings
            //are identical.
            return true;
        }

        /**
         * construct a unicode string record and fill its fields, ID is ignored
         * @param in the RecordInputstream to read the record from
         */
        public UnicodeString(RecordInputStream in1)
        {
            field_1_charCount = in1.ReadShort();
            field_2_optionflags = (byte)in1.ReadByte();

            int RunCount = 0;
            int extensionLength = 0;
            //Read the number of rich Runs if rich text.
            if (IsRichText)
            {
                RunCount = in1.ReadShort();
            }
            //Read the size of extended data if present.
            if (IsExtendedText)
            {
                extensionLength = in1.ReadInt();
            }

            bool IsCompressed = ((field_2_optionflags & 1) == 0);
            if (IsCompressed)
            {
                field_3_string = in1.ReadCompressedUnicode(CharCount);
            }
            else
            {
                field_3_string = in1.ReadUnicodeLEString(CharCount);
            }


            if (IsRichText && (RunCount > 0))
            {
                field_4_format_Runs = new List<FormatRun>(RunCount);
                for (int i = 0; i < RunCount; i++)
                {
                    field_4_format_Runs.Add(new FormatRun(in1));
                }
            }

            if (IsExtendedText && (extensionLength > 0))
            {
                field_5_ext_rst = new ExtRst(new ContinuableRecordInput(in1), extensionLength);
                if (field_5_ext_rst.DataSize + 4 != extensionLength)
                {
                    _logger.Log(POILogger.WARN, "ExtRst was supposed to be " + extensionLength + " bytes long, but seems to actually be " + (field_5_ext_rst.DataSize + 4));
                }
            }
        }



        /**
             * get the number of characters in the string,
             *  as an un-wrapped int
             *
             * @return number of characters
             */
        public int CharCount
        {
            get
            {
                if (field_1_charCount < 0)
                {
                    return field_1_charCount + 65536;
                }
                return field_1_charCount;
            }
            set
            {
                field_1_charCount = (short)value;
            }
        }
        public short CharCountShort
        {
            get { return field_1_charCount; }
        }

        /**
         * Get the option flags which among other things return if this is a 16-bit or
         * 8 bit string
         *
         * @return optionflags bitmask
         *
         */

        public byte OptionFlags
        {
            get
            {
                return field_2_optionflags;
            }
            set
            {
                field_2_optionflags = value;
            }
        }


        /**
             * @return the actual string this Contains as a java String object
             */
        public String String
        {
            get
            {
                return field_3_string;
            }
            set
            {
                field_3_string = value;
                CharCount = ((short)field_3_string.Length);
                // scan for characters greater than 255 ... if any are
                // present, we have to use 16-bit encoding. Otherwise, we
                // can use 8-bit encoding
                bool useUTF16 = false;
                int strlen = value.Length;

                for (int j = 0; j < strlen; j++)
                {
                    if (value[j] > 255)
                    {
                        useUTF16 = true;
                        break;
                    }
                }
                if (useUTF16)
                    //Set the uncompressed bit
                    field_2_optionflags = highByte.SetByte(field_2_optionflags);
                else field_2_optionflags = highByte.ClearByte(field_2_optionflags);

            }
        }

        public int FormatRunCount
        {
            get
            {
                if (field_4_format_Runs == null)
                    return 0;
                return field_4_format_Runs.Count;
            }
        }

        public FormatRun GetFormatRun(int index)
        {
            if (field_4_format_Runs == null)
            {
                return null;
            }
            if (index < 0 || index >= field_4_format_Runs.Count)
            {
                return null;
            }
            return field_4_format_Runs[(index)];
        }

        private int FindFormatRunAt(int characterPos)
        {
            int size = field_4_format_Runs.Count;
            for (int i = 0; i < size; i++)
            {
                FormatRun r = field_4_format_Runs[(i)];
                if (r._character == characterPos)
                    return i;
                else if (r._character > characterPos)
                    return -1;
            }
            return -1;
        }

        /** Adds a font run to the formatted string.
         *
         *  If a font run exists at the current charcter location, then it is
         *  Replaced with the font run to be Added.
         */
        public void AddFormatRun(FormatRun r)
        {
            if (field_4_format_Runs == null)
            {
                field_4_format_Runs = new List<FormatRun>();
            }

            int index = FindFormatRunAt(r._character);
            if (index != -1)
                field_4_format_Runs.RemoveAt(index);

            field_4_format_Runs.Add(r);
            //Need to sort the font Runs to ensure that the font Runs appear in
            //character order
            //collections.Sort(field_4_format_Runs);
            field_4_format_Runs.Sort();

            //Make sure that we now say that we are a rich string
            field_2_optionflags = richText.SetByte(field_2_optionflags);
        }

        public List<FormatRun> FormatIterator()
        {
            if (field_4_format_Runs != null)
            {
                return field_4_format_Runs;
            }
            return null;
        }

        public void RemoveFormatRun(FormatRun r)
        {
            field_4_format_Runs.Remove(r);
            if (field_4_format_Runs.Count == 0)
            {
                field_4_format_Runs = null;
                field_2_optionflags = richText.ClearByte(field_2_optionflags);
            }
        }

        public void ClearFormatting()
        {
            field_4_format_Runs = null;
            field_2_optionflags = richText.ClearByte(field_2_optionflags);
        }


        public ExtRst ExtendedRst
        {
            get
            {
                return this.field_5_ext_rst;
            }
            set
            {
                if (value != null)
                {
                    field_2_optionflags = extBit.SetByte(field_2_optionflags);
                }
                else
                {
                    field_2_optionflags = extBit.ClearByte(field_2_optionflags);
                }
                this.field_5_ext_rst = value;
            }
        }



        /**
         * Swaps all use in the string of one font index
         *  for use of a different font index.
         * Normally only called when fonts have been
         *  Removed / re-ordered
         */
        public void SwapFontUse(short oldFontIndex, short newFontIndex)
        {
            foreach (FormatRun run in field_4_format_Runs)
            {
                if (run._fontIndex == oldFontIndex)
                {
                    run._fontIndex = newFontIndex;
                }
            }
        }

        /**
         * unlike the real records we return the same as "getString()" rather than debug info
         * @see #getDebugInfo()
         * @return String value of the record
         */

        public override String ToString()
        {
            return String;
        }

        /**
         * return a character representation of the fields of this record
         *
         *
         * @return String of output for biffviewer etc.
         *
         */
        public String GetDebugInfo()
        {
            StringBuilder buffer = new StringBuilder();

            buffer.Append("[UNICODESTRING]\n");
            buffer.Append("    .charcount       = ")
                .Append(StringUtil.ToHexString(CharCount)).Append("\n");
            buffer.Append("    .optionflags     = ")
                .Append(StringUtil.ToHexString(OptionFlags)).Append("\n");
            buffer.Append("    .string          = ").Append(String).Append("\n");
            if (field_4_format_Runs != null)
            {
                for (int i = 0; i < field_4_format_Runs.Count; i++)
                {
                    FormatRun r = field_4_format_Runs[(i)];
                    buffer.Append("      .format_Run" + i + "          = ").Append(r.ToString()).Append("\n");
                }
            }
            if (field_5_ext_rst != null)
            {
                buffer.Append("    .field_5_ext_rst          = ").Append("\n");
                buffer.Append(field_5_ext_rst.ToString()).Append("\n");
            }
            buffer.Append("[/UNICODESTRING]\n");
            return buffer.ToString();
        }

        /**
         * Serialises out the String. There are special rules
         *  about where we can and can't split onto
         *  Continue records.
         */
        public void Serialize(ContinuableRecordOutput out1)
        {
            int numberOfRichTextRuns = 0;
            int extendedDataSize = 0;
            if (IsRichText && field_4_format_Runs != null)
            {
                numberOfRichTextRuns = field_4_format_Runs.Count;
            }
            if (IsExtendedText && field_5_ext_rst != null)
            {
                extendedDataSize = 4 + field_5_ext_rst.DataSize;
            }

            // Serialise the bulk of the String
            // The WriteString handles tricky continue stuff for us
            out1.WriteString(field_3_string, numberOfRichTextRuns, extendedDataSize);

            if (numberOfRichTextRuns > 0)
            {

                //This will ensure that a run does not split a continue
                for (int i = 0; i < numberOfRichTextRuns; i++)
                {
                    if (out1.AvailableSpace < 4)
                    {
                        out1.WriteContinue();
                    }
                    FormatRun r = field_4_format_Runs[(i)];
                    r.Serialize(out1);
                }
            }

            if (extendedDataSize > 0)
            {
                field_5_ext_rst.Serialize(out1);
            }
        }

        public int CompareTo(UnicodeString str)
        {

            //int result = String.CompareTo(str.String);
            int result = string.Compare(String, str.String, StringComparison.CurrentCulture);

            //As per the Equals method lets do this in stages
            if (result != 0)
                return result;

            //OK string appears to be equal but now lets compare formatting Runs
            if ((field_4_format_Runs == null) && (str.field_4_format_Runs == null))
                //Strings are Equal, and there are no formatting Runs.
                return 0;

            if ((field_4_format_Runs == null) && (str.field_4_format_Runs != null))
                //Strings are Equal, but one or the other has formatting Runs
                return 1;
            if ((field_4_format_Runs != null) && (str.field_4_format_Runs == null))
                //Strings are Equal, but one or the other has formatting Runs
                return -1;

            //Strings are Equal, so now compare formatting Runs.
            int size = field_4_format_Runs.Count;
            if (size != str.field_4_format_Runs.Count)
                return size - str.field_4_format_Runs.Count;

            for (int i = 0; i < size; i++)
            {
                FormatRun Run1 = field_4_format_Runs[(i)];
                FormatRun run2 = str.field_4_format_Runs[(i)];

                result = Run1.CompareTo(run2);
                if (result != 0)
                    return result;
            }

            //Well the format Runs are equal as well!, better check the ExtRst data
            if ((field_5_ext_rst == null) && (str.field_5_ext_rst == null))
                return 0;
            if ((field_5_ext_rst == null) && (str.field_5_ext_rst != null))
                return 1;
            if ((field_5_ext_rst != null) && (str.field_5_ext_rst == null))
                return -1;

            result = field_5_ext_rst.CompareTo(str.field_5_ext_rst);
            if (result != 0)
                return result;

            //Phew!! After all of that we have finally worked out that the strings
            //are identical.
            return 0;
        }

        private bool IsRichText
        {
            get
            {
                return richText.IsSet(OptionFlags);
            }
        }

        private bool IsExtendedText
        {
            get
            {
                return extBit.IsSet(OptionFlags);
            }
        }

        public Object Clone()
        {
            UnicodeString str = new UnicodeString();
            str.field_1_charCount = field_1_charCount;
            str.field_2_optionflags = field_2_optionflags;
            str.field_3_string = field_3_string;
            if (field_4_format_Runs != null)
            {
                str.field_4_format_Runs = new List<FormatRun>();
                foreach (FormatRun r in field_4_format_Runs)
                {
                    str.field_4_format_Runs.Add(new FormatRun(r._character, r._fontIndex));
                }
            }
            if (field_5_ext_rst != null)
            {
                str.field_5_ext_rst = field_5_ext_rst.Clone();
            }

            return str;
        }
    }

}