FormattedSharedStringsReader.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way  
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;
using NanoXLSX.Colors;
using NanoXLSX.Extensions;
using NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Reader;
using NanoXLSX.Registry;
using NanoXLSX.Registry.Attributes;
using NanoXLSX.Styles;
using NanoXLSX.Utils;
using IOException = NanoXLSX.Exceptions.IOException;
 
namespace NanoXLSX.Internal.Readers
{
    [NanoXlsxPlugIn(PlugInUUID = PlugInUUID.SharedStringsReader, PlugInOrder = 1000)]
    internal class FormattedSharedStringsReader : ISharedStringReader
    {
        internal static readonly int AUXILIARY_DATA_ID = 854563987;
 
        #region privateFields
        private bool capturePhoneticCharacters;
        private readonly List<PhoneticInfo> phoneticsInfo;
        private MemoryStream stream;
        private Workbook workbook;
        #endregion
 
        #region properties

        public List<string> SharedStrings { get; private set; }

        public Dictionary<string, FormattedText> FormattedTexts { get; private set; }

        public Workbook Workbook { get => workbook; set => workbook = value; }
        public IOptions Options { get; set; }
        public Action<MemoryStream, Workbook, string, IOptions, int?> InlinePluginHandler { get; set; }
        #endregion
 
        #region constructors
        public FormattedSharedStringsReader()
        {
            phoneticsInfo = new List<PhoneticInfo>();
            SharedStrings = new List<string>();
            FormattedTexts = new Dictionary<string, FormattedText>();
        }
        #endregion
 
        #region methods
        public void Init(MemoryStream stream, Workbook workbook, IOptions readerOptions, Action<MemoryStream, Workbook, string, IOptions, int?> inlinePluginHandler)
        {
            this.stream = stream;
            this.workbook = workbook;
            if (readerOptions is ITextOptions options)
            {
                this.capturePhoneticCharacters = options.EnforcePhoneticCharacterImport;
            }
            this.InlinePluginHandler = inlinePluginHandler;
        }

        public void Execute()
        {
            try
            {
                using (stream) // Close after processing
                {
                    XmlDocument xr = new XmlDocument
                    {
                        XmlResolver = null
                    };
                    bool hasFormattedText = false;
                    using (XmlReader reader = XmlReader.Create(stream, new XmlReaderSettings() { XmlResolver = null }))
                    {
                        xr.Load(reader);
                        StringBuilder sb = new StringBuilder();
                        foreach (XmlNode node in xr.DocumentElement.ChildNodes)
                        {
                            if (node.LocalName.Equals("si", StringComparison.OrdinalIgnoreCase))
                            {
                                sb.Clear();
                                phoneticsInfo.Clear();
 
                                FormattedText formattedText = ProcessSharedStringItem(node, ref sb);
                                string textValue;
                                if (capturePhoneticCharacters)
                                {
                                    textValue = ProcessPhoneticCharacters(sb);
                                    formattedText.OverridePlainText(textValue);
                                }
                                else if (formattedText != null && string.IsNullOrEmpty(formattedText.PlainText) && sb.ToString().Length > 0)
                                {
                                    textValue = sb.ToString();
                                    formattedText.OverridePlainText(sb.ToString()); // Fallback to prevent data loss
                                }
                                else
                                {
                                    textValue = sb.ToString();
                                }
                                if (formattedText != null)
                                {
                                    string key = PlugInUUID.SharedStringsReader + textValue;
                                    SharedStrings.Add(key);
                                    FormattedTexts[key] = formattedText;
                                    hasFormattedText = true;
                                }
                                else
                                {
                                    SharedStrings.Add(textValue);
                                }
                            }
                        }
                        InlinePluginHandler?.Invoke(stream, Workbook, PlugInUUID.SharedStringsInlineReader, Options, null);
                    }
                    if (hasFormattedText)
                    {
                        Workbook.AuxiliaryData.SetData(PlugInUUID.SharedStringsReader, AUXILIARY_DATA_ID, FormattedTexts);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new IOException("The XML entry could not be read from the " + nameof(stream) + ". Please see the inner exception:", ex);
            }
        }

        private FormattedText ProcessSharedStringItem(XmlNode siNode, ref StringBuilder sb)
        {
            bool hasRuns = false;
            bool hasPhoneticRuns = false;
            XmlNode phoneticPropertiesNode = null;
 
            // Check if this is a formatted text entry
            foreach (XmlNode childNode in siNode.ChildNodes)
            {
                if (childNode.LocalName.Equals("r", StringComparison.OrdinalIgnoreCase))
                {
                    hasRuns = true;
                }
                else if (childNode.LocalName.Equals("rPh", StringComparison.OrdinalIgnoreCase))
                {
                    hasPhoneticRuns = true;
                }
                else if (childNode.LocalName.Equals("phoneticPr", StringComparison.OrdinalIgnoreCase))
                {
                    phoneticPropertiesNode = childNode;
                }
            }
 
            if (!hasRuns && !hasPhoneticRuns && phoneticPropertiesNode == null)
            {
                // Simple text node, just extract plain text
                GetTextToken(siNode, ref sb);
                return null;
            }
 
            // Create FormattedText object
            FormattedText formattedText = new FormattedText();
 
            // Process text runs
            if (hasRuns)
            {
                foreach (XmlNode childNode in siNode.ChildNodes)
                {
                    if (childNode.LocalName.Equals("r", StringComparison.OrdinalIgnoreCase))
                    {
                        ProcessTextRun(childNode, formattedText, ref sb);
                    }
                }
            }
            else
            {
                // No runs but has phonetic info - extract text as single run
                GetTextToken(siNode, ref sb);
            }
 
            // Process phonetic runs
            if (hasPhoneticRuns)
            {
                foreach (XmlNode childNode in siNode.ChildNodes)
                {
                    if (childNode.LocalName.Equals("rPh", StringComparison.OrdinalIgnoreCase))
                    {
                        ProcessPhoneticRun(childNode, formattedText);
                    }
                }
            }
 
            // Process phonetic properties
            if (phoneticPropertiesNode != null)
            {
                ProcessPhoneticProperties(phoneticPropertiesNode, formattedText);
            }
 
            return formattedText;
        }

        private void ProcessTextRun(XmlNode runNode, FormattedText formattedText, ref StringBuilder sb)
        {
            Font fontStyle = null;
            string text = null;
 
            foreach (XmlNode childNode in runNode.ChildNodes)
            {
                if (childNode.LocalName.Equals("rPr", StringComparison.OrdinalIgnoreCase))
                {
                    fontStyle = ParseRunProperties(childNode);
                }
                else if (childNode.LocalName.Equals("t", StringComparison.OrdinalIgnoreCase))
                {
                    text = childNode.InnerText;
                    sb.Append(text);
                }
            }
 
            if (!string.IsNullOrEmpty(text))
            {
                formattedText.AddRun(text, fontStyle);
            }
        }

        private Font ParseRunProperties(XmlNode rPrNode)
        {
            Font font = new Font();
 
            foreach (XmlNode childNode in rPrNode.ChildNodes)
            {
                string nodeName = childNode.LocalName;
 
                if (nodeName.Equals("rFont", StringComparison.OrdinalIgnoreCase))
                {
                    font.Name = GetAttributeValue(childNode, "val");
                }
                else if (nodeName.Equals("charset", StringComparison.OrdinalIgnoreCase))
                {
                    string charsetValue = GetAttributeValue(childNode, "val");
                    if (!string.IsNullOrEmpty(charsetValue))
                    {
                        font.Charset = (Font.CharsetValue)ParserUtils.ParseInt(charsetValue);
                    }
                }
                else if (nodeName.Equals("family", StringComparison.OrdinalIgnoreCase))
                {
                    string familyValue = GetAttributeValue(childNode, "val");
                    if (!string.IsNullOrEmpty(familyValue))
                    {
                        font.Family = (Font.FontFamilyValue)ParserUtils.ParseInt(familyValue);
                    }
                }
                else if (nodeName.Equals("b", StringComparison.OrdinalIgnoreCase))
                {
                    font.Bold = true;
                }
                else if (nodeName.Equals("i", StringComparison.OrdinalIgnoreCase))
                {
                    font.Italic = true;
                }
                else if (nodeName.Equals("strike", StringComparison.OrdinalIgnoreCase))
                {
                    font.Strike = true;
                }
                else if (nodeName.Equals("outline", StringComparison.OrdinalIgnoreCase))
                {
                    font.Outline = true;
                }
                else if (nodeName.Equals("shadow", StringComparison.OrdinalIgnoreCase))
                {
                    font.Shadow = true;
                }
                else if (nodeName.Equals("condense", StringComparison.OrdinalIgnoreCase))
                {
                    font.Condense = true;
                }
                else if (nodeName.Equals("extend", StringComparison.OrdinalIgnoreCase))
                {
                    font.Extend = true;
                }
                else if (nodeName.Equals("color", StringComparison.OrdinalIgnoreCase))
                {
                    font.ColorValue = ParseColor(childNode);
                }
                else if (nodeName.Equals("sz", StringComparison.OrdinalIgnoreCase))
                {
                    string sizeValue = GetAttributeValue(childNode, "val");
                    if (!string.IsNullOrEmpty(sizeValue))
                    {
                        font.Size = ParserUtils.ParseFloat(sizeValue);
                    }
                }
                else if (nodeName.Equals("u", StringComparison.OrdinalIgnoreCase))
                {
                    string underlineValue = GetAttributeValue(childNode, "val");
                    if (string.IsNullOrEmpty(underlineValue))
                    {
                        font.Underline = Font.UnderlineValue.Single;
                    }
                    else
                    {
                        font.Underline = ParseUnderlineValue(underlineValue);
                    }
                }
                else if (nodeName.Equals("vertAlign", StringComparison.OrdinalIgnoreCase))
                {
                    string vertAlignValue = GetAttributeValue(childNode, "val");
                    if (!string.IsNullOrEmpty(vertAlignValue))
                    {
                        font.VerticalAlign = ParseVerticalAlignValue(vertAlignValue);
                    }
                }
                else if (nodeName.Equals("scheme", StringComparison.OrdinalIgnoreCase))
                {
                    string schemeValue = GetAttributeValue(childNode, "val");
                    if (!string.IsNullOrEmpty(schemeValue))
                    {
                        font.Scheme = ParseSchemeValue(schemeValue);
                    }
                }
            }
 
            return font;
        }

        private Color ParseColor(XmlNode colorNode)
        {
            string autoValue = GetAttributeValue(colorNode, "auto");
            string indexedValue = GetAttributeValue(colorNode, "indexed");
            string rgbValue = GetAttributeValue(colorNode, "rgb");
            string themeValue = GetAttributeValue(colorNode, "theme");
            string systemValue = GetAttributeValue(colorNode, "system");
            string tintValue = GetAttributeValue(colorNode, "tint");
 
            Color color = null; //= new Color();
 
            if (!string.IsNullOrEmpty(autoValue))
            {
                color = Color.CreateAuto();
            }
            else if (!string.IsNullOrEmpty(indexedValue))
            {
                color = Color.CreateIndexed(ParserUtils.ParseInt(indexedValue));
            }
            else if (!string.IsNullOrEmpty(rgbValue))
            {
                color = Color.CreateRgb(rgbValue);
            }
            else if (!string.IsNullOrEmpty(themeValue))
            {
                color = Color.CreateTheme(ParserUtils.ParseInt(themeValue));
            }
            else if (!string.IsNullOrEmpty(systemValue))
            {
                color = Color.CreateSystem(SystemColor.MapStringToValue(systemValue));
            }
            if (color != null && !string.IsNullOrEmpty(tintValue))
            {
                color.Tint = ParserUtils.ParseFloat(tintValue);
            }
 
            return color;
        }

        private void ProcessPhoneticRun(XmlNode rPhNode, FormattedText formattedText)
        {
            string startBase = GetAttributeValue(rPhNode, "sb");
            string endBase = GetAttributeValue(rPhNode, "eb");
            string text = null;
 
            foreach (XmlNode childNode in rPhNode.ChildNodes)
            {
                if (childNode.LocalName.Equals("t", StringComparison.OrdinalIgnoreCase))
                {
                    text = childNode.InnerText;
                }
            }
 
            if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(startBase) && !string.IsNullOrEmpty(endBase))
            {
                uint sb = (uint)ParserUtils.ParseInt(startBase);
                uint eb = (uint)ParserUtils.ParseInt(endBase);
                formattedText.AddPhoneticRun(text, sb, eb);
 
                // Also capture for plain text processing
                if (capturePhoneticCharacters)
                {
                    phoneticsInfo.Add(new PhoneticInfo(text, startBase, endBase));
                }
            }
        }

        private void ProcessPhoneticProperties(XmlNode phoneticPrNode, FormattedText formattedText)
        {
            string fontIdValue = GetAttributeValue(phoneticPrNode, "fontId");
            string typeValue = GetAttributeValue(phoneticPrNode, "type");
            string alignmentValue = GetAttributeValue(phoneticPrNode, "alignment");
 
            // Create a basic font reference for phonetic properties
            Font fontReference = new Font();
            if (!string.IsNullOrEmpty(fontIdValue))
            {
                // Font ID is stored but not resolved here
                // This is just a placeholder for the reference
            }
 
            PhoneticRun.PhoneticType type = PhoneticRun.PhoneticType.FullwidthKatakana;
            if (!string.IsNullOrEmpty(typeValue))
            {
                type = ParsePhoneticType(typeValue);
            }
 
            PhoneticRun.PhoneticAlignment alignment = PhoneticRun.PhoneticAlignment.Left;
            if (!string.IsNullOrEmpty(alignmentValue))
            {
                alignment = ParsePhoneticAlignment(alignmentValue);
            }
 
            formattedText.SetPhoneticProperties(fontReference, type, alignment);
        }

        private void GetTextToken(XmlNode node, ref StringBuilder sb)
        {
            if (node.LocalName.Equals("t", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(node.InnerText))
            {
                sb.Append(node.InnerText);
            }
            if (node.HasChildNodes)
            {
                foreach (XmlNode childNode in node.ChildNodes)
                {
                    if (childNode.LocalName.Equals("rPh", StringComparison.OrdinalIgnoreCase))
                    {
                        continue;
                    }
                    GetTextToken(childNode, ref sb);
                }
            }
        }

        private string ProcessPhoneticCharacters(StringBuilder sb)
        {
            string text = sb.ToString();
            StringBuilder sb2 = new StringBuilder();
            int currentTextIndex = 0;
            foreach (PhoneticInfo info in phoneticsInfo)
            {
                sb2.Append(text.Substring(currentTextIndex, info.StartIndex + info.Length - currentTextIndex));
                sb2.Append('(').Append(info.Value).Append(')');
                currentTextIndex = info.StartIndex + info.Length;
            }
            sb2.Append(text.Substring(currentTextIndex));
 
            return sb2.ToString();
        }

        private string GetAttributeValue(XmlNode node, string attributeName)
        {
            XmlNode attribute = node.Attributes?.GetNamedItem(attributeName);
            return attribute?.InnerText;
        }

        private Font.UnderlineValue ParseUnderlineValue(string value)
        {
            switch (value.ToLowerInvariant())
            {
                case "double":
                    return Font.UnderlineValue.Double;
                case "singleaccounting":
                    return Font.UnderlineValue.SingleAccounting;
                case "doubleaccounting":
                    return Font.UnderlineValue.DoubleAccounting;
                default:
                    return Font.UnderlineValue.Single;
            }
        }

        private Font.VerticalTextAlignValue ParseVerticalAlignValue(string value)
        {
            switch (value.ToLowerInvariant())
            {
                case "superscript":
                    return Font.VerticalTextAlignValue.Superscript;
                case "subscript":
                    return Font.VerticalTextAlignValue.Subscript;
                default:
                    return Font.VerticalTextAlignValue.Baseline;
            }
        }

        private Font.SchemeValue ParseSchemeValue(string value)
        {
            switch (value.ToLowerInvariant())
            {
                case "major":
                    return Font.SchemeValue.Major;
                case "minor":
                    return Font.SchemeValue.Minor;
                default:
                    return Font.SchemeValue.None;
            }
        }

        private PhoneticRun.PhoneticType ParsePhoneticType(string value)
        {
            switch (value.ToLowerInvariant())
            {
                case "halfwidthkatakana":
                    return PhoneticRun.PhoneticType.HalfwidthKatakana;
                case "hiragana":
                    return PhoneticRun.PhoneticType.Hiragana;
                case "noconversion":
                    return PhoneticRun.PhoneticType.NoConversion;
                default:
                    return PhoneticRun.PhoneticType.FullwidthKatakana;
            }
        }

        private PhoneticRun.PhoneticAlignment ParsePhoneticAlignment(string value)
        {
            switch (value.ToLowerInvariant())
            {
                case "nocontrol":
                    return PhoneticRun.PhoneticAlignment.NoControl;
                case "center":
                    return PhoneticRun.PhoneticAlignment.Center;
                case "distributed":
                    return PhoneticRun.PhoneticAlignment.Distributed;
                default:
                    return PhoneticRun.PhoneticAlignment.Left;
            }
        }
 
        #endregion
 
        #region sub-classes
        sealed class PhoneticInfo
        {
            public string Value { get; private set; }
            public int StartIndex { get; private set; }
            public int Length { get; private set; }

            public PhoneticInfo(string value, string start, string end)
            {
                Value = value;
                StartIndex = ParserUtils.ParseInt(start);
                Length = ParserUtils.ParseInt(end) - StartIndex;
 
            }
        }
        #endregion
    }
}