// 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.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;

namespace XliffTasks.Model;

/// <summary>
/// A <see cref="TranslatableDocument"/> for files in CPS rule .xaml format
/// See https://msdn.microsoft.com/en-us/library/ekyft91f(v=vs.100).aspx
/// </summary>
internal sealed class XamlRuleDocument : TranslatableXmlDocument
{
    private const string XliffTasksNs = "https://github.com/dotnet/xliff-tasks";
    private const string LocalizedPropertiesAttributeName = "LocalizedProperties";

    private static readonly char[] s_attrValueTrimChars = [ ':', ' ', '\t' ];
    
    protected override IEnumerable<TranslatableNode> GetTranslatableNodes()
    {
        foreach (XElement? element in Document.Descendants())
        {
            // first, let's check if the element has a descendent by the name of {elementLocalName.Description/DisplayName}
            var descendentDisplayName = element.Elements(XName.Get($"{element.Name.LocalName}.DisplayName", element.Name.NamespaceName)).FirstOrDefault();
            var descendentDescription = element.Elements(XName.Get($"{element.Name.LocalName}.Description", element.Name.NamespaceName)).FirstOrDefault();

            if (descendentDisplayName is not null)
            {
                yield return new TranslatableXmlElement(
                    id: GenerateIdForDisplayNameOrDescription(descendentDisplayName),
                    source: descendentDisplayName.Value,
                    note: GetComment(descendentDisplayName, XmlName(descendentDisplayName)),
                    element: descendentDisplayName
                );
            }
            
            if (descendentDescription is not null)
            {
                yield return new TranslatableXmlElement(
                    id: GenerateIdForDisplayNameOrDescription(descendentDescription),
                    source: descendentDescription.Value,
                    note: GetComment(descendentDescription, XmlName(descendentDescription)),
                    element: descendentDescription
                );
            }
            
            var localizableProperties = element.Attribute(XName.Get(LocalizedPropertiesAttributeName, XliffTasksNs))?.Value?.Split(';');

            if (localizableProperties is not null)
            {
                // we could have any number of descendent localizable properties
                foreach (var localizableProperty in localizableProperties)
                {
                    if (element.Elements(XName.Get($"{element.Name.LocalName}.{localizableProperty}", element.Name.NamespaceName)).FirstOrDefault() is { } descendentValue)
                    {
                        yield return new TranslatableXmlElement(
                            id: GenerateIdForPropertyMetadata(descendentValue),
                            source: descendentValue.Value,
                            note: GetComment(descendentValue, localizableProperty),
                            element: descendentValue);
                    }
                }
            }

            foreach (XAttribute? attribute in element.Attributes())
            {
                if ((descendentDisplayName is null && XmlName(attribute) == "DisplayName")
                    || (descendentDescription is null && XmlName(attribute) == "Description"))
                {
                    yield return new TranslatableXmlAttribute(
                        id: GenerateIdForDisplayNameOrDescription(attribute),
                        source: attribute.Value,
                        note: GetComment(element, XmlName(attribute)),
                        attribute: attribute);
                }
                else if (AttributedName(element) == "SearchTerms" && (XmlName(attribute) == "Value" || element.Elements(XName.Get($"{element.Name.LocalName}.Value", element.Name.NamespaceName)).FirstOrDefault() is { }))
                {
                    if (XmlName(attribute) == "Value")
                    {
                        yield return new TranslatableXmlAttribute(
                            id: GenerateIdForPropertyMetadata(element),
                            source: attribute.Value,
                            note: GetComment(element, XmlName(attribute)),
                            attribute: attribute);
                    }
                    // else if we have a descendent in the form of {elementLocalName}.Value, we should translate that descendent
                    else if (element.Elements(XName.Get($"{element.Name.LocalName}.Value", element.Name.NamespaceName)).FirstOrDefault() is { } descendentValue)
                    {
                        yield return new TranslatableXmlElement(
                            id: GenerateIdForPropertyMetadata(element),
                            source: descendentValue.Value,
                            note: GetComment(descendentValue, XmlName(attribute)),
                            element: descendentValue);
                    }
                }
                else
                {
                    if (localizableProperties is null)
                    {
                        continue;
                    }
                    
                    // if the property value is directly specified as an attribute
                    if (localizableProperties.Contains(attribute.Name.LocalName))
                    {
                        yield return new TranslatableXmlAttribute(
                            id: GenerateIdForPropertyMetadata(element, attribute),
                            source: attribute.Value,
                            note: GetComment(element, XmlName(attribute)),
                            attribute: attribute);
                    }
                }
            }
        }
    }

    private static string GenerateIdForDisplayNameOrDescription(XObject xObject)
    {
        var parent = xObject.Parent;
        if (parent is null)
        {
            throw new ArgumentException("Attribute must have a parent element", nameof(xObject));
        }

        if (XmlName(parent) == "EnumValue")
        {
            var grandparent = parent.Parent;
            if (grandparent is null)
            {
                throw new ArgumentException("Attribute must have a grandparent element", nameof(xObject));
            }
            
            return $"{XmlName(parent)}|{AttributedName(grandparent)}.{AttributedName(parent)}|{XmlName(xObject)}";
        }

        return $"{XmlName(parent)}|{AttributedName(parent)}|{XmlName(xObject)}";
    }

    private static string GenerateIdForPropertyMetadata(XElement element, XAttribute? attribute = null)
    {
        var ancestorWithNameAttributeCandidate = element.Parent?.Parent; // start at grandparent
        var idBuilder = new StringBuilder();

        // if has no grandparent, we'll try parent
        if (ancestorWithNameAttributeCandidate is null)
        {
            if (element.Parent is not null)
            {
                idBuilder.Append(element.Parent.Attribute("Name") is null ? XmlName(element.Parent) : $"{XmlName(element.Parent)}|{AttributedName(element.Parent)}");
                idBuilder.Append("|Metadata|");
            }

            idBuilder.Append(XmlName(element));
            if (element.Attribute("Name") is null)
            {
                idBuilder.Append($"|{AttributedName(element)}");
            }
            
            if (attribute is not null)
            {
                idBuilder.Append($"|{XmlName(attribute)}");
            }

            return idBuilder.ToString();
        }

        // while the current ancestor has a parent and does not have a name, append its XmlName to the id and go up a level  
        while (ancestorWithNameAttributeCandidate?.Attribute("Name") is null && ancestorWithNameAttributeCandidate?.Parent is not null) {
        {
            idBuilder.Insert(0, $"{XmlName(ancestorWithNameAttributeCandidate)}|");
            ancestorWithNameAttributeCandidate = ancestorWithNameAttributeCandidate.Parent;
        }}

        idBuilder.Insert(0, $"{XmlName(ancestorWithNameAttributeCandidate!)}|{AttributedName(ancestorWithNameAttributeCandidate!)}|");

        idBuilder.Append($"Metadata|");
        idBuilder.Append(element.Attribute("Name") is not null ? AttributedName(element) : XmlName(element));

        if (attribute is not null)
        {
            idBuilder.Append($"|{attribute.Name.LocalName}");
        }


        return idBuilder.ToString();
    }

    private static string? GetComment(XElement element, string attributeName)
    {
        foreach (XComment comment in element.Nodes().OfType<XComment>())
        {
            foreach (string? line in comment.Value.Split(new[] { '\n' }, System.StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()))
            {
                if (line.StartsWith(attributeName))
                {
                    return line.Substring(attributeName.Length).Trim(s_attrValueTrimChars);
                }
            }
        }

        return null;
    }

    private static string XmlName(XObject container) => container is XElement element ? XmlName(element) : XmlName((XAttribute)container);
    private static string XmlName(XElement element)
    {
        var localName = element.Name.LocalName;
        // if we have a descendent element, we should only take the last part of the name after the dot
        return localName.Contains('.') ? localName.Split('.').Last() : localName;
    }

    private static string XmlName(XAttribute attribute) => attribute.Name.LocalName;

    private static string? AttributedName(XElement element) => element.Attribute("Name")?.Value;
}