using System;

using System.Collections.Generic;

using System.Linq;

using System.Xml.Linq;

using System.Text.Json;

​

class Program

{

    static void Main()

    {

        string xml = @"<root>

                          <list items='{{list}}'>

                              <item>

                                  <sublist type='{{type}}' items='{{sublist}}'>

                                      <subitem>{{name}}</subitem>

                                  </sublist>

                              </item>

                          </list>

                       </root>";

​

        string jsonData = @"{

            ""list"": 

            [

                {""sublist"": [{""name"":""a""}, {""name"":""b""}], ""type"": ""type1""},

                {""sublist"": [{""name"":""c""}, {""name"":""d""}], ""type"": ""type2""}

            ]

        }";

​

        // Parse JSON data

        var jsonDoc = JsonDocument.Parse(jsonData);

        var jsonRoot = jsonDoc.RootElement;

​

        // Replace placeholders in XML

        XDocument doc = XDocument.Parse(xml);

        ProcessItems(doc.Root, jsonRoot);

​

        // Output final XML

        Console.WriteLine(doc);

        // Convert processed XML to JSON

        var jsonFromXml = ConvertXmlToJsonOption2(doc.Root);

        Console.WriteLine("\nConverted JSON:");

        Console.WriteLine(JsonSerializer.Serialize(jsonFromXml, new JsonSerializerOptions { WriteIndented = true }));

    }

​

    static void ProcessItems(XElement parentElement, JsonElement jsonData, JsonElement? parentJsonData = null)

    {

        foreach (XElement element in parentElement.Elements().ToList()) // Avoid modifying collection during iteration

        {

            XAttribute itemsAttr = element.Attribute("items");

​

            if (itemsAttr != null && itemsAttr.Value.StartsWith("{{") && itemsAttr.Value.EndsWith("}}"))

            {

                // Extract the key from the placeholder

                string key = itemsAttr.Value.Trim('{', '}');

​

                if (jsonData.TryGetProperty(key, out JsonElement listData) && listData.ValueKind == JsonValueKind.Array)

                {

                    List<XElement> newElements = new List<XElement>();

​

                    foreach (JsonElement listItem in listData.EnumerateArray())

                    {

                        XElement newElement = new XElement(element); // Clone the current element

​

                        // Process attributes and children dynamically

                        ProcessAttributes(newElement, listItem, jsonData);

                        ProcessItems(newElement, listItem, jsonData);

​

                        newElements.Add(newElement);

                    }

​

                    // Replace the original element with the generated elements

                    element.ReplaceWith(newElements);

                }

            }

            else

            {

                // Recursively process children

                ProcessItems(element, jsonData, parentJsonData);

            }

​

            // Remove the "items" attribute from <list> after processing

            if (element.Name == "list" && itemsAttr != null)

            {

                itemsAttr.Remove();

            }

​

            // Replace text placeholders (e.g., {{name}})

            ReplaceTextPlaceholders(element, jsonData, parentJsonData);

        }

    }

​

    static void ProcessAttributes(XElement element, JsonElement jsonData, JsonElement? parentJsonData = null)

    {

        foreach (XAttribute attr in element.Attributes().ToList())

        {

            if (attr.Value.StartsWith("{{") && attr.Value.EndsWith("}}"))

            {

                // Extract the key from the placeholder

                string key = attr.Value.Trim('{', '}');

​

                if (jsonData.TryGetProperty(key, out JsonElement value))

                {

                    if (value.ValueKind == JsonValueKind.String)

                    {

                        // Replace the attribute value with the JSON value

                        attr.Value = value.GetString();

                    }

                    else

                    {

                        // Remove the attribute if the value is not a string

                        attr.Remove();

                    }

                }

                else if (parentJsonData.HasValue && parentJsonData.Value.TryGetProperty(key, out JsonElement parentValue))

                {

                    if (parentValue.ValueKind == JsonValueKind.String)

                    {

                        // Use the parent JSON context if the key is not found in the current JSON data

                        attr.Value = parentValue.GetString();

                    }

                    else

                    {

                        // Remove the attribute if the value is not a string

                        attr.Remove();

                    }

                }

                else

                {

                    // Remove the attribute if no matching JSON value is found

                    attr.Remove();

                }

            }

        }

    }

​

    static void ReplaceTextPlaceholders(XElement element, JsonElement jsonData, JsonElement? parentJsonData = null)

    {

        foreach (XNode node in element.Nodes().ToList())

        {

            if (node is XText textNode && textNode.Value.StartsWith("{{") && textNode.Value.EndsWith("}}"))

            {

                // Extract the key from the placeholder

                string key = textNode.Value.Trim('{', '}');

​

                if (jsonData.TryGetProperty(key, out JsonElement value))

                {

                    if (value.ValueKind == JsonValueKind.String)

                    {

                        // Replace the text node with the JSON value

                        textNode.ReplaceWith(new XText(value.GetString()));

                    }

                }

                else if (parentJsonData.HasValue && parentJsonData.Value.TryGetProperty(key, out JsonElement parentValue))

                {

                    if (parentValue.ValueKind == JsonValueKind.String)

                    {

                        // Use the parent JSON context if the key is not found in the current JSON data

                        textNode.ReplaceWith(new XText(parentValue.GetString()));

                    }

                }

            }

        }

    }

    static object ConvertXmlToJsonOption1(XElement element)

    {

        // If the element has no children, return its value or attributes as a dictionary

        if (!element.HasElements)

        {

            if (element.HasAttributes)

            {

                var attributes = element.Attributes().ToDictionary(attr => attr.Name.LocalName, attr => (object)attr.Value);

                if (!string.IsNullOrWhiteSpace(element.Value))

                {

                    attributes["value"] = element.Value;

                }

                return attributes;

            }

            return element.Value;

        }

​

        // If the element has children, group them by name

        var groupedElements = element.Elements()

            .GroupBy(child => child.Name.LocalName)

            .ToDictionary(

                group => group.Key,

                group => group.Count() > 1

                    ? group.Select(ConvertXmlToJsonOption1).ToList() // Multiple children with the same name -> array

                    : ConvertXmlToJsonOption1(group.First()) // Single child -> object

            );

​

        // Include attributes in the result

        if (element.HasAttributes)

        {

            var attributes = element.Attributes().ToDictionary(attr => attr.Name.LocalName, attr => (object)attr.Value);

            foreach (var attr in attributes)

            {

                groupedElements[attr.Key] = attr.Value;

            }

        }

​

        return groupedElements;

    }

    static object ConvertXmlToJsonOption2(XElement element)

    {

        // Create the base JSON object for this element

        var jsonObject = new Dictionary<string, object>

        {

            { "type", element.Name.LocalName } // The tag name

        };

​

        // Add attributes as "params"

        if (element.HasAttributes)

        {

            jsonObject["params"] = element.Attributes().ToDictionary(attr => attr.Name.LocalName, attr => (object)attr.Value);

        }

        else

        {

            jsonObject["params"] = new Dictionary<string, object>();

        }

​

        // Add children

        if (element.HasElements)

        {

            jsonObject["children"] = element.Elements().Select(ConvertXmlToJsonOption2).ToList();

        }

        else if (!string.IsNullOrWhiteSpace(element.Value))

        {

            // If the element has text content, add it to "params" as "value"

            var paramsDict = (Dictionary<string, object>)jsonObject["params"];

            paramsDict["value"] = element.Value;

        }

​

        return jsonObject;

    }

}