// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

#nullable enable

using System;
using System.Linq;
using System.Xml.Linq;

namespace Microsoft.DotNet.Build.Tasks.Workloads.Msi;

internal static class WixXmlExtensions
{
    private static readonly XNamespace s_wixNamespace = "http://wixtoolset.org/schemas/v4/wxs";

    /// <summary>
    /// Allowed parent elements for a Directory element.
    /// </summary>
    private static readonly string[] _directoryParentElements =
        ["Package", "Module", "Fragment", "Directory", "DirectoryRef", "StandardDirectory"];

    /// <summary>
    /// Allowed parent elements for a ComponentGroupRef element.
    /// </summary>
    private static readonly string[] _componentGroupRefParentElements =
        ["Package", "Module", "ComponentGroup", "Feature", "FeatureGroup", "FeatureRef"];

    /// <summary>
    /// Allowed parent elements for a RegistryKey element.
    /// </summary>
    private static readonly string[] _registryKeyParentElements = ["Component", "RegistryKey"];

    /// <summary>
    /// Allowed parent elements for a RegistryValue element.
    /// </summary>
    private static readonly string[] _registryValueParentElements = ["Component", "RegistryKey"];

    /// <summary>
    /// Adds a RegistryValue element to an existing element. RegistryValue elements can be added to existing
    /// Component and RegistryKey elements.
    /// </summary>
    /// <param name="element">The parent element to which the RegistryValue will be added.</param>
    /// <param name="name">The registry value name.</param>
    /// <param name="value">The registry value.</param>
    /// <param name="type">The registry value's type.</param>
    /// <param name="keyPath">Determines whether the registry value is the keypath of the parent component.</param>
    /// <returns>The parent element.</returns>
    /// <exception cref="InvalidOperationException"></exception>
    public static XElement AddRegistryValue(this XElement element, string? name, string value, string type = "string", bool keyPath = false)
    {
        if (_registryValueParentElements.Any(e => string.Equals(e, element.Name.LocalName)))
        {
            var registryValue = new XElement(s_wixNamespace + "RegistryValue",
                new XAttribute("Value", value),
                new XAttribute("Type", type),
                new XAttribute("KeyPath", keyPath ? "yes" : "no"));

            if (!string.IsNullOrWhiteSpace(name))
            {
                registryValue.SetAttributeValue("Name", name);
            }

            element.Add(registryValue);
            return element;
        }
        throw new InvalidOperationException(string.Format(Strings.InvalidChildElement, "RegistryValue", element.Name.LocalName));
    }

    /// <summary>
    /// Adds a new <c>RegistryKey</c> child element to the specified parent <see cref="XElement"/> if the parent
    /// supports registry key elements.
    /// </summary>
    /// <remarks>Use this method to programmatically construct WiX XML fragments that define registry
    /// keys. The method only adds a <c>RegistryKey</c> element if the parent element type is valid for registry
    /// keys.</remarks>
    /// <param name="element">The parent <see cref="XElement"/> to which the <c>RegistryKey</c> element will be added. Must be an element
    /// type that allows registry key children.</param>
    /// <param name="key">The registry key path to assign to the new <c>RegistryKey</c> element.</param>
    /// <param name="root">The root of the registry hive. Defaults to "HKLM" if not specified.</param>
    /// <returns>The newly created <c>XElement</c> representing the <c>RegistryKey</c> child element.</returns>
    /// <exception cref="InvalidOperationException">Thrown if the specified <paramref name="element"/> does not support adding a <c>RegistryKey</c> child
    /// element.</exception>
    public static XElement AddRegistryKey(this XElement element, string key, string? root = "HKLM")
    {
        if (_registryKeyParentElements.Any(e => string.Equals(e, element.Name.LocalName)))
        {
            var registryKey = new XElement(s_wixNamespace + "RegistryKey",
                new XAttribute("Key", key));

            // If root is null, <RegistryKey> elements can be nested and will inherit the parent's Root attribute.
            if (!string.IsNullOrWhiteSpace(root))
            {
                registryKey.SetAttributeValue("Root", root);
            }

            element.Add(registryKey);
            return registryKey;
        }
        throw new InvalidOperationException(string.Format(Strings.InvalidChildElement, "RegistryKey", element.Name.LocalName));
    }

    /// <summary>
    /// Adds a new ComponentGroupRef element with the specified identifier as a child of the given XElement, if the
    /// element supports ComponentGroupRef children.
    /// </summary>
    /// <param name="element">The parent XElement to which the ComponentGroupRef element will be added. Must be an element type that
    /// allows ComponentGroupRef children.</param>
    /// <param name="id">The identifier to assign to the Id attribute of the new ComponentGroupRef element.</param>
    /// <returns>The newly created ComponentGroupRef XElement that was added as a child of the specified element.</returns>
    /// <exception cref="InvalidOperationException">Thrown if the specified element does not support ComponentGroupRef child elements.</exception>
    public static XElement AddComponentGroupRef(this XElement element, string id)
    {
        if (_componentGroupRefParentElements.Any(e => string.Equals(e, element.Name.LocalName)))
        {
            var componentGroupRef = new XElement(s_wixNamespace + "ComponentGroupRef",
            new XAttribute("Id", id));
            element.Add(componentGroupRef);
            return componentGroupRef;
        }
        throw new InvalidOperationException(string.Format(Strings.InvalidChildElement, "ComponentGroupRef", element.Name.LocalName));
    }

    /// <summary>
    /// Adds a Directory element to an existing directory element. Directory elements can be added
    /// to existing Directory or DirectoryRef elements to create a subdirectory.
    /// </summary>        
    /// <param name="id">The identifier used when referencing the directory.</param>
    /// <param name="name">The name of the directory.</param>
    /// <returns>The new Directory element.</returns>
    /// <exception cref="InvalidOperationException"/>
    public static XElement AddDirectory(this XElement element, string id, string name)
    {
        if (_directoryParentElements.Any(e => string.Equals(e, element.Name.LocalName)))
        {
            var directory = new XElement(s_wixNamespace + "Directory",
                new XAttribute("Id", id),
                new XAttribute("Name", name));

            element.Add(directory);

            return directory;
        }

        throw new InvalidOperationException(string.Format(Strings.InvalidChildElement, "Directory", element.Name.LocalName));
    }

    public static XElement AddDirectory(this XElement element, XElement directory)
    {
        if (_directoryParentElements.Any(e => string.Equals(e, element.Name.LocalName)))
        {
            element.Add(directory);

            return directory;
        }

        throw new InvalidOperationException(string.Format(Strings.InvalidChildElement, "Directory", element.Name.LocalName));
    }
}