Program.cs

using System.Text;

namespace XyFavMenu;

internal static class Program
{
    private static string GetVersion() =>
        typeof(Program).Assembly.GetName().Version?.ToString(3) ?? "?";

    private static int Main(string[] args)
    {
        if (args.Length == 1 && (args[0] == "--version" || args[0] == "-v"))
        {
            Console.WriteLine(GetVersion());
            return 0;
        }

        if (args.Length == 0 || args.Length == 1 && (args[0] == "--help" || args[0] == "-h" || args[0] == "/?"))
        {
            Console.WriteLine($"XyFavMenu v{GetVersion()}");
            Console.WriteLine(Options.UsageText);
            return 0;
        }

        try
        {
            var options = Options.Parse(args);
            var outputDirectory = options.CheckOnly
                ? null
                : Path.GetDirectoryName(Path.GetFullPath(options.OutputPath!));
            var folderIconConfig = FolderIconConfig.Load(outputDirectory);
            var loader = new FavoritesLoader();
            var directoryLoad = loader.Load(options.DirectoryFavoritesPath, FavoriteKind.Directory);
            var fileLoad = loader.Load(options.FileFavoritesPath, FavoriteKind.File);
            var problems = directoryLoad.Problems
                .Concat(fileLoad.Problems)
                .ToList();

            var items = directoryLoad.Items
                .Concat(fileLoad.Items)
                .ToList();

            var builder = new MenuBuilder();
            var buildResult = builder.Build(items, folderIconConfig);
            var root = buildResult.Root;

            var outputProblems = GeneratedMenuValidator.RemoveInvalidGotoTargets(root);
            if (outputProblems.Count > 0)
            {
                problems.AddRange(outputProblems);
            }

            ShowWarnings(buildResult.Warnings);
            ShowProblems(problems);

            if (options.CheckOnly)
            {
                var ok = problems.Count == 0;
                Console.WriteLine(ok ? "Check passed." : "Check failed.");
                return ok ? 0 : 1;
            }

            var renderer = new XyMenuRenderer();
            var output = renderer.Render(root);
            var linkedElements = LinkedElementExporter.Export(root);

            if (!string.IsNullOrEmpty(outputDirectory))
            {
                Directory.CreateDirectory(outputDirectory);
            }

            File.WriteAllText(options.OutputPath!, output, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
            File.WriteAllText(
                GetItemsOutputPath(options.OutputPath!),
                linkedElements,
                new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));

            Console.WriteLine($"Wrote {items.Count} source items to '{options.OutputPath}'.");
            return 0;
        }
        catch (UsageException ex)
        {
            Console.Error.WriteLine(ex.Message);
            Console.Error.WriteLine();
            Console.Error.WriteLine(Options.UsageText);
            return 2;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine(ex.Message);
            return 1;
        }
    }

    private static string GetItemsOutputPath(string outputPath)
    {
        var directory = Path.GetDirectoryName(outputPath);
        var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(outputPath);
        return Path.Combine(directory ?? string.Empty, fileNameWithoutExtension + "-items.txt");
    }

    private static void ShowWarnings(IReadOnlyList<string> warnings)
    {
        foreach (var warning in warnings)
        {
            Console.Error.WriteLine($"Warning: {warning}");
        }
    }

    private static void ShowProblems(IReadOnlyList<string> problems)
    {
        if (problems.Count == 0)
        {
            return;
        }

        Console.Error.WriteLine("Missing targets were skipped:");
        foreach (var problem in problems)
        {
            Console.Error.WriteLine($"  {problem}");
        }
    }
}

internal sealed record Options(
    string DirectoryFavoritesPath,
    string FileFavoritesPath,
    string? OutputPath,
    bool CheckOnly = false)
{
    public const string UsageText =
        """
        Usage:
          XyFavMenu <dir-fav> <file-fav> <output>     Generate menu files
          XyFavMenu --check <dir-fav> <file-fav>       Validate only, no output written
          XyFavMenu --version                          Print version
          XyFavMenu --help                             Show this help
        """;

    public static Options Parse(IReadOnlyList<string> args)
    {
        if (args.Count == 3 && !args[0].StartsWith("--", StringComparison.Ordinal))
        {
            return new Options(args[0], args[1], args[2]);
        }

        if (args.Count == 3 && string.Equals(args[0], "--check", StringComparison.OrdinalIgnoreCase))
        {
            return new Options(args[1], args[2], null, CheckOnly: true);
        }

        throw new UsageException("Invalid arguments.");
    }
}

internal sealed class UsageException : Exception
{
    public UsageException(string message) : base(message)
    {
    }
}

internal enum FavoriteKind
{
    Directory,
    File
}

internal abstract record SourceItem(FavoriteKind Kind, int LineNumber);

internal sealed record SeparatorItem(FavoriteKind Kind, int LineNumber) : SourceItem(Kind, LineNumber);

internal sealed record FavoriteItem(
    FavoriteKind Kind,
    int LineNumber,
    string TargetPath,
    IReadOnlyList<TitleElement> Titles) : SourceItem(Kind, LineNumber);

internal sealed record AdditionalMenuItem(
    FavoriteKind Kind,
    int LineNumber,
    int Depth,
    string Text,
    string? Command,
    string? IconPath) : SourceItem(Kind, LineNumber);

internal sealed record TitleElement(string MenuPath, string? IconPath);

internal sealed record LoadResult(IReadOnlyList<SourceItem> Items, IReadOnlyList<string> Problems);

internal sealed class FavoritesLoader
{
    public LoadResult Load(string path, FavoriteKind kind)
    {
        if (!File.Exists(path))
        {
            throw new FileNotFoundException($"Input file not found: {path}", path);
        }

        var items = new List<SourceItem>();
        var problems = new List<string>();
        var lines = File.ReadAllLines(path);
        var inMoreBlock = false;
        int? moreBaseDepth = null;

        for (var i = 0; i < lines.Length; i++)
        {
            var lineNumber = i + 1;
            var rawLine = lines[i];
            var trimmed = rawLine.Trim();

            if (trimmed.Length == 0)
            {
                continue;
            }

            if (!inMoreBlock && string.Equals(trimmed, "more", StringComparison.OrdinalIgnoreCase))
            {
                inMoreBlock = true;
                moreBaseDepth = null;
                continue;
            }

            if (inMoreBlock)
            {
                var additional = ParseAdditionalMenuLine(kind, lineNumber, rawLine, ref moreBaseDepth);
                if (TryValidate(path, additional, out var additionalProblem))
                {
                    items.Add(additional);
                }
                else if (additionalProblem is not null)
                {
                    problems.Add(additionalProblem);
                }

                continue;
            }

            if (trimmed == "-")
            {
                items.Add(new SeparatorItem(kind, lineNumber));
                continue;
            }

            var favorite = ParseFavoriteLine(kind, lineNumber, trimmed);
            if (TryValidate(path, favorite, out var favoriteProblem))
            {
                items.Add(favorite);
            }
            else if (favoriteProblem is not null)
            {
                problems.Add(favoriteProblem);
            }
        }

        return new LoadResult(items, problems);
    }

    private static bool TryValidate(string sourcePath, SourceItem item, out string? problem)
    {
        problem = null;

        switch (item)
        {
            case FavoriteItem favorite:
                return TryValidateTargetPath(sourcePath, favorite.LineNumber, favorite.TargetPath, out problem);
            case AdditionalMenuItem additional when TryExtractGotoPath(additional.Command, out var targetPath):
                return TryValidateTargetPath(sourcePath, additional.LineNumber, targetPath, out problem);
            default:
                return true;
        }
    }

    private static bool TryValidateTargetPath(string sourcePath, int lineNumber, string targetPath, out string? problem)
    {
        if (Directory.Exists(targetPath) || File.Exists(targetPath))
        {
            problem = null;
            return true;
        }

        problem = $"{Path.GetFileName(sourcePath)}:{lineNumber}: {targetPath}";
        return false;
    }

    private static bool TryExtractGotoPath(string? command, out string path)
    {
        path = string.Empty;
        if (string.IsNullOrWhiteSpace(command))
        {
            return false;
        }

        var trimmed = command.Trim();
        if (!(trimmed.StartsWith(":goto ", StringComparison.OrdinalIgnoreCase)
            || trimmed.StartsWith("goto ", StringComparison.OrdinalIgnoreCase)))
        {
            return false;
        }

        var firstQuote = trimmed.IndexOf('"');
        if (firstQuote >= 0)
        {
            var secondQuote = trimmed.IndexOf('"', firstQuote + 1);
            if (secondQuote > firstQuote)
            {
                path = trimmed[(firstQuote + 1)..secondQuote];
                return path.Length > 0;
            }
        }

        var parts = trimmed.Split(' ', 2, StringSplitOptions.RemoveEmptyEntries);
        if (parts.Length != 2)
        {
            return false;
        }

        path = parts[1].Trim();
        return path.Length > 0;
    }

    private static FavoriteItem ParseFavoriteLine(FavoriteKind kind, int lineNumber, string line)
    {
        string? rawTitle = null;
        string targetPath;

        if (line[0] == '"')
        {
            var closingQuoteIndex = line.IndexOf('"', 1);
            if (closingQuoteIndex < 0)
            {
                throw new FormatException($"Line {lineNumber}: missing closing quote.");
            }

            rawTitle = line[1..closingQuoteIndex];
            targetPath = line[(closingQuoteIndex + 1)..].Trim();

            if (targetPath.Length == 0)
            {
                targetPath = rawTitle;
                rawTitle = null;
            }
        }
        else
        {
            if (LooksLikeBarePath(line))
            {
                targetPath = line;
            }
            else
            {
                var splitIndex = FindUnquotedWhitespace(line);
                if (splitIndex < 0)
                {
                    targetPath = line;
                }
                else
                {
                    rawTitle = line[..splitIndex].Trim();
                    targetPath = line[splitIndex..].Trim();
                }
            }
        }

        if (string.IsNullOrWhiteSpace(targetPath))
        {
            throw new FormatException($"Line {lineNumber}: missing target path.");
        }

        targetPath = ResolvePathVariables(targetPath);
        targetPath = NormalizeTargetPath(kind, targetPath);
        var titles = ParseTitleElements(rawTitle, targetPath);
        return new FavoriteItem(kind, lineNumber, targetPath, titles);
    }

    private static string NormalizeTargetPath(FavoriteKind kind, string path)
    {
        if (kind == FavoriteKind.Directory && !path.EndsWith('\\') && !path.EndsWith('/'))
        {
            return path + '\\';
        }

        if (kind == FavoriteKind.File)
        {
            return path.TrimEnd('\\', '/');
        }

        return path;
    }

    private static bool LooksLikeBarePath(string line)
    {
        if (line.Length >= 3 && char.IsLetter(line[0]) && line[1] == ':' && (line[2] == '\\' || line[2] == '/'))
        {
            return true;
        }

        if (line.StartsWith(@"\\", StringComparison.Ordinal))
        {
            return true;
        }

        if (line.StartsWith('%') && line.LastIndexOf('%') > 0)
        {
            return true;
        }

        return false;
    }

    private static AdditionalMenuItem ParseAdditionalMenuLine(FavoriteKind kind, int lineNumber, string rawLine, ref int? baseDepth)
    {
        var indentCount = rawLine.TakeWhile(ch => ch == ' ').Count();
        if (indentCount % 2 != 0)
        {
            throw new FormatException($"Line {lineNumber}: additional menu indentation must use multiples of 2 spaces.");
        }

        var absoluteDepth = indentCount / 2;
        baseDepth ??= absoluteDepth;

        if (absoluteDepth < baseDepth.Value)
        {
            throw new FormatException($"Line {lineNumber}: additional menu indentation moved above the block base level.");
        }

        var depth = absoluteDepth - baseDepth.Value;
        var content = rawLine[indentCount..].TrimEnd();
        var parts = SplitAdditionalMenuParts(content);

        if (parts.Count < 2 || parts.Count > 3)
        {
            throw new FormatException($"Line {lineNumber}: invalid additional menu entry.");
        }

        var text = parts[0].Trim();
        var command = parts[1].Trim();
        var iconPath = parts.Count == 3 ? parts[2].Trim() : string.Empty;

        if (text.Length == 0)
        {
            throw new FormatException($"Line {lineNumber}: additional menu text is empty.");
        }

        return new AdditionalMenuItem(
            kind,
            lineNumber,
            depth,
            text,
            command.Length == 0 ? null : NormalizeAdditionalCommand(command),
            iconPath.Length == 0 ? null : ResolvePathVariables(iconPath));
    }

    private static string NormalizeAdditionalCommand(string command)
    {
        return command
            .Replace(";", ",")
            .Replace("|", ",");
    }
    private static List<string> SplitAdditionalMenuParts(string content)
    {
        var parts = new List<string>();
        var current = new StringBuilder();
        var inQuotes = false;

        foreach (var ch in content)
        {
            if (ch == '"')
            {
                inQuotes = !inQuotes;
                current.Append(ch);
                continue;
            }

            if (ch == '|' && !inQuotes && parts.Count < 2)
            {
                parts.Add(current.ToString());
                current.Clear();
                continue;
            }

            current.Append(ch);
        }

        parts.Add(current.ToString());
        return parts;
    }

    private static IReadOnlyList<TitleElement> ParseTitleElements(string? rawTitle, string targetPath)
    {
        if (string.IsNullOrWhiteSpace(rawTitle))
        {
            return new[] { new TitleElement(targetPath, null) };
        }

        var elements = rawTitle
            .Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
            .Select(ParseTitleElement)
            .ToList();

        if (elements.Count == 0)
        {
            elements.Add(new TitleElement(targetPath, null));
        }

        return elements;
    }

    private static TitleElement ParseTitleElement(string rawElement)
    {
        var separatorIndex = rawElement.IndexOf('|');
        if (separatorIndex < 0)
        {
            return new TitleElement(rawElement, null);
        }

        var menuPath = rawElement[..separatorIndex].Trim();
        var iconPath = ResolvePathVariables(rawElement[(separatorIndex + 1)..].Trim());

        return new TitleElement(menuPath, iconPath.Length == 0 ? null : iconPath);
    }

    private static string ResolvePathVariables(string path)
    {
        if (string.IsNullOrWhiteSpace(path))
        {
            return path;
        }

        return Environment.ExpandEnvironmentVariables(path);
    }

    private static int FindUnquotedWhitespace(string line)
    {
        for (var i = 0; i < line.Length; i++)
        {
            if (char.IsWhiteSpace(line[i]))
            {
                return i;
            }
        }

        return -1;
    }
}

internal sealed record BuildResult(MenuNode Root, IReadOnlyList<string> Warnings);

internal sealed class MenuBuilder
{
    public BuildResult Build(IEnumerable<SourceItem> items, FolderIconConfig folderIconConfig)
    {
        var warnings = new List<string>();
        var root = new MenuNode(string.Empty, null);
        var additionalStack = new Stack<MenuNode>();
        var pathEntries = new Dictionary<string, PathEntry>(StringComparer.OrdinalIgnoreCase);
        additionalStack.Push(root);

        foreach (var item in items)
        {
            switch (item)
            {
                case SeparatorItem:
                    root.Children.Add(new SeparatorNode());
                    additionalStack.Clear();
                    additionalStack.Push(root);
                    break;
                case FavoriteItem favorite:
                    AddPathEntry(pathEntries, favorite.TargetPath, $":goto {Quote(favorite.TargetPath)}", favorite.Titles.Select(title => title.IconPath).FirstOrDefault(icon => !string.IsNullOrWhiteSpace(icon)));
                    foreach (var title in favorite.Titles)
                    {
                        AddFavorite(root, favorite, title, warnings);
                    }

                    additionalStack.Clear();
                    additionalStack.Push(root);
                    break;
                case AdditionalMenuItem additional:
                    if (additional.Command is not null && TryExtractGotoPath(additional.Command, out var additionalPath))
                    {
                        AddPathEntry(pathEntries, additionalPath, additional.Command, additional.IconPath);
                    }

                    AddAdditional(additionalStack, additional);
                    break;
            }
        }

        CollapseSingleChildMenusRecursive(root, isRoot: true);
        SortChildrenRecursive(root);

        var pathChildren = BuildPathChildren(pathEntries);
        if (pathChildren.Count > 0)
        {
            root.Children.RemoveAll(child => child is not MenuNode);
            root.Children.Add(new SeparatorNode());
            root.Children.AddRange(pathChildren);
        }

        ApplyMenuIconsRecursive(root, folderIconConfig);
        return new BuildResult(root, warnings);
    }

    private static void AddFavorite(MenuNode root, FavoriteItem favorite, TitleElement title, List<string> warnings)
    {
        var segments = title.MenuPath
            .Split('>', StringSplitOptions.TrimEntries)
            .Where(segment => segment.Length > 0)
            .ToArray();

        if (segments.Length == 0)
        {
            segments = new[] { favorite.TargetPath };
        }

        var current = root;
        for (var i = 0; i < segments.Length - 1; i++)
        {
            current = current.GetOrAddMenu(segments[i]);
        }

        var label = segments[^1];
        if (current.Children.OfType<CommandNode>().Any(c => string.Equals(c.Text, label, StringComparison.OrdinalIgnoreCase)))
        {
            var menuPath = string.Join(" > ", segments).Replace("&", "");
            warnings.Add($"Duplicate menu entry: \"{menuPath}\"");
        }

        current.Children.Add(new CommandNode(label, title.IconPath, $":goto {Quote(favorite.TargetPath)}"));
    }

    private static void AddAdditional(Stack<MenuNode> stack, AdditionalMenuItem item)
    {
        while (stack.Count > item.Depth + 1)
        {
            stack.Pop();
        }

        if (stack.Count != item.Depth + 1)
        {
            throw new FormatException($"Line {item.LineNumber}: invalid nesting in additional menu block.");
        }

        var parent = stack.Peek();
        var segments = SplitMenuPath(item.Text);
        if (segments.Length == 0)
        {
            throw new FormatException($"Line {item.LineNumber}: additional menu text is empty.");
        }

        if (item.Command is null)
        {
            for (var i = 0; i < segments.Length - 1; i++)
            {
                parent = parent.GetOrAddMenu(segments[i]);
            }

            var menu = parent.GetOrAddMenu(segments[^1], item.IconPath);
            stack.Push(menu);
            return;
        }

        for (var i = 0; i < segments.Length - 1; i++)
        {
            parent = parent.GetOrAddMenu(segments[i]);
        }

        parent.Children.Add(new CommandNode(segments[^1], item.IconPath, item.Command));
    }

    private static void CollapseSingleChildMenusRecursive(MenuNode menu, bool isRoot)
    {
        for (var i = 0; i < menu.Children.Count; i++)
        {
            if (menu.Children[i] is not MenuNode childMenu)
            {
                continue;
            }

            CollapseSingleChildMenusRecursive(childMenu, isRoot: false);
            menu.Children[i] = CollapseSingleChildMenu(childMenu, parentIsRoot: isRoot);
        }
    }

    private static MenuChild CollapseSingleChildMenu(MenuNode menu, bool parentIsRoot)
    {
        if (parentIsRoot)
        {
            return menu;
        }

        if (menu.Children.Count != 1)
        {
            return menu;
        }

        return menu.Children[0] switch
        {
            CommandNode command => new CommandNode($"{menu.Text} > {command.Text}", command.IconPath, command.Command),
            MenuNode childMenu => CreateMergedMenu(menu, childMenu),
            _ => menu
        };
    }

    private static MenuNode CreateMergedMenu(MenuNode parent, MenuNode child)
    {
        var merged = new MenuNode($"{parent.Text} > {child.Text}", child.IconPath ?? parent.IconPath);
        foreach (var grandChild in child.Children)
        {
            merged.Children.Add(grandChild);
        }

        return merged;
    }
    private static void SortChildrenRecursive(MenuNode menu)
    {
        foreach (var childMenu in menu.Children.OfType<MenuNode>())
        {
            SortChildrenRecursive(childMenu);
        }

        var orderedChildren = menu.Children
            .OrderBy(GetSortRank)
            .ThenBy(GetSortText, StringComparer.OrdinalIgnoreCase)
            .ToList();

        menu.Children.Clear();
        menu.Children.AddRange(orderedChildren);
    }

    private static void AddPathEntry(Dictionary<string, PathEntry> entries, string path, string command, string? iconPath)
    {
        if (!entries.ContainsKey(path))
        {
            entries.Add(path, new PathEntry(path, command, iconPath));
        }
    }

    private static List<MenuChild> BuildPathChildren(Dictionary<string, PathEntry> entries)
    {
        if (entries.Count == 0)
        {
            return [];
        }

        var pathRoot = new PathNode(string.Empty);
        foreach (var entry in entries.Values)
        {
            AddPathEntry(pathRoot, entry);
        }

        return pathRoot.Children.Values
            .Select(BuildPathChild)
            .OrderBy(GetSortText, StringComparer.OrdinalIgnoreCase)
            .ThenBy(GetSortRank)
            .ToList();
    }

    private static bool TryExtractGotoPath(string command, out string path)
    {
        path = string.Empty;

        var trimmed = command.Trim();
        if (!(trimmed.StartsWith(":goto ", StringComparison.OrdinalIgnoreCase)
            || trimmed.StartsWith("goto ", StringComparison.OrdinalIgnoreCase)))
        {
            return false;
        }

        var firstQuote = trimmed.IndexOf('"');
        var lastQuote = trimmed.LastIndexOf('"');
        if (firstQuote < 0 || lastQuote <= firstQuote)
        {
            return false;
        }

        path = trimmed[(firstQuote + 1)..lastQuote];
        return path.Length > 0;
    }

    private static void AddPathEntry(PathNode root, PathEntry entry)
    {
        var segments = SplitFilesystemPath(entry.Path);
        if (segments.Length == 0)
        {
            return;
        }

        var current = root;
        foreach (var segment in segments)
        {
            current = current.GetOrAddChild(segment);
        }

        current.Command = entry.Command;
        current.IconPath = entry.IconPath;
    }

    private static string[] SplitFilesystemPath(string path)
    {
        if (path.StartsWith(@"\\", StringComparison.Ordinal))
        {
            var trimmed = path.TrimEnd('\\');
            var parts = trimmed.Split('\\', StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length < 2)
            {
                return new[] { path };
            }

            var segments = new List<string> { $@"\\{parts[0]}\{parts[1]}" };
            segments.AddRange(parts.Skip(2));
            return segments.ToArray();
        }

        if (path.Length >= 3 && char.IsLetter(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
        {
            var trimmed = path.TrimEnd('\\', '/');
            var segments = new List<string> { path[..3] };
            if (trimmed.Length > 3)
            {
                segments.AddRange(trimmed[3..].Split(['\\', '/'], StringSplitOptions.RemoveEmptyEntries));
            }

            return segments.ToArray();
        }

        return new[] { path };
    }

    private static void ApplyMenuIconsRecursive(MenuNode menu, FolderIconConfig folderIconConfig)
    {
        foreach (var childMenu in menu.Children.OfType<MenuNode>())
        {
            ApplyMenuIconsRecursive(childMenu, folderIconConfig);
        }

        if (string.IsNullOrWhiteSpace(menu.Text) || !string.IsNullOrWhiteSpace(menu.IconPath))
        {
            return;
        }

        menu.IconPath = DetermineMenuIcon(menu, folderIconConfig);
    }

    private static string? DetermineMenuIcon(MenuNode menu, FolderIconConfig folderIconConfig)
    {
        var overrideIcon = folderIconConfig.FindOverride(menu.Text);
        if (!string.IsNullOrWhiteSpace(overrideIcon))
        {
            return overrideIcon;
        }

        var directSelfIcon = menu.Children
            .OfType<CommandNode>()
            .FirstOrDefault(child => string.Equals(NormalizeLookupKey(child.Text), NormalizeLookupKey(menu.Text), StringComparison.OrdinalIgnoreCase))
            ?.IconPath;

        if (!string.IsNullOrWhiteSpace(directSelfIcon))
        {
            return directSelfIcon;
        }

        var childIcons = menu.Children
            .Select(child => child switch
            {
                MenuNode childMenu => childMenu.IconPath,
                CommandNode command => command.IconPath,
                _ => null
            })
            .Where(icon => !string.IsNullOrWhiteSpace(icon))
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList();

        if (childIcons.Count == 1)
        {
            return childIcons[0];
        }

        return folderIconConfig.FallbackIconPath;
    }

    private static MenuChild BuildPathChild(PathNode node)
    {
        var label = node.Segment;
        var current = node;

        while (current.Command is null && current.Children.Count == 1)
        {
            current = current.Children.Values.Single();
            label = CombinePathLabel(label, current.Segment);
        }

        if (current.Command is not null && current.Children.Count == 0)
        {
            return new CommandNode(label, current.IconPath, current.Command);
        }

        var menu = new MenuNode(label, current.IconPath);
        if (current.Command is not null)
        {
            menu.Children.Add(new CommandNode(label, current.IconPath, current.Command));
        }

        foreach (var child in current.Children.Values
            .Select(BuildPathChild)
            .OrderBy(GetSortText, StringComparer.OrdinalIgnoreCase)
            .ThenBy(GetSortRank))
        {
            menu.Children.Add(child);
        }

        return menu;
    }

    private static string CombinePathLabel(string left, string right)
    {
        if (left.EndsWith('\\') || left.EndsWith('/'))
        {
            return left + right;
        }

        return left + @"\" + right;
    }

    private static int GetSortRank(MenuChild child) => child switch
    {
        MenuNode => 0,
        CommandNode command when !LooksLikePathText(command.Text) => 1,
        CommandNode => 2,
        SeparatorNode => 3,
        _ => 4
    };

    private static string GetSortText(MenuChild child) => child switch
    {
        MenuNode menu => NormalizeSortText(menu.Text),
        CommandNode command => NormalizeSortText(command.Text),
        _ => string.Empty
    };

    private static string NormalizeSortText(string text)
    {
        var normalized = text
            .Replace("&", string.Empty)
            .Replace("Ä", "Ae", StringComparison.Ordinal)
            .Replace("Ö", "Oe", StringComparison.Ordinal)
            .Replace("Ü", "Ue", StringComparison.Ordinal)
            .Replace("ä", "ae", StringComparison.Ordinal)
            .Replace("ö", "oe", StringComparison.Ordinal)
            .Replace("ü", "ue", StringComparison.Ordinal)
            .Replace("ß", "ss", StringComparison.Ordinal);

        return new string(normalized.Where(char.IsLetterOrDigit).ToArray());
    }

    private static string NormalizeLookupKey(string text)
    {
        return NormalizeSortText(text)
            .Replace(">", @"\", StringComparison.Ordinal)
            .Replace("/", @"\", StringComparison.Ordinal);
    }

    private static bool LooksLikePathText(string text)
    {
        if (text.Length >= 3 && char.IsLetter(text[0]) && text[1] == ':' && (text[2] == '\\' || text[2] == '/'))
        {
            return true;
        }

        if (text.StartsWith(@"\\", StringComparison.Ordinal))
        {
            return true;
        }

        if (text.StartsWith('%') && text.LastIndexOf('%') > 0)
        {
            return true;
        }

        return false;
    }

    private static string[] SplitMenuPath(string menuPath)
    {
        return menuPath
            .Split('>' , StringSplitOptions.TrimEntries)
            .Where(segment => segment.Length > 0)
            .ToArray();
    }

    private static string Quote(string value) => $"\"{value}\"";

    private sealed class PathNode(string segment)
    {
        public string Segment { get; } = segment;

        public string? Command { get; set; }

        public string? IconPath { get; set; }

        public Dictionary<string, PathNode> Children { get; } = new(StringComparer.OrdinalIgnoreCase);

        public PathNode GetOrAddChild(string segment)
        {
            if (!Children.TryGetValue(segment, out var child))
            {
                child = new PathNode(segment);
                Children.Add(segment, child);
            }

            return child;
        }
    }

    private sealed record PathEntry(string Path, string Command, string? IconPath);
}

internal abstract record MenuChild;

internal sealed record SeparatorNode() : MenuChild;

internal sealed record CommandNode(string Text, string? IconPath, string Command) : MenuChild;

internal sealed record MenuNode : MenuChild
{
    public MenuNode(string text, string? iconPath)
    {
        Text = text;
        IconPath = iconPath;
    }

    public string Text { get; }

    public string? IconPath { get; set; }

    public List<MenuChild> Children { get; } = new();

    public MenuNode GetOrAddMenu(string text, string? iconPath = null)
    {
        foreach (var child in Children)
        {
            if (child is MenuNode menu && string.Equals(menu.Text, text, StringComparison.Ordinal))
            {
                return menu;
            }
        }

        var created = new MenuNode(text, iconPath);
        Children.Add(created);
        return created;
    }

}

internal sealed class FolderIconConfig
{
    private FolderIconConfig(Dictionary<string, string> overrides, string? fallbackIconPath)
    {
        Overrides = overrides;
        FallbackIconPath = fallbackIconPath;
    }

    public Dictionary<string, string> Overrides { get; }

    public string? FallbackIconPath { get; }

    public static FolderIconConfig Load(string? outputDirectory)
    {
        if (string.IsNullOrWhiteSpace(outputDirectory))
        {
            return new FolderIconConfig(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), null);
        }

        var path = Path.Combine(outputDirectory, "folder-icons.txt");
        if (!File.Exists(path))
        {
            return new FolderIconConfig(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), null);
        }

        var overrides = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        string? fallback = null;

        foreach (var rawLine in File.ReadAllLines(path))
        {
            var line = rawLine.Trim();
            if (line.Length == 0 || line.StartsWith('#'))
            {
                continue;
            }

            var separatorIndex = line.IndexOf(':');
            if (separatorIndex <= 0)
            {
                continue;
            }

            var key = NormalizeKey(line[..separatorIndex]);
            var rawValue = line[(separatorIndex + 1)..].Trim();
            var iconPath = Environment.ExpandEnvironmentVariables(rawValue);
            if (key.Length == 0)
            {
                continue;
            }

            if (string.Equals(key, "fallback", StringComparison.OrdinalIgnoreCase))
            {
                fallback = iconPath;
            }
            else if (iconPath.Length > 0)
            {
                overrides[key] = iconPath;
            }
        }

        return new FolderIconConfig(overrides, fallback);
    }

    public string? FindOverride(string menuText)
    {
        var normalized = NormalizeKey(menuText);
        if (normalized.Length == 0)
        {
            return null;
        }

        if (Overrides.TryGetValue(normalized, out var exactMatch))
        {
            return exactMatch;
        }

        foreach (var segment in normalized.Split(['\\', '>'], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
        {
            if (Overrides.TryGetValue(segment, out var segmentMatch))
            {
                return segmentMatch;
            }
        }

        foreach (var overrideEntry in Overrides.OrderByDescending(entry => entry.Key.Length))
        {
            if (normalized.Contains(overrideEntry.Key, StringComparison.OrdinalIgnoreCase))
            {
                return overrideEntry.Value;
            }
        }

        return null;
    }

    private static string NormalizeKey(string key)
    {
        return key
            .Replace("&", string.Empty)
            .Replace("/", @"\")
            .Trim();
    }
}

internal sealed class XyMenuRenderer
{
    public string Render(MenuNode root)
    {
        var lines = new List<string>();

        foreach (var child in root.Children)
        {
            RenderChild(lines, child, depth: 0);
        }

        lines = CollapseDuplicateSeparators(lines);
        return string.Join(Environment.NewLine, lines) + Environment.NewLine;
    }

    private static List<string> CollapseDuplicateSeparators(List<string> lines)
    {
        var result = new List<string>(lines.Count);
        var previousWasSeparator = false;

        foreach (var line in lines)
        {
            var isSeparator = string.Equals(line.Trim(), "-", StringComparison.Ordinal);
            if (isSeparator && previousWasSeparator)
            {
                continue;
            }

            result.Add(line);
            previousWasSeparator = isSeparator;
        }

        return result;
    }

    private static void RenderChild(List<string> lines, MenuChild child, int depth)
    {
        var indent = new string(' ', depth * 4);

        switch (child)
        {
            case SeparatorNode:
                lines.Add($"{indent}-");
                break;
            case CommandNode command:
                lines.Add($"{indent}{command.Text};{command.Command};{command.IconPath ?? string.Empty}");
                break;
            case MenuNode menu:
                lines.Add($"{indent}{menu.Text};;{menu.IconPath ?? string.Empty}");
                foreach (var nestedChild in menu.Children)
                {
                    RenderChild(lines, nestedChild, depth + 1);
                }
                break;
        }
    }
}

internal static class LinkedElementExporter
{
    public static string Export(MenuNode root)
    {
        var entries = new List<LinkedElementEntry>();
        Collect(root, entries);

        var seenPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        var lines = entries
            .Where(entry => seenPaths.Add(entry.ElementPath))
            .OrderBy(entry => NormalizeLinkedElementSortText(entry.Title), StringComparer.OrdinalIgnoreCase)
            .ThenBy(entry => entry.ElementPath, StringComparer.OrdinalIgnoreCase)
            .ThenBy(entry => entry.IconPath, StringComparer.OrdinalIgnoreCase)
            .Select(entry => $"{entry.Title}|{entry.ElementPath}|{entry.IconPath}")
            .ToList();

        return string.Join(Environment.NewLine, lines) + Environment.NewLine;
    }

    private static void Collect(MenuNode menu, List<LinkedElementEntry> entries)
    {
        foreach (var child in menu.Children)
        {
            switch (child)
            {
                case MenuNode childMenu:
                    Collect(childMenu, entries);
                    break;
                case CommandNode command when TryExtractGotoPath(command.Command, out var path):
                    entries.Add(new LinkedElementEntry(command.Text.Replace("&", string.Empty), path, command.IconPath ?? string.Empty));
                    break;
            }
        }
    }

    private static string NormalizeLinkedElementSortText(string text)
    {
        var normalized = text
            .Replace("&", string.Empty)
            .Replace("Ä", "Ae", StringComparison.Ordinal)
            .Replace("Ö", "Oe", StringComparison.Ordinal)
            .Replace("Ü", "Ue", StringComparison.Ordinal)
            .Replace("ä", "ae", StringComparison.Ordinal)
            .Replace("ö", "oe", StringComparison.Ordinal)
            .Replace("ü", "ue", StringComparison.Ordinal)
            .Replace("ß", "ss", StringComparison.Ordinal);

        return new string(normalized.Where(char.IsLetterOrDigit).ToArray());
    }

    private sealed record LinkedElementEntry(string Title, string ElementPath, string IconPath);

    private static bool TryExtractGotoPath(string command, out string path)
    {
        path = string.Empty;

        var trimmed = command.Trim();
        if (!(trimmed.StartsWith(":goto ", StringComparison.OrdinalIgnoreCase)
            || trimmed.StartsWith("goto ", StringComparison.OrdinalIgnoreCase)))
        {
            return false;
        }

        var firstQuote = trimmed.IndexOf('"');
        var lastQuote = trimmed.LastIndexOf('"');
        if (firstQuote < 0 || lastQuote <= firstQuote)
        {
            return false;
        }

        path = trimmed[(firstQuote + 1)..lastQuote];
        return path.Length > 0;
    }
}

internal static class GeneratedMenuValidator
{
    public static IReadOnlyList<string> RemoveInvalidGotoTargets(MenuNode root)
    {
        var problems = new List<string>();
        RemoveInvalidChildren(root, problems, keepIfEmpty: true);
        return problems;
    }

    private static bool RemoveInvalidChildren(MenuNode menu, List<string> problems, bool keepIfEmpty = false)
    {
        for (var i = menu.Children.Count - 1; i >= 0; i--)
        {
            switch (menu.Children[i])
            {
                case MenuNode childMenu:
                    if (!RemoveInvalidChildren(childMenu, problems))
                    {
                        menu.Children.RemoveAt(i);
                    }

                    break;
                case CommandNode command when TryExtractGotoPath(command.Command, out var targetPath):
                    if (!Directory.Exists(targetPath) && !File.Exists(targetPath))
                    {
                        problems.Add($"generated:{command.Text}: {targetPath}");
                        menu.Children.RemoveAt(i);
                    }

                    break;
            }
        }

        return keepIfEmpty || menu.Children.Count > 0;
    }

    private static bool TryExtractGotoPath(string command, out string path)
    {
        path = string.Empty;

        var trimmed = command.Trim();
        if (!(trimmed.StartsWith(":goto ", StringComparison.OrdinalIgnoreCase)
            || trimmed.StartsWith("goto ", StringComparison.OrdinalIgnoreCase)))
        {
            return false;
        }

        var firstQuote = trimmed.IndexOf('"');
        var lastQuote = trimmed.LastIndexOf('"');
        if (firstQuote < 0 || lastQuote <= firstQuote)
        {
            return false;
        }

        path = trimmed[(firstQuote + 1)..lastQuote];
        return path.Length > 0;
    }
}