path: root/src/SMAPI/Framework/ContentManagers/GameContentManager.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.Xna.Framework.Graphics;
using StardewModdingAPI.Events;
using StardewModdingAPI.Framework.Content;
using StardewModdingAPI.Framework.Deprecations;
using StardewModdingAPI.Framework.Exceptions;
using StardewModdingAPI.Framework.Reflection;
using StardewModdingAPI.Framework.Utilities;
using StardewModdingAPI.Internal;
using StardewValley;
using xTile;
using xTile.Tiles;

namespace StardewModdingAPI.Framework.ContentManagers
{
    /// <summary>A content manager which handles reading files from the game content folder with support for interception.</summary>
    internal class GameContentManager : BaseContentManager
    {
        /*********
        ** Fields
        *********/
        /// <summary>The assets currently being intercepted by <see cref="IAssetLoader"/> instances. This is used to prevent infinite loops when a loader loads a new asset.</summary>
        private readonly ContextHash<string> AssetsBeingLoaded = new();

        /// <summary>Whether the next load is the first for any game content manager.</summary>
        private static bool IsFirstLoad = true;

        /// <summary>A callback to invoke the first time *any* game content manager loads an asset.</summary>
        private readonly Action OnLoadingFirstAsset;

        /// <summary>A callback to invoke when an asset is fully loaded.</summary>
        private readonly Action<BaseContentManager, IAssetName> OnAssetLoaded;


        /*********
        ** Public methods
        *********/
        /// <summary>Construct an instance.</summary>
        /// <param name="name">A name for the mod manager. Not guaranteed to be unique.</param>
        /// <param name="serviceProvider">The service provider to use to locate services.</param>
        /// <param name="rootDirectory">The root directory to search for content.</param>
        /// <param name="currentCulture">The current culture for which to localize content.</param>
        /// <param name="coordinator">The central coordinator which manages content managers.</param>
        /// <param name="monitor">Encapsulates monitoring and logging.</param>
        /// <param name="reflection">Simplifies access to private code.</param>
        /// <param name="onDisposing">A callback to invoke when the content manager is being disposed.</param>
        /// <param name="onLoadingFirstAsset">A callback to invoke the first time *any* game content manager loads an asset.</param>
        /// <param name="onAssetLoaded">A callback to invoke when an asset is fully loaded.</param>
        public GameContentManager(string name, IServiceProvider serviceProvider, string rootDirectory, CultureInfo currentCulture, ContentCoordinator coordinator, IMonitor monitor, Reflector reflection, Action<BaseContentManager> onDisposing, Action onLoadingFirstAsset, Action<BaseContentManager, IAssetName> onAssetLoaded)
            : base(name, serviceProvider, rootDirectory, currentCulture, coordinator, monitor, reflection, onDisposing, isNamespaced: false)
        {
            this.OnLoadingFirstAsset = onLoadingFirstAsset;
            this.OnAssetLoaded = onAssetLoaded;
        }

        /// <inheritdoc />
        public override bool DoesAssetExist<T>(IAssetName assetName)
        {
            if (base.DoesAssetExist<T>(assetName))
                return true;

            // vanilla asset
            if (File.Exists(Path.Combine(this.RootDirectory, $"{assetName.Name}.xnb")))
                return true;

            // managed asset
            if (this.Coordinator.TryParseManagedAssetKey(assetName.Name, out string? contentManagerID, out IAssetName? relativePath))
                return this.Coordinator.DoesManagedAssetExist<T>(contentManagerID, relativePath);

            // custom asset from a loader
            string locale = this.GetLocale();
            IAssetInfo info = new AssetInfo(locale, assetName, typeof(T), this.AssertAndNormalizeAssetName);
            AssetOperationGroup? operations = this.Coordinator.GetAssetOperations
#if SMAPI_DEPRECATED
                <T>
#endif
                (info);
            if (operations?.LoadOperations.Count > 0)
            {
                if (!this.AssertMaxOneRequiredLoader(info, operations.LoadOperations, out string? error))
                {
                    this.Monitor.Log(error, LogLevel.Warn);
                    return false;
                }

                return true;
            }

            return false;
        }

        /// <inheritdoc />
        public override T LoadExact<T>(IAssetName assetName, bool useCache)
        {
            if (typeof(IRawTextureData).IsAssignableFrom(typeof(T)))
                throw new SContentLoadException(ContentLoadErrorType.Other, $"Can't load {nameof(IRawTextureData)} assets from the game content pipeline. This asset type is only available for mod files.");

            // raise first-load callback
            if (GameContentManager.IsFirstLoad)
            {
                GameContentManager.IsFirstLoad = false;
                this.OnLoadingFirstAsset();
            }

            // get from cache
            if (useCache && this.IsLoaded(assetName))
                return this.RawLoad<T>(assetName, useCache: true);

            // get managed asset
            if (this.Coordinator.TryParseManagedAssetKey(assetName.Name, out string? contentManagerID, out IAssetName? relativePath))
            {
                T managedAsset = this.Coordinator.LoadManagedAsset<T>(contentManagerID, relativePath);
                this.TrackAsset(assetName, managedAsset, useCache);
                return managedAsset;
            }

            // load asset
            T data;
            if (this.AssetsBeingLoaded.Contains(assetName.Name))
            {
                this.Monitor.Log($"Broke loop while loading asset '{assetName}'.", LogLevel.Warn);
                this.Monitor.Log($"Bypassing mod loaders for this asset. Stack trace:\n{Environment.StackTrace}");
                data = this.RawLoad<T>(assetName, useCache);
            }
            else
            {
                data = this.AssetsBeingLoaded.Track(assetName.Name, () =>
                {
                    IAssetInfo info = new AssetInfo(assetName.LocaleCode, assetName, typeof(T), this.AssertAndNormalizeAssetName);
                    AssetOperationGroup? operations = this.Coordinator.GetAssetOperations
#if SMAPI_DEPRECATED
                        <T>
#endif
                        (info);
                    IAssetData asset =
                        this.ApplyLoader<T>(info, operations?.LoadOperations)
                        ?? new AssetDataForObject(info, this.RawLoad<T>(assetName, useCache), this.AssertAndNormalizeAssetName, this.Reflection);
                    asset = this.ApplyEditors<T>(info, asset, operations?.EditOperations);
                    return (T)asset.Data;
                });
            }

            // update cache
            this.TrackAsset(assetName, data, useCache);

            // raise event & return data
            this.OnAssetLoaded(this, assetName);
            return data;
        }

        /// <inheritdoc />
        public override LocalizedContentManager CreateTemporary()
        {
            return this.Coordinator.CreateGameContentManager("(temporary)");
        }


        /*********
        ** Private methods
        *********/
        /// <summary>Load the initial asset from the registered loaders.</summary>
        /// <param name="info">The basic asset metadata.</param>
        /// <param name="loadOperations">The load operations to apply to the asset.</param>
        /// <returns>Returns the loaded asset metadata, or <c>null</c> if no loader matched.</returns>
        private IAssetData? ApplyLoader<T>(IAssetInfo info, List<AssetLoadOperation>? loadOperations)
            where T : notnull
        {
            // find matching loader
            AssetLoadOperation? loader = null;
            if (loadOperations?.Count > 0)
            {
                if (!this.AssertMaxOneRequiredLoader(info, loadOperations, out string? error))
                {
                    this.Monitor.Log(error, LogLevel.Warn);
                    return null;
                }

                loader = loadOperations.OrderByDescending(p => p.Priority).FirstOrDefault();
            }
            if (loader == null)
                return null;

            // fetch asset from loader
            IModMetadata mod = loader.Mod;
            T data;
            Context.HeuristicModsRunningCode.Push(loader.Mod);
            try
            {
                data = (T)loader.GetData(info);
                this.Monitor.Log($"{mod.DisplayName} loaded asset '{info.Name}'{this.GetOnBehalfOfLabel(loader.OnBehalfOf)}.");
            }
            catch (Exception ex)
            {
                mod.LogAsMod($"Mod crashed when loading asset '{info.Name}'{this.GetOnBehalfOfLabel(loader.OnBehalfOf)}. SMAPI will use the default asset instead. Error details:\n{ex.GetLogSummary()}", LogLevel.Error);
                return null;
            }
            finally
            {
                Context.HeuristicModsRunningCode.TryPop(out _);
            }

            // return matched asset
            return this.TryFixAndValidateLoadedAsset(info, data, loader)
                ? new AssetDataForObject(info, data, this.AssertAndNormalizeAssetName, this.Reflection)
                : null;
        }

        /// <summary>Apply any editors to a loaded asset.</summary>
        /// <typeparam name="T">The asset type.</typeparam>
        /// <param name="info">The basic asset metadata.</param>
        /// <param name="asset">The loaded asset.</param>
        /// <param name="editOperations">The edit operations to apply to the asset.</param>
        private IAssetData ApplyEditors<T>(IAssetInfo info, IAssetData asset, List<AssetEditOperation>? editOperations)
            where T : notnull
        {
            if (editOperations?.Count is not > 0)
                return asset;

            IAssetData GetNewData(object data) => new