ROTATES 2

QWERTYkez.WordProcessor/MultiReplace.cs

@@ -2,10 +2,7 @@
 
 /// <summary>
 /// Выполняет замену всех вхождений ключей из словаря на соответствующие массивы значений.
-/// Каждое значение из массива помещается в отдельный параграф, причём первое значение
+/// Поддерживает разрывы страниц и смену ориентации (альбомная/книжная) через <see cref="ReplaceItem"/>.
-/// остаётся в текущем параграфе, а последующие создают новые.
-/// Текст между вхождениями и после последнего сохраняется в соответствующих параграфах.
-/// Поддерживает разрывы страниц и смену ориентации (альбомная/книжная) через <see cref="ReplaceItem.SplitValue"/>.
 /// </summary>
 internal static class MultiReplaceExt
 {
@@ -16,13 +13,15 @@ internal static class MultiReplaceExt
     internal static void Replace(this Body body, string oldValue, IEnumerable<string> newValues, StringComparison comparisonType)
     {
         if (body is null || string.IsNullOrEmpty(oldValue) || newValues is null) return;
-        body.Replace(new Dictionary<string, IEnumerable<string>> { { oldValue, newValues } }, comparisonType);
+        var dict = new Dictionary<string, IEnumerable<string>> { { oldValue, newValues } };
+        body.Replace(dict, comparisonType);
     }
 
     internal static void Replace(this Body body, string oldValue, IEnumerable<ReplaceItem> newValues, StringComparison comparisonType)
     {
         if (body is null || string.IsNullOrEmpty(oldValue) || newValues is null) return;
-        body.Replace(new Dictionary<string, IEnumerable<ReplaceItem>> { { oldValue, newValues } }, comparisonType);
+        var dict = new Dictionary<string, IEnumerable<ReplaceItem>> { { oldValue, newValues } };
+        body.Replace(dict, comparisonType);
     }
 
     #endregion
@@ -32,29 +31,27 @@ internal static class MultiReplaceExt
     internal static void Replace(this Body body, IEnumerable<KeyValuePair<string, IEnumerable<string>>> replacements, StringComparison comparisonType)
     {
         if (body is null || replacements is null) return;
-        ReplaceInBody(body, replacements, null, comparisonType);
-    }
-
-    internal static void Replace(this Body body, IEnumerable<KeyValuePair<string, IEnumerable<ReplaceItem>>> replacements, StringComparison comparisonType)
-    {
-        if (body is null || replacements is null) return;
-        ReplaceInBody(body, null, replacements, comparisonType);
-    }
-
-    private static void ReplaceInBody(
-        Body body,
-        IEnumerable<KeyValuePair<string, IEnumerable<string>>>? stringReplacements,
-        IEnumerable<KeyValuePair<string, IEnumerable<ReplaceItem>>>? itemReplacements,
-        StringComparison comparisonType)
-    {
         var paragraphs = body.Elements<Paragraph>().ToList();
         for (int i = paragraphs.Count - 1; i >= 0; i--)
         {
             var p = paragraphs[i];
             if (p?.Parent is null) continue;
+            var newParas = ProcessMultiReplacements(p, replacements, null, comparisonType);
+            if (newParas is not null && newParas.Count > 0)
+                ParagraphReplacer.ReplaceParagraph(p, newParas);
+        }
+    }
 
-            var newParas = ProcessMultiReplacements(p, stringReplacements, itemReplacements, comparisonType);
+    internal static void Replace(this Body body, IEnumerable<KeyValuePair<string, IEnumerable<ReplaceItem>>> replacements, StringComparison comparisonType)
-            if (newParas is { Count: > 0 })
+    {
+        if (body is null || replacements is null) return;
+        var paragraphs = body.Elements<Paragraph>().ToList();
+        for (int i = paragraphs.Count - 1; i >= 0; i--)
+        {
+            var p = paragraphs[i];
+            if (p?.Parent is null) continue;
+            var newParas = ProcessMultiReplacements(p, null, replacements, comparisonType);
+            if (newParas is not null && newParas.Count > 0)
                 ParagraphReplacer.ReplaceParagraph(p, newParas);
         }
     }
@@ -65,13 +62,14 @@ internal static class MultiReplaceExt
 
     internal static bool ReplaceWithMultiple(this Paragraph? paragraph, string oldValue, IEnumerable<string> newValues, StringComparison comparisonType)
     {
-        if (paragraph?.Parent is null || string.IsNullOrEmpty(oldValue) || newValues is null || !newValues.Any())
+        if (paragraph is null || string.IsNullOrEmpty(oldValue) || newValues is null || newValues.Count() == 0)
             return false;
 
         var dict = new Dictionary<string, IEnumerable<string>> { { oldValue, newValues } };
         var newParas = ProcessMultiReplacements(paragraph, dict, null, comparisonType);
+        if (newParas is null || newParas.Count == 0) return false;
 
-        if (newParas is { Count: > 0 })
+        if (paragraph.Parent is not null)
         {
             ParagraphReplacer.ReplaceParagraph(paragraph, newParas);
             return true;
@@ -81,13 +79,14 @@ internal static class MultiReplaceExt
 
     internal static bool ReplaceWithMultiple(this Paragraph? paragraph, string oldValue, IEnumerable<ReplaceItem> newValues, StringComparison comparisonType)
     {
-        if (paragraph?.Parent is null || string.IsNullOrEmpty(oldValue) || newValues is null || !newValues.Any())
+        if (paragraph is null || string.IsNullOrEmpty(oldValue) || newValues is null || newValues.Count() == 0)
             return false;
 
         var dict = new Dictionary<string, IEnumerable<ReplaceItem>> { { oldValue, newValues } };
         var newParas = ProcessMultiReplacements(paragraph, null, dict, comparisonType);
+        if (newParas is null || newParas.Count == 0) return false;
 
-        if (newParas is { Count: > 0 })
+        if (paragraph.Parent is not null)
         {
             ParagraphReplacer.ReplaceParagraph(paragraph, newParas);
             return true;
@@ -103,23 +102,26 @@ internal static class MultiReplaceExt
         Paragraph paragraph,
         IEnumerable<KeyValuePair<string, IEnumerable<string>>> replacements,
         StringComparison comparisonType)
-        => ProcessMultiReplacements(paragraph, replacements, null, comparisonType);
+    {
+        return ProcessMultiReplacements(paragraph, replacements, null, comparisonType);
+    }
 
     internal static List<Paragraph>? ProcessParagraphWithAllReplacements(
         Paragraph paragraph,
         IEnumerable<KeyValuePair<string, IEnumerable<ReplaceItem>>> replacements,
         StringComparison comparisonType)
-        => ProcessMultiReplacements(paragraph, null, replacements, comparisonType);
+    {
+        return ProcessMultiReplacements(paragraph, null, replacements, comparisonType);
+    }
 
     internal static List<Paragraph>? ProcessParagraphWithAllReplacements(
         Paragraph paragraph,
         IEnumerable<KeyValuePair<string, string>> replacements,
         StringComparison comparisonType)
     {
-        var dict = replacements
+        Dictionary<string, IEnumerable<string>> dict = replacements
             .Where(kvp => !string.IsNullOrEmpty(kvp.Key))
             .ToDictionary(kvp => kvp.Key, kvp => (IEnumerable<string>)[kvp.Value]);
-
         return ProcessMultiReplacements(paragraph, dict, null, comparisonType);
     }
 
@@ -135,9 +137,9 @@ internal static class MultiReplaceExt
 
     private class Match
     {
-        public MatchDefinition Definition { get; init; } = null!;
+        public MatchDefinition Definition { get; set; } = null!;
-        public int Start { get; init; }
+        public int Start { get; set; }
-        public int End { get; init; }
+        public int End { get; set; }
     }
 
     private class RunSegment(Run run, string text, int start, int end)
@@ -156,15 +158,13 @@ internal static class MultiReplaceExt
 
     private static ParagraphStructure AnalyzeParagraphStructure(List<Run> runs)
     {
-        var segments = new List<RunSegment>(runs.Count);
+        var segments = new List<RunSegment>();
         var sb = new StringBuilder();
         int pos = 0;
-
         foreach (var run in runs)
         {
             string text = GetRunText(run);
             if (string.IsNullOrEmpty(text)) continue;
-
             segments.Add(new RunSegment(run, text, pos, pos + text.Length));
             sb.Append(text);
             pos += text.Length;
@@ -184,18 +184,16 @@ internal static class MultiReplaceExt
     private static Paragraph CloneParagraphWithoutSection(Paragraph original)
     {
         var newPara = new Paragraph();
-        if (original.ParagraphProperties is null) return newPara;
+        if (original.ParagraphProperties is not null)
-
-        var newProps = new ParagraphProperties();
-        foreach (var child in original.ParagraphProperties.ChildElements)
         {
-            if (child is not SectionProperties and not PageBreakBefore)
+            var newProps = new ParagraphProperties();
-                newProps.AppendChild(child.CloneNode(true));
+            foreach (var child in original.ParagraphProperties.ChildElements)
-        }
+            {
-
+                if (child is not SectionProperties && child is not PageBreakBefore)
-        if (newProps.HasChildren)
+                    newProps.AppendChild(child.CloneNode(true));
+            }
             newPara.ParagraphProperties = newProps;
-
+        }
         return newPara;
     }
 
@@ -207,29 +205,28 @@ internal static class MultiReplaceExt
         foreach (var seg in structure.Segments)
         {
             if (seg.End <= position) continue;
-
             if (seg.Start >= position)
             {
                 newPara.AppendChild(seg.Run.CloneNode(true));
             }
-            else
+            else if (seg.End > position)
             {
                 var runClone = (Run)seg.Run.CloneNode(true);
-                runClone.RemoveAllChildren<Text>(); // Упрощенная очистка
+                foreach (var t in runClone.Elements<Text>().ToList()) t.Remove();
-
                 int offset = position - seg.Start;
-                runClone.AppendChild(new Text(seg.Text.Substring(offset)));
+                string newText = seg.Text.Substring(offset);
+                runClone.AppendChild(new Text(newText));
                 newPara.AppendChild(runClone);
             }
         }
-
+        foreach (var run in newPara.Descendants<Run>().Where(r => !r.HasChildren).ToList())
-        // Удаляем пустые Run-ы без вложений
+            run.Remove();
-        newPara.Elements<Run>().Where(r => !r.HasChildren).ToList().ForEach(r => r.Remove());
+        if (!newPara.ChildElements.OfType<Run>().Any() && newPara.ParagraphProperties is null)
-
+            return null;
-        return !newPara.Elements<Run>().Any() && newPara.ParagraphProperties is null ? null : newPara;
+        return newPara;
     }
 
-    private static void InsertFormattedRun(Paragraph para, ReplaceItem item, ParagraphStructure structure, int position)
+    private static void InsertFormattedRun(Paragraph para, string text, ParagraphStructure structure, int position)
     {
         var seg = structure.Segments.FirstOrDefault(s => position >= s.Start && position < s.End);
         if (seg is null) return;
@@ -237,89 +234,178 @@ internal static class MultiReplaceExt
         var textRun = new Run();
         if (seg.Run.RunProperties is not null)
             textRun.RunProperties = (RunProperties)seg.Run.RunProperties.CloneNode(true);
-
+        textRun.AppendChild(new Text(text));
-        textRun.AppendChild(new Text(item.Text ?? string.Empty));
         para.AppendChild(textRun);
     }
 
     /// <summary>
     /// Добавляет SectionProperties к параграфу. Все значения (PageSize, PageMargin) берутся из документа.
+    /// Для книжных секций (addPageSize=false) Orient не устанавливается (not set).
     /// </summary>
-    private static void AddSectionProperties(Paragraph para, PageBreakType splitValue, bool addPageSize, SectionProperties? sourceSection, SectionProperties? portraitSection)
+    private static void AddSectionProperties(
+        Paragraph para,
+        BreakType splitValue,
+        bool addPageSize,
+        SectionProperties sourceSection,
+        SectionProperties portraitSection)
     {
         if (para is null) return;
 
-        // Удаляем существующие секции и разрывы
         if (para.ParagraphProperties is not null)
         {
-            para.ParagraphProperties.RemoveAllChildren<SectionProperties>();
+            var sections = para.ParagraphProperties.Elements<SectionProperties>().ToList();
-            para.ParagraphProperties.RemoveAllChildren<PageBreakBefore>();
+            foreach (var sec in sections) sec.Remove();
+            var pageBreaks = para.ParagraphProperties.Elements<PageBreakBefore>().ToList();
+            foreach (var pb in pageBreaks) pb.Remove();
         }
 
         para.ParagraphProperties ??= new ParagraphProperties();
         var sectionProps = new SectionProperties();
 
-        // Добавляем PageSize
+        var pageSizeClone = CreatePageSizeClone(addPageSize, splitValue, sourceSection, portraitSection);
-        var sizeSource = addPageSize ? sourceSection : portraitSection;
+        if (pageSizeClone is not null)
-        var sourcePageSize = sizeSource?.GetFirstChild<PageSize>()
-                          ?? portraitSection?.GetFirstChild<PageSize>()
-                          ?? sourceSection?.GetFirstChild<PageSize>();
-
-        if (sourcePageSize is not null)
-        {
-            var pageSizeClone = (PageSize)sourcePageSize.CloneNode(true);
-            bool sourceIsLandscape = pageSizeClone.Orient?.Value == PageOrientationValues.Landscape ||
-                                     pageSizeClone.Width?.Value > pageSizeClone.Height?.Value;
-            bool targetIsLandscape = addPageSize && splitValue == PageBreakType.NewLandscapeSection;
-
-            if (targetIsLandscape && !sourceIsLandscape)
-            {
-                pageSizeClone.SwapValues();
-                pageSizeClone.Orient = PageOrientationValues.Landscape;
-            }
-            else if (!targetIsLandscape && sourceIsLandscape)
-            {
-                pageSizeClone.SwapValues();
-                pageSizeClone.Orient = addPageSize ? PageOrientationValues.Portrait : null;
-            }
-            else
-            {
-                pageSizeClone.Orient = targetIsLandscape ? PageOrientationValues.Landscape : (addPageSize ? PageOrientationValues.Portrait : null);
-            }
             sectionProps.AppendChild(pageSizeClone);
-        }
 
-        // Копируем PageMargin
+        var marginClone = CreateMarginClone(addPageSize, splitValue, sourceSection, portraitSection);
-        PageMargin? marginToUse = null;
+        if (marginClone is not null)
-        if (addPageSize)
+            sectionProps.AppendChild(marginClone);
-        {
-            var sourceMargin = sourceSection?.GetFirstChild<PageMargin>() ?? portraitSection?.GetFirstChild<PageMargin>();
-            if (sourceMargin is not null)
-            {
-                var marginClone = (PageMargin)sourceMargin.CloneNode(true);
-                var sourceIsLndscape = sourceSection?.GetFirstChild<PageSize>()?.Orient?.Value == PageOrientationValues.Landscape ||
-                                       sourceSection?.GetFirstChild<PageSize>()?.Width?.Value > sourceSection?.GetFirstChild<PageSize>()?.Height?.Value;
-
-                if ((splitValue == PageBreakType.NewLandscapeSection && !sourceIsLndscape) ||
-                    (splitValue == PageBreakType.NewPortraitSection && sourceIsLndscape))
-                {
-                    marginClone.SwapBottomRight();
-                }
-                marginToUse = marginClone;
-            }
-        }
-        else if (portraitSection?.GetFirstChild<PageMargin>() is { } portraitMargin)
-        {
-            marginToUse = (PageMargin)portraitMargin.CloneNode(true);
-        }
-
-        if (marginToUse is not null)
-            sectionProps.AppendChild(marginToUse);
 
         sectionProps.AppendChild(new SectionType { Val = SectionMarkValues.NextPage });
         para.ParagraphProperties.AppendChild(sectionProps);
     }
 
+    private static PageSize? CreatePageSizeClone(
+        bool addPageSize,
+        BreakType splitValue,
+        SectionProperties sourceSection,
+        SectionProperties portraitSection)
+    {
+        if (!addPageSize && splitValue != BreakType.NewLandscapeSection)
+            return null;
+
+        SectionProperties? sizeSource = addPageSize ? sourceSection : portraitSection;
+        var sourcePageSize = sizeSource?.GetFirstChild<PageSize>()
+                              ?? portraitSection.GetFirstChild<PageSize>()
+                              ?? sourceSection.GetFirstChild<PageSize>();
+
+        if (sourcePageSize is null)
+            return null;
+
+        var clone = (PageSize)sourcePageSize.CloneNode(true);
+        bool sourceIsLandscape = clone.Orient?.Value == PageOrientationValues.Landscape ||
+                                 (clone.Width?.Value > clone.Height?.Value);
+
+        bool targetIsLandscape = addPageSize && splitValue == BreakType.NewLandscapeSection;
+
+        if (targetIsLandscape && !sourceIsLandscape)
+        {
+            clone.SwapValues();
+            clone.Orient = PageOrientationValues.Landscape;
+        }
+        else if (!targetIsLandscape && sourceIsLandscape)
+        {
+            clone.SwapValues();
+            clone.Orient = addPageSize ? PageOrientationValues.Portrait : null;
+        }
+        else
+        {
+            clone.Orient = targetIsLandscape ? PageOrientationValues.Landscape :
+                           addPageSize ? PageOrientationValues.Portrait : null;
+        }
+
+        return clone;
+    }
+
+    private static PageMargin? CreateMarginClone(
+        bool addPageSize,
+        BreakType splitValue,
+        SectionProperties sourceSection,
+        SectionProperties portraitSection)
+    {
+        PageMargin? marginToUse = null;
+
+        if (addPageSize)
+        {
+            var sourceMargin = sourceSection?.GetFirstChild<PageMargin>()
+                               ?? portraitSection?.GetFirstChild<PageMargin>();
+            if (sourceMargin is not null)
+            {
+                var clone = (PageMargin)sourceMargin.CloneNode(true);
+                var sourceOrient = sourceSection?.GetFirstChild<PageSize>()?.Orient;
+                bool sourceIsLandscape = sourceOrient?.Value == PageOrientationValues.Landscape ||
+                                         (sourceSection?.GetFirstChild<PageSize>()?.Width?.Value > sourceSection?.GetFirstChild<PageSize>()?.Height?.Value);
+
+                if ((splitValue == BreakType.NewLandscapeSection && !sourceIsLandscape) ||
+                    (splitValue == BreakType.NewPortraitSection && sourceIsLandscape))
+                {
+                    clone.SwapBottomRight();
+                }
+                marginToUse = clone;
+            }
+        }
+        else
+        {
+            var portraitMargin = portraitSection?.GetFirstChild<PageMargin>();
+            if (portraitMargin is not null)
+                marginToUse = (PageMargin)portraitMargin.CloneNode(true);
+        }
+
+        return marginToUse;
+    }
+
+    private static void EnsureBodyLandscapeSection(
+        Body body,
+        SectionProperties sourceSection,
+        bool sectionChangeInsideGroup,
+        BreakType? lastOrientation)
+    {
+        if (body is null || sourceSection is null) return;
+
+        var sourcePageSize = sourceSection.GetFirstChild<PageSize>();
+        if (sourcePageSize is null) return;
+
+        bool sourceIsLandscape = sourcePageSize.Orient?.Value == PageOrientationValues.Landscape ||
+                                 (sourcePageSize.Width?.Value > sourcePageSize.Height?.Value);
+        bool lastIsPortrait = lastOrientation.HasValue && lastOrientation.Value == BreakType.NewPortraitSection;
+
+        if (!(sourceIsLandscape && sectionChangeInsideGroup && lastIsPortrait))
+            return;
+
+        foreach (var bodySec in body.Elements<SectionProperties>())
+        {
+            var ps = bodySec.GetFirstChild<PageSize>();
+            if (ps is not null && ps.Orient?.Value == PageOrientationValues.Landscape)
+                return;
+        }
+
+        var bodySection = new SectionProperties();
+        var pageSizeClone = (PageSize)sourcePageSize.CloneNode(true);
+        if (pageSizeClone.Orient?.Value != PageOrientationValues.Landscape)
+        {
+            pageSizeClone.SwapValues();
+            pageSizeClone.Orient = PageOrientationValues.Landscape;
+        }
+        bodySection.AppendChild(pageSizeClone);
+
+        var sourceMargin = sourceSection.GetFirstChild<PageMargin>();
+        if (sourceMargin is not null)
+        {
+            var marginClone = (PageMargin)sourceMargin.CloneNode(true);
+            if (sourceSection.GetFirstChild<PageSize>()?.Orient?.Value != PageOrientationValues.Landscape)
+                marginClone.SwapBottomRight();
+            bodySection.AppendChild(marginClone);
+        }
+
+        bodySection.AppendChild(new SectionType { Val = SectionMarkValues.NextPage });
+        body.AppendChild(bodySection);
+    }
+
+    private static void MergeParagraph(Paragraph target, Paragraph source)
+    {
+        foreach (var child in source.ChildElements)
+            target.AppendChild(child.CloneNode(true));
+    }
+
     /// <summary>Основной алгоритм множественной замены с поддержкой разрывов и смены ориентации.</summary>
     private static List<Paragraph>? ProcessMultiReplacements(
         Paragraph original,
@@ -327,61 +413,89 @@ internal static class MultiReplaceExt
         IEnumerable<KeyValuePair<string, IEnumerable<ReplaceItem>>>? itemReplacements,
         StringComparison comparisonType)
     {
-        var definitions = new List<MatchDefinition>();
+        var body = original.Ancestors<Body>().FirstOrDefault();
 
+        // 1. Сбор определений
+        var definitions = new List<MatchDefinition>();
         if (stringReplacements is not null)
         {
-            definitions.AddRange(stringReplacements
+            foreach (var kvp in stringReplacements)
-                .Where(kvp => !string.IsNullOrEmpty(kvp.Key) && kvp.Value != null && kvp.Value.Any())
+            {
-                .Select(kvp => new MatchDefinition(kvp.Key, kvp.Value.Select(v => new ReplaceItem(v, PageBreakType.None)))));
+                if (string.IsNullOrEmpty(kvp.Key) || kvp.Value is null || kvp.Value.Count() == 0) continue;
+                var items = kvp.Value.Select(v => new ReplaceItem(v));
+                definitions.Add(new MatchDefinition(kvp.Key, items));
+            }
         }
-
         if (itemReplacements is not null)
         {
-            definitions.AddRange(itemReplacements
+            foreach (var kvp in itemReplacements)
-                .Where(kvp => !string.IsNullOrEmpty(kvp.Key) && kvp.Value != null && kvp.Value.Any())
+            {
-                .Select(kvp => new MatchDefinition(kvp.Key, kvp.Value)));
+                if (string.IsNullOrEmpty(kvp.Key) || kvp.Value is null || kvp.Value.Count() == 0) continue;
+                definitions.Add(new MatchDefinition(kvp.Key, kvp.Value));
+            }
         }
-
         if (definitions.Count == 0) return null;
 
-        var runs = original.Elements<Run>().ToList();
+        // 2. Анализ структуры параграфа
+        var runs = original.Descendants<Run>().ToList();
         if (runs.Count == 0) return null;
-
         var structure = AnalyzeParagraphStructure(runs);
         string fullText = structure.FullText;
         if (fullText.Length == 0) return null;
 
+        // 3. Поиск всех вхождений
         var matches = new List<Match>();
         foreach (var def in definitions)
         {
             int pos = 0;
             while ((pos = fullText.IndexOf(def.Key, pos, comparisonType)) != -1)
             {
-                matches.Add(new Match { Definition = def, Start = pos, End = pos + def.Key.Length });
+                matches.Add(new Match
+                {
+                    Definition = def,
+                    Start = pos,
+                    End = pos + def.Key.Length
+                });
                 pos += def.Key.Length;
             }
         }
-
         if (matches.Count == 0) return null;
         matches.Sort((a, b) => a.Start.CompareTo(b.Start));
 
-        var body = original.Ancestors<Body>().FirstOrDefault();
+        // 4. Получаем исходную секцию для копирования (из original или из документа)
-        var sourceSection = original.ParagraphProperties?.GetFirstChild<SectionProperties>()?.CloneNode(true) as SectionProperties
+        SectionProperties? sourceSection = original.ParagraphProperties?.GetFirstChild<SectionProperties>()?.CloneNode(true) as SectionProperties;
-                            ?? body?.Elements<SectionProperties>().LastOrDefault()?.CloneNode(true) as SectionProperties
+        if (sourceSection is null && body is not null)
-                            ?? new SectionProperties();
+        {
+            sourceSection = body.Elements<SectionProperties>().LastOrDefault()?.CloneNode(true) as SectionProperties;
+        }
+        sourceSection ??= new SectionProperties();
 
-        var portraitSection = body?.Elements<SectionProperties>().FirstOrDefault()?.CloneNode(true) as SectionProperties
+        SectionProperties? portraitSection = null;
-                              ?? new SectionProperties();
+        if (body is not null)
+        {
+            portraitSection = body.Elements<SectionProperties>().FirstOrDefault()?.CloneNode(true) as SectionProperties;
+        }
+        portraitSection ??= new SectionProperties();
 
+        // 5. Построение результата
         var resultParas = new List<Paragraph>();
         Paragraph? currentPara = null;
         int currentPos = 0;
         bool sectionChangeInsideGroup = false;
-        PageBreakType? lastOrientation = null;
+        BreakType? lastOrientation = null;
 
-        foreach (var match in matches)
+        // Состояние обработки группы
+        bool pageBreakBeforeNext = false;
+        BreakType? pendingOrientation = null;
+        bool firstSplitMarkerHandled = false;
+        int textCount = 0;
+        Paragraph? lastTextPara = null;
+
+        for (int i = 0; i < matches.Count; i++)
         {
+            var match = matches[i];
+
+            // Текст перед совпадением
             if (currentPos < match.Start)
             {
                 var beforePara = CloneParagraphWithoutSection(original);
@@ -389,7 +503,6 @@ internal static class MultiReplaceExt
                 {
                     if (seg.End <= currentPos) continue;
                     if (seg.Start >= match.Start) break;
-
                     if (seg.Start >= currentPos && seg.End <= match.Start)
                     {
                         beforePara.AppendChild(seg.Run.CloneNode(true));
@@ -398,99 +511,201 @@ internal static class MultiReplaceExt
                     {
                         int startOffset = Math.Max(0, currentPos - seg.Start);
                         int endOffset = Math.Min(seg.Text.Length, match.Start - seg.Start);
-
                         var runClone = (Run)seg.Run.CloneNode(true);
-                        runClone.RemoveAllChildren<Text>();
+                        foreach (var t in runClone.Elements<Text>().ToList()) t.Remove();
-                        runClone.AppendChild(new Text(seg.Text.Substring(startOffset, endOffset - startOffset)));
+                        string textPart = seg.Text.Substring(startOffset, endOffset - startOffset);
+                        runClone.AppendChild(new Text(textPart));
                         beforePara.AppendChild(runClone);
                     }
                 }
-                if (beforePara.Elements<Run>().Any())
+                if (beforePara.ChildElements.OfType<Run>().Any())
                 {
                     resultParas.Add(beforePara);
                     currentPara = beforePara;
+                    lastTextPara = beforePara;
                 }
             }
 
             var values = match.Definition.Values.ToList();
             if (values.Count == 0) continue;
 
-            for (int vIdx = 0; vIdx < values.Count; vIdx++)
+            // Сбрасываем флаги для новой группы
+            pageBreakBeforeNext = false;
+            pendingOrientation = null;
+            firstSplitMarkerHandled = false;
+            textCount = 0;
+            lastTextPara = null;
+
+            foreach (var item in values)
             {
-                var item = values[vIdx];
+                if (!string.IsNullOrEmpty(item.Text))
-                currentPara = CloneParagraphWithoutSection(original);
-                resultParas.Add(currentPara);
-
-                InsertFormattedRun(currentPara, item, structure, match.Start);
-
-                if (item.SplitValue is PageBreakType.NewLandscapeSection or PageBreakType.NewPortraitSection)
                 {
-                    bool addPageSize = vIdx != 0;
+                    // Если есть отложенная ориентация — применяем её
-                    var orientation = vIdx != 0 ? PageBreakType.NewLandscapeSection : item.SplitValue;
+                    if (pendingOrientation.HasValue)
-
-                    AddSectionProperties(currentPara, orientation, addPageSize, sourceSection, portraitSection);
-                    lastOrientation = item.SplitValue;
-                    sectionChangeInsideGroup = true;
-                }
-                else if (item.SplitValue == PageBreakType.PageBreak)
-                {
-                    var seg = structure.Segments.FirstOrDefault(s => match.Start >= s.Start && match.Start < s.End);
-                    var breakRun = new Run(new Break { Type = BreakValues.Page });
-                    if (seg?.Run.RunProperties is not null)
-                        breakRun.RunProperties = (RunProperties)seg.Run.RunProperties.CloneNode(true);
-                    currentPara.AppendChild(breakRun);
-                }
-            }
-
-            if (sectionChangeInsideGroup && lastOrientation.HasValue && currentPara?.ParagraphProperties?.GetFirstChild<SectionProperties>() is null)
-            {
-                AddSectionProperties(currentPara!, lastOrientation.Value, lastOrientation.Value == PageBreakType.NewLandscapeSection, sourceSection, portraitSection);
-            }
-
-            if (body is not null && sourceSection.GetFirstChild<PageSize>() is { } sourcePageSize)
-            {
-                bool sourceIsLandscape = sourcePageSize.Orient?.Value == PageOrientationValues.Landscape || sourcePageSize.Width?.Value > sourcePageSize.Height?.Value;
-                bool lastIsPortrait = lastOrientation == PageBreakType.NewPortraitSection;
-
-                if (sourceIsLandscape && sectionChangeInsideGroup && lastIsPortrait && !body.Elements<SectionProperties>().Any(s => s.GetFirstChild<PageSize>()?.Orient?.Value == PageOrientationValues.Landscape))
-                {
-                    var bodySection = new SectionProperties();
-                    var pageSizeClone = (PageSize)sourcePageSize.CloneNode(true);
-
-                    if (pageSizeClone.Orient?.Value != PageOrientationValues.Landscape)
                     {
-                        pageSizeClone.SwapValues();
+                        var newPara = CloneParagraphWithoutSection(original);
-                        pageSizeClone.Orient = PageOrientationValues.Landscape;
+                        resultParas.Add(newPara);
-                    }
+                        currentPara = newPara;
-                    bodySection.AppendChild(pageSizeClone);
 
-                    if (sourceSection.GetFirstChild<PageMargin>() is { } sourceMargin)
+                        bool addPageSize = (pendingOrientation.Value == BreakType.NewLandscapeSection);
-                    {
+                        AddSectionProperties(currentPara, pendingOrientation.Value, addPageSize, sourceSection, portraitSection);
-                        var marginClone = (PageMargin)sourceMargin.CloneNode(true);
+                        lastOrientation = pendingOrientation;
-                        if (sourceSection.GetFirstChild<PageSize>()?.Orient?.Value != PageOrientationValues.Landscape)
+                        sectionChangeInsideGroup = true;
+                        pendingOrientation = null;
+                        textCount++;
+                        lastTextPara = currentPara;
+
+                        if (pageBreakBeforeNext)
                         {
-                            marginClone.SwapBottomRight();
+                            var breakRun = new Run(new Break { Type = BreakValues.Page });
+                            currentPara.InsertAt(breakRun, 0);
+                            pageBreakBeforeNext = false;
+                        }
+
+                        InsertFormattedRun(currentPara, item.Text, structure, match.Start);
+                    }
+                    else
+                    {
+                        var newPara = CloneParagraphWithoutSection(original);
+                        resultParas.Add(newPara);
+                        currentPara = newPara;
+                        textCount++;
+                        lastTextPara = currentPara;
+
+                        if (pageBreakBeforeNext)
+                        {
+                            var breakRun = new Run(new Break { Type = BreakValues.Page });
+                            currentPara.InsertAt(breakRun, 0);
+                            pageBreakBeforeNext = false;
+                        }
+
+                        InsertFormattedRun(currentPara, item.Text, structure, match.Start);
+                    }
+                }
+                else if (item.BreakValue.HasValue)
+                {
+                    var breakType = item.BreakValue.Value;
+                    if (breakType == BreakType.PageBreak)
+                    {
+                        if (currentPara is not null)
+                        {
+                            var breakRun = new Run(new Break { Type = BreakValues.Page });
+                            var lastRun = currentPara.Descendants<Run>().LastOrDefault();
+                            if (lastRun?.RunProperties is not null)
+                                breakRun.RunProperties = (RunProperties)lastRun.RunProperties.CloneNode(true);
+                            currentPara.AppendChild(breakRun);
+                        }
+                        else
+                        {
+                            pageBreakBeforeNext = true;
+                        }
+                    }
+                    else if (breakType == BreakType.NewLandscapeSection || breakType == BreakType.NewPortraitSection)
+                    {
+                        if (currentPara is null)
+                        {
+                            var newPara = CloneParagraphWithoutSection(original);
+                            resultParas.Add(newPara);
+                            currentPara = newPara;
+                            AddSectionProperties(currentPara, breakType, false, sourceSection, portraitSection);
+                            lastOrientation = breakType;
+                            sectionChangeInsideGroup = true;
+                            firstSplitMarkerHandled = true;
+                            pendingOrientation = null;
+                            textCount = 0;
+                            lastTextPara = null;
+                        }
+                        else
+                        {
+                            if (!firstSplitMarkerHandled)
+                            {
+                                if (lastTextPara is not null)
+                                {
+                                    if (lastTextPara.ParagraphProperties?.GetFirstChild<SectionProperties>() is null)
+                                    {
+                                        lastTextPara.ParagraphProperties ??= new ParagraphProperties();
+
+                                        var sourcePageSize = sourceSection.GetFirstChild<PageSize>();
+                                        if (sourcePageSize is not null)
+                                        {
+                                            lastTextPara.ParagraphProperties.AppendChild(sourceSection.CloneNode(true));
+                                        }
+                                        else
+                                        {
+                                            AddSectionProperties(lastTextPara, breakType, false, sourceSection, portraitSection);
+                                        }
+                                        lastOrientation = breakType;
+                                        sectionChangeInsideGroup = true;
+                                    }
+                                    firstSplitMarkerHandled = true;
+                                    pendingOrientation = null;
+                                }
+                                else
+                                {
+                                    AddSectionProperties(currentPara, breakType, false, sourceSection, portraitSection);
+                                    lastOrientation = breakType;
+                                    sectionChangeInsideGroup = true;
+                                    firstSplitMarkerHandled = true;
+                                    pendingOrientation = null;
+                                }
+                            }
+                            else
+                            {
+                                pendingOrientation = breakType;
+                            }
                         }
-                        bodySection.AppendChild(marginClone);
                     }
-                    bodySection.AppendChild(new SectionType { Val = SectionMarkValues.NextPage });
-                    body.AppendChild(bodySection);
                 }
             }
+
+            // Закрываем секцию, если была смена
+            if (sectionChangeInsideGroup && lastOrientation.HasValue && currentPara is not null)
+            {
+                if (currentPara.ParagraphProperties?.GetFirstChild<SectionProperties>() is null)
+                {
+                    bool addPageSize = (lastOrientation.Value == BreakType.NewLandscapeSection);
+                    AddSectionProperties(currentPara, lastOrientation.Value, addPageSize, sourceSection, portraitSection);
+                }
+            }
+
+            EnsureBodyLandscapeSection(body!, sourceSection, sectionChangeInsideGroup, lastOrientation);
+
             currentPos = match.End;
         }
 
-        if (currentPos < fullText.Length && BuildRemainderParagraph(original, structure, currentPos) is { } remainderPara)
+        // 6. Обработка остатка текста
+        if (currentPos < fullText.Length)
         {
-            if (sectionChangeInsideGroup && lastOrientation.HasValue)
+            var remainderPara = BuildRemainderParagraph(original, structure, currentPos);
+            if (remainderPara is not null)
             {
-                remainderPara.InsertAt(new Run(new Break { Type = BreakValues.Page }), 0);
+                if (pendingOrientation.HasValue)
-                AddSectionProperties(remainderPara, lastOrientation.Value, lastOrientation.Value == PageBreakType.NewLandscapeSection, sourceSection, portraitSection);
+                {
+                    var breakRun = new Run(new Break { Type = BreakValues.Page });
+                    remainderPara.InsertAt(breakRun, 0);
+                    bool addPageSize = (pendingOrientation.Value == BreakType.NewLandscapeSection);
+                    AddSectionProperties(remainderPara, pendingOrientation.Value, addPageSize, sourceSection, portraitSection);
+                    pendingOrientation = null;
+                }
+                else if (sectionChangeInsideGroup && lastOrientation.HasValue)
+                {
+                    var breakRun = new Run(new Break { Type = BreakValues.Page });
+                    remainderPara.InsertAt(breakRun, 0);
+                    bool addPageSize = (lastOrientation.Value == BreakType.NewLandscapeSection);
+                    AddSectionProperties(remainderPara, lastOrientation.Value, addPageSize, sourceSection, portraitSection);
+                }
+                resultParas.Add(remainderPara);
             }
-            resultParas.Add(remainderPara);
         }
 
-        resultParas.RemoveAll(p => !p.Elements<Run>().Any() && p.ParagraphProperties is null);
+        // 7. Очистка пустых параграфов
+        for (int i = resultParas.Count - 1; i >= 0; i--)
+        {
+            var p = resultParas[i];
+            if (!p.ChildElements.OfType<Run>().Any() && p.ParagraphProperties is null)
+                resultParas.RemoveAt(i);
+        }
+
         return resultParas.Count > 0 ? resultParas : null;
     }
 }

QWERTYkez.WordProcessor/ReplaceItem.cs

@@ -1,70 +1,39 @@
 namespace QWERTYkez.WordProcessor;
 
-/// <summary>
+/// <summary> Определяет тип разрыва или смены ориентации страницы </summary>
-/// Определяет тип разрыва или смены ориентации страницы, применяется к элементам следующим после замены
+public enum BreakType
-/// </summary>
-public enum PageBreakType
 {
-    /// <summary>Без разрыва или смены ориентации.</summary>
-    None,
-
     /// <summary>Обычный разрыв страницы (новый лист).</summary>
     PageBreak,
-
     /// <summary>Начать новую секцию с альбомной ориентацией страницы.</summary>
     NewLandscapeSection,
-
     /// <summary>Начать новую секцию с книжной ориентацией страницы.</summary>
     NewPortraitSection,
 }
 
-/// <summary>
+public class ReplaceItem
-/// Представляет элемент замены текста, содержащий сам текст и указание
-/// на тип разрыва или смены ориентации, который должен быть применён
-/// после вставки этого текста.
-/// </summary>
-/// <remarks>
-/// Используется в методах множественной замены, например,
-/// <see cref="IWordWriter.ReplaceItem(string, IEnumerable{ReplaceItem})"/>.
-/// </remarks>
-public readonly struct ReplaceItem
 {
-    /// <summary>
+    private ReplaceItem() { }
-    /// Инициализирует новый экземпляр <see cref="ReplaceItem"/> с пустым текстом
+    public ReplaceItem(string text) => _Text = text;
-    /// и типом разрыва <see cref="PageBreakType.None"/>.
+    public ReplaceItem(BreakType item) => _BreakValue = item;
-    /// </summary>
-    public ReplaceItem() { }
 
-    /// <summary>
-    /// Инициализирует новый экземпляр <see cref="ReplaceItem"/> с указанным текстом
-    /// и типом разрыва/смены ориентации.
-    /// </summary>
-    /// <param name="text">Текст, который будет вставлен вместо плейсхолдера.</param>
-    /// <param name="splitValue">
-    /// Тип разрыва или смены ориентации, который будет применён после вставки текста.
-    /// По умолчанию <see cref="PageBreakType.None"/>.
-    /// </param>
-    public ReplaceItem(string text, PageBreakType splitValue = PageBreakType.None)
-    {
-        Text = text;
-        SplitValue = splitValue;
-    }
 
-    /// <summary>
+    public static implicit operator ReplaceItem(string text) => new(text);
-    /// Получает текст, который будет вставлен вместо плейсхолдера.
+    public static implicit operator ReplaceItem(BreakType item) => item switch
-    /// </summary>
+        {
-    public string Text { get; init; } = string.Empty;
+            BreakType.PageBreak => PageBreak,
+            BreakType.NewLandscapeSection => NewLandscapeSection,
+            BreakType.NewPortraitSection => NewPortraitSection,
+            _ => throw new NotImplementedException()
+        };
 
-    /// <summary>
+    public static ReplaceItem PageBreak { get; } = new() { _BreakValue = BreakType.PageBreak };
-    /// Получает тип разрыва или смены ориентации, который будет применён
+    public static ReplaceItem NewLandscapeSection { get; } = new() { _BreakValue = BreakType.NewLandscapeSection };
-    /// после вставки текста.
+    public static ReplaceItem NewPortraitSection { get; } = new() { _BreakValue = BreakType.NewPortraitSection };
-    /// </summary>
-    public PageBreakType SplitValue { get; init; } = PageBreakType.None;
 
-    /// <summary>
+    public string Text => _Text;
-    /// Определяет явное преобразование из строки в <see cref="ReplaceItem"/>.
+    public string _Text = string.Empty;
-    /// </summary>
+
-    /// <param name="text">Строка текста.</param>
+    public BreakType? BreakValue => _BreakValue;
-    /// <returns>Новый экземпляр <see cref="ReplaceItem"/> с указанным текстом и <see cref="PageBreakType.None"/>.</returns>
+    public BreakType? _BreakValue;
-    public static explicit operator ReplaceItem(string text) => new() { Text = text };
 }

QWERTYkez.WordProcessor/SimplyReplace.cs

@@ -77,7 +77,7 @@ internal static class SimplyReplaceExt
         }
     }
 
-    internal static bool SimpleReplace(this Paragraph? paragraph, string oldValue, string newValue, StringComparison comparisonType, PageBreakType splitValue = PageBreakType.None)
+    internal static bool SimpleReplace(this Paragraph? paragraph, string oldValue, string newValue, StringComparison comparisonType, BreakType? splitValue = null)
     {
         if (paragraph is null || string.IsNullOrEmpty(oldValue))
             return false;
@@ -108,7 +108,7 @@ internal static class SimplyReplaceExt
     }
 
     internal static bool SimpleReplace(this Paragraph? paragraph, string oldValue, string newValue, StringComparison comparisonType, bool breakPage)
-        => SimpleReplace(paragraph, oldValue, newValue, comparisonType, breakPage ? PageBreakType.PageBreak : PageBreakType.None);
+        => SimpleReplace(paragraph, oldValue, newValue, comparisonType, breakPage ? BreakType.PageBreak : null);
 
     internal static void Replace(this Paragraph paragraph, IEnumerable<KeyValuePair<string, string>> replacements, StringComparison comparisonType)
     {
@@ -139,7 +139,7 @@ internal static class SimplyReplaceExt
                     OldValue = kvp.Key,
                     NewValue = kvp.Value ?? string.Empty,
                     Index = pos,
-                    SplitValue = PageBreakType.None
+                    BreakValue = null
                 });
                 pos += kvp.Key.Length;
             }
@@ -159,7 +159,7 @@ internal static class SimplyReplaceExt
             var nodesToReplace = FindNodesToReplace(structure, matchIndex, matchEnd);
             if (nodesToReplace.Count > 0)
             {
-                ExecuteReplacement(nodesToReplace, matchIndex, matchEnd, replacement.NewValue, replacement.SplitValue);
+                ExecuteReplacement(nodesToReplace, matchIndex, matchEnd, replacement.NewValue, replacement.BreakValue);
             }
         }
     }
@@ -193,7 +193,7 @@ internal static class SimplyReplaceExt
                     OldValue = kvp.Key,
                     NewValue = kvp.Value.Text ?? string.Empty,
                     Index = pos,
-                    SplitValue = kvp.Value.SplitValue
+                    BreakValue = kvp.Value.BreakValue
                 });
                 pos += kvp.Key.Length;
             }
@@ -213,7 +213,7 @@ internal static class SimplyReplaceExt
             var nodesToReplace = FindNodesToReplace(structure, matchIndex, matchEnd);
             if (nodesToReplace.Count > 0)
             {
-                ExecuteReplacement(nodesToReplace, matchIndex, matchEnd, replacement.NewValue, replacement.SplitValue);
+                ExecuteReplacement(nodesToReplace, matchIndex, matchEnd, replacement.NewValue, replacement.BreakValue);
             }
         }
     }
@@ -223,7 +223,7 @@ internal static class SimplyReplaceExt
         internal string OldValue { get; set; } = null!;
         internal string NewValue { get; set; } = null!;
         internal int Index { get; set; }
-        internal PageBreakType SplitValue { get; set; } = PageBreakType.None;
+        internal BreakType? BreakValue { get; set; } = null;
     }
 
     private static ParagraphStructure AnalyzeParagraphStructure(IEnumerable<Run> runs)
@@ -287,7 +287,7 @@ internal static class SimplyReplaceExt
     int matchStart,
     int matchEnd,
     string newValue,
-    PageBreakType splitValue)
+    BreakType? splitValue)
     {
         if (nodesToReplace.Count == 0) return;
 
@@ -312,7 +312,7 @@ internal static class SimplyReplaceExt
             nodesToReplace[i].Text.Text = string.Empty;
         }
 
-        if (splitValue == PageBreakType.PageBreak)
+        if (splitValue == BreakType.PageBreak)
         {
             if (nodesToReplace[0].Text.Parent is Run run && run.Parent is Paragraph para)
             {
@@ -322,7 +322,7 @@ internal static class SimplyReplaceExt
                 para.AppendChild(breakRun);
             }
         }
-        else if (splitValue == PageBreakType.NewLandscapeSection || splitValue == PageBreakType.NewPortraitSection)
+        else if (splitValue == BreakType.NewLandscapeSection || splitValue == BreakType.NewPortraitSection)
         {
             var firstText = nodesToReplace[0].Text;
             if (firstText.Parent is Run run && run.Parent is Paragraph para)
@@ -332,10 +332,10 @@ internal static class SimplyReplaceExt
         }
     }
 
-    private static void AddSectionProperties(Paragraph para, PageBreakType splitValue)
+    private static void AddSectionProperties(Paragraph para, BreakType? splitValue)
     {
         if (para is null) return;
-        PageOrientationValues orientation = splitValue == PageBreakType.NewLandscapeSection
+        PageOrientationValues orientation = splitValue == BreakType.NewLandscapeSection
             ? PageOrientationValues.Landscape
             : PageOrientationValues.Portrait;