ChangelogInlineRenderer.cs

// Licensed to Elasticsearch B.V under one or more agreements.
// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information

using System.Globalization;
using System.Text;
using Elastic.Documentation;
using Elastic.Documentation.ReleaseNotes;

namespace Elastic.Markdown.Myst.Directives.Changelog;

/// <summary>
/// Renders changelog bundles as inline markdown content for the {changelog} directive.
/// Uses pre-loaded and cached bundle data from <see cref="ChangelogBlock"/>.
/// </summary>
public static class ChangelogInlineRenderer
{
	public static string? RenderChangelogMarkdown(ChangelogBlock block)
	{
		if (!block.Found || block.LoadedBundles.Count == 0)
			return "_No changelog entries._";

		var sb = new StringBuilder();
		var typeFilter = block.TypeFilter;

		// Render each bundle as a version section (already sorted by semver descending)
		var isFirst = true;
		foreach (var bundle in block.LoadedBundles)
		{
			if (!isFirst)
				_ = sb.AppendLine();

			var bundleMarkdown = RenderSingleBundle(
				bundle,
				block.Subsections,
				block.PublishBlocker,
				block.PrivateRepositories,
				block.HideFeatures,
				typeFilter,
				block.LinkVisibility);
			_ = sb.Append(bundleMarkdown);

			isFirst = false;
		}

		return sb.ToString();
	}

	private static string RenderSingleBundle(
		LoadedBundle bundle,
		bool subsections,
		PublishBlocker? publishBlocker,
		HashSet<string> privateRepositories,
		HashSet<string> hideFeatures,
		ChangelogTypeFilter typeFilter,
		ChangelogLinkVisibility linkVisibility)
	{
		var titleSlug = ChangelogTextUtilities.TitleToSlug(bundle.Version);

		// Filter entries based on publish blocker configuration
		var filteredEntries = FilterEntries(bundle.Entries, publishBlocker);

		// Filter entries based on hide-features (from bundle metadata)
		filteredEntries = FilterEntriesByHideFeatures(filteredEntries, hideFeatures);

		// Apply type filter
		filteredEntries = FilterEntriesByType(filteredEntries, typeFilter);

		// Group entries by type
		var entriesByType = filteredEntries
			.GroupBy(e => e.Type)
			.ToDictionary(g => g.Key, g => g.ToList());

		var hideLinks = linkVisibility switch
		{
			ChangelogLinkVisibility.KeepLinks => false,
			ChangelogLinkVisibility.HideLinks => true,
			_ => ShouldHideLinksForRepo(bundle.Repo, privateRepositories)
		};

		var displayVersion = VersionOrDate.FormatDisplayVersion(bundle.Version);
		return GenerateMarkdown(displayVersion, titleSlug, bundle.Repo, bundle.Owner, entriesByType, subsections, hideLinks, typeFilter, publishBlocker, bundle.Data?.Description, bundle.Data?.ReleaseDate, bundle.Data?.ShowReleaseDates ?? false);
	}

	/// <summary>
	/// Filters entries based on the type filter.
	/// </summary>
	private static IReadOnlyList<ChangelogEntry> FilterEntriesByType(
		IReadOnlyList<ChangelogEntry> entries,
		ChangelogTypeFilter typeFilter) => typeFilter switch
		{
			ChangelogTypeFilter.All => entries,
			ChangelogTypeFilter.BreakingChange => entries.Where(e => e.Type == ChangelogEntryType.BreakingChange).ToList(),
			ChangelogTypeFilter.Deprecation => entries.Where(e => e.Type == ChangelogEntryType.Deprecation).ToList(),
			ChangelogTypeFilter.KnownIssue => entries.Where(e => e.Type == ChangelogEntryType.KnownIssue).ToList(),
			ChangelogTypeFilter.Highlight => entries.Where(e => e.Highlight == true).ToList(),
			_ => entries.Where(e => !ChangelogBlock.SeparatedTypes.Contains(e.Type)).ToList() // Default: exclude separated types
		};

	/// <summary>
	/// Filters entries based on hide-features configuration from bundle metadata.
	/// Entries with matching feature-id values are excluded from the output.
	/// </summary>
	private static IReadOnlyList<ChangelogEntry> FilterEntriesByHideFeatures(
		IReadOnlyList<ChangelogEntry> entries,
		HashSet<string> hideFeatures)
	{
		if (hideFeatures.Count == 0)
			return entries;

		return entries
			.Where(e => string.IsNullOrWhiteSpace(e.FeatureId) || !hideFeatures.Contains(e.FeatureId))
			.ToList();
	}

	/// <summary>
	/// Determines if links should be hidden for a bundle based on its repository.
	/// For merged bundles (e.g., "elasticsearch+kibana+private-repo"), returns true
	/// if ANY component repository is in the private repositories set.
	/// </summary>
	public static bool ShouldHideLinksForRepo(string bundleRepo, HashSet<string> privateRepositories)
	{
		if (privateRepositories.Count == 0)
			return false;

		// Split on '+' to handle merged bundles (e.g., "elasticsearch+kibana+private-repo")
		var repos = bundleRepo.Split('+', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

		// Hide links if ANY component repo is private
		return repos.Any(privateRepositories.Contains);
	}

	/// <summary>
	/// Filters entries based on publish blocker configuration.
	/// </summary>
	private static IReadOnlyList<ChangelogEntry> FilterEntries(
		IReadOnlyList<ChangelogEntry> entries,
		PublishBlocker? publishBlocker)
	{
		if (publishBlocker is not { HasBlockingRules: true })
			return entries;

		return entries.Where(e => !publishBlocker.ShouldBlock(e)).ToList();
	}

	private static string GenerateMarkdown(
		string title,
		string titleSlug,
		string repo,
		string owner,
		Dictionary<ChangelogEntryType, List<ChangelogEntry>> entriesByType,
		bool subsections,
		bool hideLinks,
		ChangelogTypeFilter typeFilter,
		PublishBlocker? publishBlocker,
		string? description = null,
		DateOnly? releaseDate = null,
		bool showReleaseDates = false)
	{
		var sb = new StringBuilder();

		// Get entries by category
		var features = entriesByType.GetValueOrDefault(ChangelogEntryType.Feature, []);
		var enhancements = entriesByType.GetValueOrDefault(ChangelogEntryType.Enhancement, []);
		var security = entriesByType.GetValueOrDefault(ChangelogEntryType.Security, []);
		var bugFixes = entriesByType.GetValueOrDefault(ChangelogEntryType.BugFix, []);
		var docs = entriesByType.GetValueOrDefault(ChangelogEntryType.Docs, []);
		var regressions = entriesByType.GetValueOrDefault(ChangelogEntryType.Regression, []);
		var other = entriesByType.GetValueOrDefault(ChangelogEntryType.Other, []);
		var breakingChanges = entriesByType.GetValueOrDefault(ChangelogEntryType.BreakingChange, []);
		var deprecations = entriesByType.GetValueOrDefault(ChangelogEntryType.Deprecation, []);
		var knownIssues = entriesByType.GetValueOrDefault(ChangelogEntryType.KnownIssue, []);

		// Get highlighted entries from all types
		var highlights = entriesByType.Values
			.SelectMany(e => e)
			.Where(e => e.Highlight == true)
			.ToList();

		_ = sb.AppendLine(CultureInfo.InvariantCulture, $"## {title}");

		// Add release date if present and ShowReleaseDates is enabled
		if (showReleaseDates && releaseDate is { } date)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"_Released: {date.ToString("MMMM d, yyyy", CultureInfo.InvariantCulture)}_");
		}

		// Add description if present
		if (!string.IsNullOrEmpty(description))
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(description);
		}

		// Check if we have any content at all
		var hasAnyContent = features.Count > 0 || enhancements.Count > 0 || security.Count > 0 ||
							bugFixes.Count > 0 || docs.Count > 0 || regressions.Count > 0 || other.Count > 0 ||
							breakingChanges.Count > 0 || deprecations.Count > 0 || knownIssues.Count > 0 ||
							highlights.Count > 0;

		if (!hasAnyContent)
		{
			_ = sb.AppendLine(GetEmptyMessage(typeFilter));
			return sb.ToString();
		}

		// Special case: When filtering by highlight, render only highlights without type-based sections
		if (typeFilter == ChangelogTypeFilter.Highlight)
		{
			if (highlights.Count > 0)
				RenderDetailedEntries(sb, highlights, repo, owner, groupBySubtype: false, hideLinks, publishBlocker);
			return sb.ToString();
		}

		if (breakingChanges.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Breaking changes [{repo}-{titleSlug}-breaking-changes]");
			RenderDetailedEntries(sb, breakingChanges, repo, owner, groupBySubtype: true, hideLinks, publishBlocker);
		}

		if (highlights.Count > 0 && typeFilter == ChangelogTypeFilter.All)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Highlights [{repo}-{titleSlug}-highlights]");
			RenderDetailedEntries(sb, highlights, repo, owner, groupBySubtype: false, hideLinks, publishBlocker);
		}

		if (security.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Security [{repo}-{titleSlug}-security]");
			RenderEntriesByArea(sb, security, repo, owner, subsections, hideLinks, publishBlocker);
		}

		if (knownIssues.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Known issues [{repo}-{titleSlug}-known-issues]");
			RenderDetailedEntries(sb, knownIssues, repo, owner, groupBySubtype: false, hideLinks, publishBlocker);
		}

		if (deprecations.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Deprecations [{repo}-{titleSlug}-deprecations]");
			RenderDetailedEntries(sb, deprecations, repo, owner, groupBySubtype: false, hideLinks, publishBlocker);
		}

		if (features.Count > 0 || enhancements.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Features and enhancements [{repo}-{titleSlug}-features-enhancements]");
			var combined = features.Concat(enhancements).ToList();
			RenderEntriesByArea(sb, combined, repo, owner, subsections, hideLinks, publishBlocker);
		}

		if (bugFixes.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Fixes [{repo}-{titleSlug}-fixes]");
			RenderEntriesByArea(sb, bugFixes, repo, owner, subsections, hideLinks, publishBlocker);
		}

		if (docs.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Documentation [{repo}-{titleSlug}-docs]");
			RenderEntriesByArea(sb, docs, repo, owner, subsections, hideLinks, publishBlocker);
		}

		if (regressions.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Regressions [{repo}-{titleSlug}-regressions]");
			RenderEntriesByArea(sb, regressions, repo, owner, subsections, hideLinks, publishBlocker);
		}

		if (other.Count > 0)
		{
			_ = sb.AppendLine();
			_ = sb.AppendLine(CultureInfo.InvariantCulture, $"### Other changes [{repo}-{titleSlug}-other]");
			RenderEntriesByArea(sb, other, repo, owner, subsections, hideLinks, publishBlocker);
		}

		return sb.ToString();
	}

	private static void RenderEntriesByArea(
		StringBuilder sb,
		List<ChangelogEntry> entries,
		string repo,
		string owner,
		bool subsections,
		bool hideLinks,
		PublishBlocker? publishBlocker)
	{
		if (subsections)
		{
			// Group by area and sort when subsections is enabled
			var groupedByArea = entries.GroupBy(e => publishBlocker.GetPreferredArea(e)).OrderBy(g => g.Key).ToList();

			foreach (var areaGroup in groupedByArea)
			{
				if (!string.IsNullOrWhiteSpace(areaGroup.Key))
				{
					var header = ChangelogTextUtilities.FormatAreaHeader(areaGroup.Key);
					_ = sb.AppendLine();
					_ = sb.AppendLine(CultureInfo.InvariantCulture, $"**{header}**");
				}

				foreach (var entry in areaGroup)
					RenderSingleEntry(sb, entry, repo, owner, hideLinks);
			}
		}
		else
		{
			foreach (var entry in entries)
				RenderSingleEntry(sb, entry, repo, owner, hideLinks);
		}
	}

	private static void RenderSingleEntry(StringBuilder sb, ChangelogEntry entry, string repo, string owner, bool hideLinks)
	{
		_ = sb.Append("* ");
		_ = sb.Append(ChangelogTextUtilities.Beautify(entry.Title));

		RenderEntryLinks(sb, entry, repo, owner, hideLinks);

		if (!string.IsNullOrWhiteSpace(entry.Description))
		{
			_ = sb.AppendLine();
			var indented = ChangelogTextUtilities.Indent(entry.Description);
			_ = sb.AppendLine(indented);
		}
	}

	private static void RenderEntryLinks(StringBuilder sb, ChangelogEntry entry, string repo, string owner, bool hideLinks)
	{
		if (hideLinks)
		{
			_ = sb.AppendLine();
			foreach (var pr in entry.Prs ?? [])
			{
				_ = sb.Append("  ");
				_ = sb.AppendLine(ChangelogTextUtilities.FormatPrLink(pr, repo, hidePrivateLinks: true, owner));
			}
			foreach (var issue in entry.Issues ?? [])
			{
				_ = sb.Append("  ");
				_ = sb.AppendLine(ChangelogTextUtilities.FormatIssueLink(issue, repo, hidePrivateLinks: true, owner));
			}
			return;
		}

		_ = sb.Append(' ');
		foreach (var pr in entry.Prs ?? [])
		{
			_ = sb.Append(ChangelogTextUtilities.FormatPrLink(pr, repo, hidePrivateLinks: false, owner));
			_ = sb.Append(' ');
		}
		foreach (var issue in entry.Issues ?? [])
		{
			_ = sb.Append(ChangelogTextUtilities.FormatIssueLink(issue, repo, hidePrivateLinks: false, owner));
			_ = sb.Append(' ');
		}
		_ = sb.AppendLine();
	}

	private static void RenderDetailedEntries(
		StringBuilder sb,
		List<ChangelogEntry> entries,
		string repo,
		string owner,
		bool groupBySubtype,
		bool hideLinks,
		PublishBlocker? publishBlocker)
	{
		var grouped = groupBySubtype
			? entries.GroupBy(e => e.Subtype?.ToStringFast(true) ?? string.Empty).OrderBy(g => g.Key).ToList()
			: entries.GroupBy(e => publishBlocker.GetPreferredArea(e)).OrderBy(g => g.Key).ToList();

		foreach (var group in grouped)
		{
			if (!string.IsNullOrWhiteSpace(group.Key))
			{
				var header = groupBySubtype
					? ChangelogTextUtilities.FormatSubtypeHeader(group.Key)
					: ChangelogTextUtilities.FormatAreaHeader(group.Key);
				_ = sb.AppendLine();
				_ = sb.AppendLine(CultureInfo.InvariantCulture, $"**{header}**");
			}

			foreach (var entry in group)
				RenderDetailedEntry(sb, entry, repo, owner, hideLinks);
		}
	}

	private static void RenderDetailedEntry(StringBuilder sb, ChangelogEntry entry, string repo, string owner, bool hideLinks)
	{
		_ = sb.AppendLine();
		_ = sb.AppendLine(CultureInfo.InvariantCulture, $"::::{{dropdown}} {ChangelogTextUtilities.Beautify(entry.Title)}");
		_ = sb.AppendLine(entry.Description ?? "% Describe the change");
		_ = sb.AppendLine();

		RenderDetailedEntryLinks(sb, entry, repo, owner, hideLinks);

		// Impact section
		_ = sb.AppendLine(!string.IsNullOrWhiteSpace(entry.Impact)
			? "**Impact**<br>" + entry.Impact
			: "% **Impact**<br>_Add a description of the impact_");
		_ = sb.AppendLine();

		// Action section
		_ = sb.AppendLine(!string.IsNullOrWhiteSpace(entry.Action)
			? "**Action**<br>" + entry.Action
			: "% **Action**<br>_Add a description of what action to take_");

		_ = sb.AppendLine("::::");
	}

	private static void RenderDetailedEntryLinks(StringBuilder sb, ChangelogEntry entry, string repo, string owner, bool hideLinks)
	{
		var hasPrs = entry.Prs is { Count: > 0 };
		var hasIssues = entry.Issues is { Count: > 0 };

		if (!hasPrs && !hasIssues)
			return;

		if (hideLinks)
		{
			foreach (var pr in entry.Prs ?? [])
				_ = sb.AppendLine(ChangelogTextUtilities.FormatPrLink(pr, repo, hidePrivateLinks: true, owner));
			foreach (var issue in entry.Issues ?? [])
				_ = sb.AppendLine(ChangelogTextUtilities.FormatIssueLink(issue, repo, hidePrivateLinks: true, owner));
			_ = sb.AppendLine("For more information, check the pull request or issue above.");
			_ = sb.AppendLine();
			return;
		}

		_ = sb.Append("For more information, check ");
		var first = true;
		foreach (var pr in entry.Prs ?? [])
		{
			if (!first)
				_ = sb.Append(' ');
			_ = sb.Append(ChangelogTextUtilities.FormatPrLink(pr, repo, hidePrivateLinks: false, owner));
			first = false;
		}
		foreach (var issue in entry.Issues ?? [])
		{
			if (!first)
				_ = sb.Append(' ');
			_ = sb.Append(ChangelogTextUtilities.FormatIssueLink(issue, repo, hidePrivateLinks: false, owner));
			first = false;
		}
		_ = sb.AppendLine(".");
		_ = sb.AppendLine();
	}

	/// <summary>
	/// Gets the appropriate empty message based on the type filter.
	/// Matches messages used by CLI renderers for consistency.
	/// </summary>
	private static string GetEmptyMessage(ChangelogTypeFilter typeFilter) =>
		typeFilter switch
		{
			ChangelogTypeFilter.BreakingChange => "_There are no breaking changes associated with this release._",
			ChangelogTypeFilter.Deprecation => "_There are no deprecations associated with this release._",
			ChangelogTypeFilter.KnownIssue => "_There are no known issues associated with this release._",
			_ => "_No new features, enhancements, or fixes._"
		};
}