using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using StardewModdingAPI.Framework.ModHelpers;
using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
using StardewModdingAPI.Toolkit.Framework.ModData;
using StardewModdingAPI.Toolkit.Framework.UpdateData;
using StardewModdingAPI.Toolkit.Utilities;
namespace StardewModdingAPI.Framework.ModLoading
{
/// Metadata for a mod.
internal class ModMetadata : IModMetadata
{
/*********
** Fields
*********/
/// The non-error issues with the mod, including warnings suppressed by the data record.
private ModWarning ActualWarnings = ModWarning.None;
/// The mod IDs which are listed as a requirement by this mod. The value for each pair indicates whether the dependency is required (i.e. not an optional dependency).
private readonly Lazy> Dependencies;
/*********
** Accessors
*********/
///
public string DisplayName { get; }
///
public string RootPath { get; }
///
public string DirectoryPath { get; }
///
public string RelativeDirectoryPath { get; }
///
public IManifest Manifest { get; }
///
public ModDataRecordVersionedFields? DataRecord { get; }
///
public ModMetadataStatus Status { get; private set; }
///
public ModFailReason? FailReason { get; private set; }
///
public ModWarning Warnings => this.ActualWarnings & ~(this.DataRecord?.DataRecord.SuppressWarnings ?? ModWarning.None);
///
public string? Error { get; private set; }
///
public string? ErrorDetails { get; private set; }
///
public bool IsIgnored { get; }
///
public IMod? Mod { get; private set; }
///
public IContentPack? ContentPack { get; private set; }
///
public TranslationHelper? Translations { get; private set; }
///
public IMonitor? Monitor { get; private set; }
///
public object? Api { get; private set; }
///
public ModEntryModel? UpdateCheckData { get; private set; }
///
[MemberNotNullWhen(true, nameof(ModMetadata.ContentPack))]
[SuppressMessage("ReSharper", "ConstantConditionalAccessQualifier", Justification = "The manifest may be null for broken mods while loading.")]
public bool IsContentPack => this.Manifest?.ContentPackFor != null;
/// The fake content packs created by this mod, if any.
public ISet> FakeContentPacks { get; } = new HashSet>();
/*********
** Public methods
*********/
/// Construct an instance.
/// The mod's display name.
/// The mod's full directory path within the .
/// The root path containing mods.
/// The mod manifest.
/// Metadata about the mod from SMAPI's internal data (if any).
/// Whether the mod folder should be ignored. This should be true if it was found within a folder whose name starts with a dot.
public ModMetadata(string displayName, string directoryPath, string rootPath, IManifest? manifest, ModDataRecordVersionedFields? dataRecord, bool isIgnored)
{
this.DisplayName = displayName;
this.DirectoryPath = directoryPath;
this.RootPath = rootPath;
this.RelativeDirectoryPath = PathUtilities.GetRelativePath(this.RootPath, this.DirectoryPath);
this.Manifest = manifest!; // manifest may be null in low-level SMAPI code, but won't be null once it's received by mods via IModInfo
this.DataRecord = dataRecord;
this.IsIgnored = isIgnored;
this.Dependencies = new Lazy>(this.ExtractDependencies);
}
///
public IModMetadata SetStatusFound()
{
this.SetStatus(ModMetadataStatus.Found, ModFailReason.Incompatible, null);
this.FailReason = null;
return this;
}
///
public IModMetadata SetStatus(ModMetadataStatus status, ModFailReason reason, string? error, string? errorDetails = null)
{
this.Status = status;
this.FailReason = reason;
this.Error = error;
this.ErrorDetails = errorDetails;
return this;
}
///
public IModMetadata SetWarning(ModWarning warning)
{
this.ActualWarnings |= warning;
return this;
}
///
public IModMetadata SetMod(IMod mod, TranslationHelper translations)
{
if (this.ContentPack != null)
throw new InvalidOperationException("A mod can't be both an assembly mod and content pack.");
this.Mod = mod;
this.Monitor = mod.Monitor;
this.Translations = translations;
return this;
}
///
public IModMetadata SetMod(IContentPack contentPack, IMonitor monitor, TranslationHelper translations)
{
if (this.Mod != null)
throw new InvalidOperationException("A mod can't be both an assembly mod and content pack.");
this.ContentPack = contentPack;
this.Monitor = monitor;
this.Translations = translations;
return this;
}
///
public IModMetadata SetApi(object? api)
{
this.Api = api;
return this;
}
///
public IModMetadata SetUpdateData(ModEntryModel data)
{
this.UpdateCheckData = data;
return this;
}
///
[MemberNotNullWhen(true, nameof(IModInfo.Manifest))]
public bool HasManifest()
{
return this.Manifest != null;
}
///
public bool HasID()
{
return
this.HasManifest()
&& !string.IsNullOrWhiteSpace(this.Manifest.UniqueID);
}
///
public bool HasID(string? id)
{
return
this.HasID()
&& string.Equals(this.Manifest.UniqueID.Trim(), id?.Trim(), StringComparison.OrdinalIgnoreCase);
}
///
public IEnumerable GetUpdateKeys(bool validOnly = false)
{
if (!this.HasManifest())
yield break;
foreach (string rawKey in this.Manifest.UpdateKeys)
{
UpdateKey updateKey = UpdateKey.Parse(rawKey);
if (updateKey.LooksValid || !validOnly)
yield return updateKey;
}
}
///
public bool HasRequiredModId(string modId, bool includeOptional)
{
return
this.Dependencies.Value.TryGetValue(modId, out bool isRequired)
&& (includeOptional || isRequired);
}
///
public IEnumerable GetRequiredModIds(bool includeOptional = false)
{
foreach (var pair in this.Dependencies.Value)
{
if (includeOptional || pair.Value)
yield return pair.Key;
}
}
///
public bool HasValidUpdateKeys()
{
return this.GetUpdateKeys(validOnly: true).Any();
}
///
public bool HasWarnings(params ModWarning[] warnings)
{
ModWarning curWarnings = this.Warnings;
return warnings.Any(warning => curWarnings.HasFlag(warning));
}
///
public string GetRelativePathWithRoot()
{
string rootFolderName = Path.GetFileName(this.RootPath);
return Path.Combine(rootFolderName, this.RelativeDirectoryPath);
}
/// Get the currently live fake content packs created by this mod.
public IEnumerable GetFakeContentPacks()
{
foreach (var reference in this.FakeContentPacks.ToArray())
{
if (!reference.TryGetTarget(out ContentPack? pack))
{
this.FakeContentPacks.Remove(reference);
continue;
}
yield return pack;
}
}
/*********
** Private methods
*********/
/// Extract mod IDs from the manifest that must be installed to load this mod.
/// Returns a dictionary of mod ID => is required (i.e. not an optional dependency).
public IDictionary ExtractDependencies()
{
var ids = new Dictionary(StringComparer.OrdinalIgnoreCase);
if (this.HasManifest())
{
// yield dependencies
foreach (IManifestDependency entry in this.Manifest.Dependencies)
{
if (!string.IsNullOrWhiteSpace(entry.UniqueID))
ids[entry.UniqueID] = entry.IsRequired;
}
// yield content pack parent
if (!string.IsNullOrWhiteSpace(this.Manifest.ContentPackFor?.UniqueID))
ids[this.Manifest.ContentPackFor.UniqueID] = true;
}
return ids;
}
}
}