Revise paste xx-1

public class XsdGenerator
{
    private const string Xs = "http://www.w3.org/2001/XMLSchema";
    
    public XDocument Generate(XmlValidator validator, string rootElementName)
    {
        var schema = new XElement(XName.Get("schema", Xs),
            new XAttribute(XNamespace.Xmlns + "xs", Xs));

var rootElement = new XElement(XName.Get("element", Xs),
            new XAttribute("name", rootElementName));

var rootComplex = new XElement(XName.Get("complexType", Xs));
        var rootSeq = new XElement(XName.Get("sequence", Xs));

foreach (var rule in validator.Rules.OfType<XmlCompositeRule>())
        {
            var segments = GetElementSegments(rootElementName, rule.Path);

XElement parent = rootSeq;
            foreach (var seg in segments)
            {
                // Find or create element node
                var existing = parent.Elements(XName.Get("element", Xs))
                    .FirstOrDefault(e => (string)e.Attribute("name") == seg);
                if (existing == null)
                {
                    existing = new XElement(XName.Get("element", Xs),
                        new XAttribute("name", seg));
                    parent.Add(existing);
                    var complex = new XElement(XName.Get("complexType", Xs));
                    var seq = new XElement(XName.Get("sequence", Xs));
                    complex.Add(seq);
                    existing.Add(complex);
                }
                parent = existing.Element(XName.Get("complexType", Xs))!
                    .Element(XName.Get("sequence", Xs))!;
            }

// Apply restrictions/attributes at the deepest segment
            var targetElement = parent.Parent!.Parent!; // the <xs:element> node
            ApplyRuleToElement(targetElement, rule);
        }

var globalRules = validator.Rules.OfType<XmlGlobalRule>();
        var annotation = GetAnnotation(rootElement);
        foreach (var gr in globalRules)
        {
            annotation.Add(new XElement(XName.Get("documentation", Xs),
                gr.Message ?? "Global validation rule applied"));
        }

rootComplex.Add(rootSeq);
        rootElement.Add(rootComplex);
        schema.Add(rootElement);

AddUniqueConstraints(new XDocument(schema), validator, rootElementName);

return new XDocument(schema);
    }

private XElement GetAnnotation(XElement rootElement)
    {
        var annotation = rootElement.Element(XName.Get("annotation", Xs));
        if (annotation == null)
        {
            annotation = new XElement(XName.Get("annotation", Xs));
            rootElement.Add(annotation);
        }

return annotation;
    }

private static string[] GetElementSegments(string root, string path)
    {
        // Trim leading/trailing slashes and split
        var segments = path.Trim('/').Split('/');
        // Ensure the first segment matches root
        if (segments.Length == 0 || segments[0] != root)
            throw new InvalidOperationException($"Path '{path}' does not start with root '{root}'.");
        // Return all segments after root
        return segments.Skip(1).ToArray();
    }
    
    private static void ApplyRuleToElement(XElement elementNode, XmlCompositeRule rule)
    {
        var complex = elementNode.Element(XName.Get("complexType", Xs));
        var sequence = complex?.Element(XName.Get("sequence", Xs));

var attributes = new Dictionary<string, List<RecordedStep>>();
        var simpleContentNeeded = false;
      
        // Add empty annotation
        //// Collect annotation node once per element
        //var annotation = elementNode.Element(XName.Get("annotation", Xs));
        //if (annotation == null)
        //{
        //    annotation = new XElement(XName.Get("annotation", Xs));
        //    elementNode.Add(annotation);
        //}

foreach (var step in rule.RecordedSteps)
        {
            switch (step.Kind)
            {
                case XmlValidationRuleKind.AttributeRequired:
                case XmlValidationRuleKind.AttributeRegex:
                case XmlValidationRuleKind.AttributeRangeInt:
                case XmlValidationRuleKind.AttributeUnique:
                    simpleContentNeeded = true;
                    var name = step.AttributeName!;
                    if (!attributes.ContainsKey(name)) attributes[name] = new List<RecordedStep>();
                    attributes[name].Add(step);
                    break;

case XmlValidationRuleKind.ElementRequired:
                case XmlValidationRuleKind.ElementRegex:
                case XmlValidationRuleKind.ElementRangeInt:
                case XmlValidationRuleKind.ElementUnique:
                    simpleContentNeeded = true;
                    break;
                case XmlValidationRuleKind.CustomElement:
                    //elementNode.Add(new XElement(XName.Get("annotation", Xs),
                    //    new XElement(XName.Get("documentation", Xs),
                    //        $"Custom rule applied: {step.Message}")));
                    break;

case XmlValidationRuleKind.ElementAttributeCross:
                    //elementNode.Add(new XElement(XName.Get("annotation", Xs),
                    //    new XElement(XName.Get("documentation", Xs),
                    //        $"Runtime rule on '{elementNode.Attribute("name")?.Value}': {step.Message ?? step.Kind.ToString()}")));
                    break;
            }
        }

if (simpleContentNeeded || attributes.Count > 0)
        {
            var simpleContent = new XElement(XName.Get("simpleContent", Xs));
            var extension = new XElement(XName.Get("extension", Xs),
                new XAttribute("base", InferBaseForElement(new[] { rule })));
            foreach (var attr in attributes)
            {
                extension.Add(BuildAttribute(attr.Key, attr.Value));
            }
            simpleContent.Add(extension);
            complex!.RemoveNodes();
            complex.Add(simpleContent);
        }
    }

private static string GetTopElementName(string root, string path)
    {
        // path like /order/id or /order/items/item
        var segments = path.Trim('/').Split('/');
        if (segments.Length < 2 || segments[0] != root) return segments[0];
        return segments[1];
    }

private static string? GetChildElementName(string root, string path)
    {
        var segments = path.Trim('/').Split('/');
        if (segments.Length <= 2) return null;
        if (segments[0] != root) return null;
        return segments.Last();
    }

private static string InferMinOccurs(IEnumerable<XmlCompositeRule> rules)
    {
        var hasRequired = rules.Any(r => r.RecordedSteps.Any(s => s.Kind == XmlValidationRuleKind.ElementRequired));
        return hasRequired ? "1" : "0";
    }

private static XName XS(string local) => XName.Get(local, Xs);

private static XElement? BuildSimpleTypeForElement(IEnumerable<XmlCompositeRule> rules)
    {
        var regex = rules.SelectMany(r => r.RecordedSteps)
            .Where(s => s.Kind == XmlValidationRuleKind.ElementRegex)
            .Select(s => s.Arg1 as string)
            .FirstOrDefault();

var range = rules.SelectMany(r => r.RecordedSteps)
            .Where(s => s.Kind == XmlValidationRuleKind.ElementRangeInt)
            .Select(s => (Min: (int)s.Arg1!, Max: (int)s.Arg2!))
            .FirstOrDefault();

if (regex == null && range.Min == 0 && range.Max == 0) return null;

var simpleType = new XElement(XS("simpleType"));
        var restriction = new XElement(XS("restriction"),
            new XAttribute("base", range.Min != 0 || range.Max != 0 ? "xs:int" : "xs:string"));

if (range.Min != 0 || range.Max != 0)
        {
            restriction.Add(new XElement(XS("minInclusive"), new XAttribute("value", range.Min)));
            restriction.Add(new XElement(XS("maxInclusive"), new XAttribute("value", range.Max)));
        }

if (regex is not null)
        {
            restriction.Add(new XElement(XS("pattern"), new XAttribute("value", regex)));
        }

simpleType.Add(restriction);
        return simpleType;
    }

private static string InferBaseForElement(IEnumerable<XmlCompositeRule> rules)
    {
        var hasIntRange = rules.SelectMany(r => r.RecordedSteps)
            .Any(s => s.Kind == XmlValidationRuleKind.ElementRangeInt);
        return hasIntRange ? "xs:int" : "xs:string";
    }

private static XElement BuildAttribute(string name, IEnumerable<RecordedStep> steps)
    {
        var attr = new XElement(XS("attribute"), new XAttribute("name", name));
        var required = steps.Any(s => s.Kind == XmlValidationRuleKind.AttributeRequired);
        if (required) attr.Add(new XAttribute("use", "required"));

var pattern = steps.Where(s => s.Kind == XmlValidationRuleKind.AttributeRegex).Select(s => s.Arg1 as string).FirstOrDefault();
        var range = steps.Where(s => s.Kind == XmlValidationRuleKind.AttributeRangeInt).Select(s => (Min: (int)s.Arg1!, Max: (int)s.Arg2!)).FirstOrDefault();

if (pattern != null || (range.Min != 0 || range.Max != 0))
        {
            var simpleType = new XElement(XS("simpleType"));
            var baseType = (range.Min != 0 || range.Max != 0) ? "xs:int" : "xs:string";
            var restriction = new XElement(XS("restriction"), new XAttribute("base", baseType));
            if (range.Min != 0 || range.Max != 0)
            {
                restriction.Add(new XElement(XS("minInclusive"), new XAttribute("value", range.Min)));
                restriction.Add(new XElement(XS("maxInclusive"), new XAttribute("value", range.Max)));
            }
            if (pattern != null)
            {
                restriction.Add(new XElement(XS("pattern"), new XAttribute("value", pattern)));
            }
            simpleType.Add(restriction);
            attr.Add(simpleType);
        }

return attr;
    }

private static void AddUniqueConstraints(XDocument schema, XmlValidator validator, string rootElementName)
    {
        // Element-level unique constraints
        var elementUniqueRules = validator.Rules.OfType<XmlCompositeRule>()
            .Where(r => r.RecordedSteps.Any(s => s.Kind == XmlValidationRuleKind.ElementUnique));

foreach (var rule in elementUniqueRules)
        {
            schema.Root!.Add(new XElement(XName.Get("unique", Xs),
                new XAttribute("name", $"unique_{San(rule.Path)}"),
                new XElement(XName.Get("selector", Xs), new XAttribute("xpath", rule.Path)),
                new XElement(XName.Get("field", Xs), new XAttribute("xpath", "."))));
        }

// Attribute-level unique constraints
        var attributeUniqueRules = validator.Rules.OfType<XmlCompositeRule>()
            .SelectMany(r => r.RecordedSteps.Select(s => (Rule: r, Step: s)))
            .Where(rs => rs.Step.Kind == XmlValidationRuleKind.AttributeUnique);

foreach (var (r, step) in attributeUniqueRules)
        {
            schema.Root!.Add(new XElement(XName.Get("unique", Xs),
                new XAttribute("name", $"unique{San(r.Path)}{step.AttributeName}"),
                new XElement(XName.Get("selector", Xs), new XAttribute("xpath", r.Path)),
                new XElement(XName.Get("field", Xs), new XAttribute("xpath", $"@{step.AttributeName}"))));
        }

static string San(string s) => s.Trim('/').Replace("/", "").Replace("@", "");
    }

}