#nullable disable
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using HarmonyLib;
namespace StardewModdingAPI.Framework.Commands
{
/// The 'harmony_summary' SMAPI console command.
internal class HarmonySummaryCommand : IInternalCommand
{
/*********
** Accessors
*********/
/// The command name, which the user must type to trigger it.
public string Name { get; } = "harmony_summary";
/// The human-readable documentation shown when the player runs the built-in 'help' command.
public string Description { get; } = "Harmony is a library which rewrites game code, used by SMAPI and some mods. This command lists current Harmony patches.\n\nUsage: harmony_summary\nList all Harmony patches.\n\nUsage: harmony_summary \n- search: one more more words to search. If any word matches a method name, the method and all its patchers will be listed; otherwise only matching patchers will be listed for the method.";
/*********
** Public methods
*********/
/// Handle the console command when it's entered by the user.
/// The command arguments.
/// Writes messages to the console.
public void HandleCommand(string[] args, IMonitor monitor)
{
SearchResult[] matches = this.FilterPatches(args).OrderBy(p => p.MethodName).ToArray();
StringBuilder result = new();
if (!matches.Any())
result.AppendLine("No current patches match your search.");
else
{
result.AppendLine(args.Any() ? "Harmony patches which match your search terms:" : "Current Harmony patches:");
result.AppendLine();
foreach (var match in matches)
{
result.AppendLine($" {match.MethodName}");
foreach (var ownerGroup in match.PatchTypesByOwner.OrderBy(p => p.Key))
{
var sortedTypes = ownerGroup.Value
.OrderBy(p => p switch
{
PatchType.Prefix => 0,
PatchType.Postfix => 1,
PatchType.Finalizer => 2,
PatchType.Transpiler => 3,
_ => 4
});
result.AppendLine($" - {ownerGroup.Key} ({string.Join(", ", sortedTypes).ToLower()})");
}
result.AppendLine();
}
}
monitor.Log(result.ToString().TrimEnd(), LogLevel.Info);
}
/*********
** Private methods
*********/
/// Get all current Harmony patches matching any of the given search terms.
/// The search terms to match.
private IEnumerable FilterPatches(string[] searchTerms)
{
bool hasSearch = searchTerms.Any();
bool IsMatch(string target) => !hasSearch || searchTerms.Any(search => target != null && target.IndexOf(search, StringComparison.OrdinalIgnoreCase) > -1);
foreach (var patch in this.GetAllPatches())
{
// matches entire patch
if (IsMatch(patch.MethodDescription))
{
yield return patch;
continue;
}
// matches individual patchers
foreach (var pair in patch.PatchTypesByOwner.ToArray())
{
if (!IsMatch(pair.Key) && !pair.Value.Any(type => IsMatch(type.ToString())))
patch.PatchTypesByOwner.Remove(pair.Key);
}
if (patch.PatchTypesByOwner.Any())
yield return patch;
}
}
/// Get all current Harmony patches.
private IEnumerable GetAllPatches()
{
foreach (MethodBase method in Harmony.GetAllPatchedMethods().ToArray())
{
// get metadata for method
HarmonyLib.Patches patchInfo = Harmony.GetPatchInfo(method);
IDictionary> patchGroups = new Dictionary>
{
[PatchType.Prefix] = patchInfo.Prefixes,
[PatchType.Postfix] = patchInfo.Postfixes,
[PatchType.Finalizer] = patchInfo.Finalizers,
[PatchType.Transpiler] = patchInfo.Transpilers
};
// get patch types by owner
var typesByOwner = new Dictionary>();
foreach (var group in patchGroups)
{
foreach (var patch in group.Value)
{
if (!typesByOwner.TryGetValue(patch.owner, out ISet patchTypes))
typesByOwner[patch.owner] = patchTypes = new HashSet();
patchTypes.Add(group.Key);
}
}
// create search result
yield return new SearchResult(method, typesByOwner);
}
}
/// A Harmony patch type.
private enum PatchType
{
/// A prefix patch.
Prefix,
/// A postfix patch.
Postfix,
/// A finalizer patch.
Finalizer,
/// A transpiler patch.
Transpiler
}
/// A patch search result for a method.
private class SearchResult
{
/*********
** Accessors
*********/
/// A simple human-readable name for the patched method.
public string MethodName { get; }
/// A detailed description for the patched method.
public string MethodDescription { get; }
/// The patch types by the Harmony instance ID that added them.
public IDictionary> PatchTypesByOwner { get; }
/*********
** Public methods
*********/
/// Construct an instance.
/// The patched method.
/// The patch types by the Harmony instance ID that added them.
public SearchResult(MethodBase method, IDictionary> patchTypesByOwner)
{
this.MethodName = $"{method.DeclaringType?.FullName}.{method.Name}";
this.MethodDescription = method.FullDescription();
this.PatchTypesByOwner = patchTypesByOwner;
}
}
}
}