A craft that cleans up after itself¶

using System;
using System.Collections.Generic;

using RevGaming.RevFramework.Crafting.Core;

using RevGaming.RevFramework.Economy;
using RevGaming.RevFramework.Economy.Abstractions;

using UnityEngine;
using UnityEngine.Serialization;

namespace RevGaming.RevFramework.Cookbook.AtomicCraft
{
    /// <summary>
    /// Runs an authored crafting recipe through Economy's transaction instead of the workbench — so a
    /// leg that fails after another has succeeded is compensated, a retry carrying the same request id
    /// is replayed instead of charged again, and the craft can cost more than one currency.
    /// </summary>
    /// <remarks>
    /// <para><b>Recipe.</b> One class, dropped into a project that already exists. Systems required:
    /// <b>Crafting</b>, <b>Economy</b>, <b>Currency</b> — the only implementation of
    /// <c>ICraftingService</c> is internal and reaches you through a bootstrap gated on Currency. The
    /// wiring also uses <b>Inventory</b>, because that is the bootstrap that hands back a real
    /// <see cref="IItemStore"/>. Complete only. Public API only.</para>
    ///
    /// <para><b>There are two crafting implementations in this framework and nothing connects them.</b>
    /// Crafting has the benches, timers, validators, modifiers and progression. Economy has its own
    /// <c>ICraftingService.Craft</c>: one call that takes money, removes ingredients, delivers a result
    /// and compensates the legs that already succeeded when a later one fails. Neither knows the other
    /// exists. This class is the twenty lines in the middle, and it uses the recipe asset as a
    /// <i>price list</i> — which is the honest description of what it does.</para>
    ///
    /// <para><b>Compensation is an attempt, not a transaction, and this is the trap.</b>
    /// <c>ICraftingService</c> promises only that it <i>may attempt</i> to undo completed legs, and a
    /// compensating leg can itself be refused — an inventory authority, a currency cap, an item guid
    /// the store's resolver does not know. Economy reports that on
    /// <c>CompensationFailureReport.Failed</c> (in Core, so present in every package) and the failure
    /// this call returns says nothing about it. Subscribe to that event if a stuck half-craft matters.</para>
    ///
    /// <para><b>Going around the crafting service means going around all of it:</b>
    /// <c>ICraftingValidator</c>, <c>ICraftingModifier</c>, level gates, station rules, output routing,
    /// queueing, the crafting events and XP. None of them run here. This is for the instant case — a
    /// vendor who crafts for you, an upgrade counter, a shrine that trades three things for one — and
    /// not a replacement for the workbench.</para>
    ///
    /// <para><b>Two recipe fields are refused rather than ignored,</b> and
    /// <see cref="IsUsable(RecipeCore, out string)"/> reports both up front so a tool can sweep a
    /// library rather than finding out at the counter. <c>Craft</c> delivers a single
    /// <see cref="ItemLine"/>, so a multi-output recipe is refused rather than have the extras silently
    /// destroyed — a limit of the call this class chose, not of Economy: <c>IShopService.Buy</c> takes a
    /// list on the same ledger and store, with the same preflight, compensation and idempotency, at the
    /// cost of telemetering as a shop rather than a craft. A craft time is refused for a different
    /// reason: this path is instantaneous, so honouring it is impossible and swallowing it changes what
    /// the author wrote.</para>
    ///
    /// <para><b>Idempotency lives entirely in the request id</b> — see the parameter on
    /// <see cref="TryCraft"/> for how to mint one. The window it is checked against is smaller than it
    /// sounds: it lives on the <c>ICraftingService</c> instance, holds the 32 most recent successful
    /// crafts per owner, and does not survive a reload or a rebuild of the services. Build them once
    /// and share them, and expect it to cover a double-click, not a retry across a save.</para>
    /// </remarks>
    [DisallowMultipleComponent]
    public sealed class AtomicCraft : MonoBehaviour
    {
        /// <summary>
        /// One extra currency line added to a recipe's own cost.
        /// </summary>
        /// <remarks>
        /// Exists because <c>RecipeCore.Currency</c> holds exactly one cost and a
        /// <see cref="PriceBundle"/> does not. Nothing keeps these in step with the recipe asset — a
        /// second price living on a component is a real cost of this approach, and worth stating rather
        /// than hiding.
        /// </remarks>
        [Serializable]
        private struct ExtraCost
        {
            [Tooltip("Currency id, matching the ids your currency service knows.")]
            public string currencyId;

            [Tooltip("Amount charged per craft, on top of whatever the recipe itself costs.")]
            [Min(0)] public long amount;
        }

        [Header("Recipe")]
        [Tooltip("Recipe to craft: a RecipeCore asset, or an authoring asset that resolves to one " +
                 "(RecipeDefinition, or your own registered wrapper).")]
        // Renamed from `recipe` when the type widened from RecipeCore to ScriptableObject, so that
        // projects authoring with RecipeDefinition can assign one at all. Unity keys serialized data
        // on the field NAME, so without this attribute the rename silently empties the slot in every
        // scene and prefab that already had it filled -- and an empty slot here refuses every craft
        // with "No recipe assigned", which reads like a bug rather than a migration. RecipeCore is a
        // ScriptableObject, so an existing reference deserializes into the wider field unchanged.
        [FormerlySerializedAs("recipe")]
        [SerializeField] private ScriptableObject recipeAsset;

        [Tooltip("Extra currency costs added to the recipe's own. This is how a craft costs gold AND " +
                 "shards, which a recipe asset cannot express by itself.")]
        [SerializeField] private ExtraCost[] extraCosts = Array.Empty<ExtraCost>();

        [Header("Telemetry")]
        [Tooltip("Vendor id recorded against the currency operations. Optional; for logs and audit only.")]
        [SerializeField] private string vendorId;

        private ICraftingService _crafting;
        private IValueLedger _ledger;
        private IItemStore _store;

        /// <summary>
        /// Gives this component the Economy services it charges and delivers through.
        /// </summary>
        /// <remarks>
        /// All three come out of <c>EconomyInventoryBootstrap.BuildForPlayer</c> together, so this is
        /// one line where you already build them. <c>EconomyBootstrap.BuildForPlayer</c> is not an
        /// alternative here: it documents that the item store it returns is always <c>null</c>, so
        /// bring your own <see cref="IItemStore"/> if that is the route you are on. They are interfaces,
        /// so they cannot come from the Inspector. Build them once and share them — the idempotency
        /// window lives on the crafting service instance.
        /// </remarks>
        public void Bind(ICraftingService crafting, IValueLedger ledger, IItemStore store)
        {
            _crafting = crafting;
            _ledger = ledger;
            _store = store;
        }

        /// <summary>
        /// Whether the assigned recipe can be crafted through this path at all.
        /// </summary>
        /// <param name="reason">Why not, when the answer is false.</param>
        /// <remarks>
        /// A data question, not a runtime one — it does not look at the crafter, the wallet or the bag.
        /// </remarks>
        public bool IsUsable(out string reason) => TryResolveRecipe(out _, out reason);

        /// <summary>
        /// Whether any recipe can be crafted through this path, without a component to hold it.
        /// </summary>
        /// <param name="recipe">Recipe to test.</param>
        /// <param name="reason">Why not, when the answer is false.</param>
        /// <remarks>
        /// Static so a validation pass can sweep a recipe library and report the ones this path would
        /// have to refuse, rather than each one surfacing as a failed craft in front of a player. The
        /// instance overload is this method applied to the assigned asset.
        /// </remarks>
        public static bool IsUsable(RecipeCore recipe, out string reason)
        {
            if (!recipe)
            {
                reason = "No recipe.";
                return false;
            }

            if (!recipe.IsValid)
            {
                reason = "Recipe is not valid: it needs at least one input and one output, with ids and positive quantities.";
                return false;
            }

            if (recipe.Outputs.Count != 1)
            {
                reason = $"Recipe has {recipe.Outputs.Count} outputs and ICraftingService.Craft delivers exactly one. " +
                         "Crafting the first and dropping the rest would silently destroy authored content; " +
                         "IShopService.Buy takes a list of deliveries if you need all of them atomically.";
                return false;
            }

            if (recipe.CraftTimeSeconds > 0f)
            {
                reason = $"Recipe takes {recipe.CraftTimeSeconds}s and this path is instantaneous. " +
                         "Use the crafting service for timed recipes; it is the thing that owns the queue.";
                return false;
            }

            reason = null;
            return true;
        }

        /// <summary>
        /// Charges for the recipe and delivers its output.
        /// </summary>
        /// <param name="crafter">The wallet that pays, and the bucket the request id is remembered
        /// against. It is <i>not</i> the bag: ingredients leave, and the result lands in, whichever
        /// owner the <see cref="IItemStore"/> was built for. Pass that same GameObject unless you mean
        /// to move value between two owners.</param>
        /// <param name="requestId">Idempotency key, and the only thing that provides one. A repeat of
        /// the same value replays the first success instead of charging again; null, empty or
        /// whitespace means no protection at all. Mint it once per logical craft, keep it under 128
        /// characters — longer ids are truncated and can collide — and never make it constant, which
        /// turns every craft after the first into a silent no-op.</param>
        /// <returns>
        /// <see cref="EcoOpResult.Ok"/> when the craft completed, or when a repeated request id replayed
        /// an earlier success. A failure otherwise, after Economy has attempted to undo the legs that
        /// had already succeeded — an attempt, not a guarantee; see the class remarks for the case where
        /// it is refused.
        /// </returns>
        public EcoOpResult TryCraft(GameObject crafter, string requestId = null)
        {
            if (_crafting == null || _ledger == null || _store == null)
                return EcoOpResult.ServiceMissing(
                    "AtomicCraft needs a crafting service, ledger and item store. Call Bind with all " +
                    "three; note that EconomyBootstrap always returns a null store.");

            if (!crafter)
                return EcoOpResult.InvalidArgs("No crafter.");

            if (!TryResolveRecipe(out RecipeCore recipe, out string reason))
                return EcoOpResult.InvalidArgs(reason);

            ItemRef output = recipe.Outputs[0];
            var result = new ItemLine(output.guid, output.quantity);

            // Fresh lists per craft, deliberately. PriceBundle documents that it does not copy or freeze
            // what it is handed, so a pooled list reused on the next craft would be mutating a bundle a
            // consumer may still be holding. A craft is a button press, not a per-frame cost.
            var money = new List<ChargeLine>();
            var items = new List<ItemLine>(recipe.Inputs.Count);

            CurrencyCost currency = recipe.Currency;
            if (!string.IsNullOrWhiteSpace(currency.currencyId) && currency.amountPerCraft > 0)
                money.Add(new ChargeLine(currency.currencyId, currency.amountPerCraft));

            for (int i = 0; i < extraCosts.Length; i++)
            {
                ExtraCost extra = extraCosts[i];

                // Skipped rather than refused: a blank row in an Inspector array is someone part-way
                // through authoring, not a broken craft.
                if (string.IsNullOrWhiteSpace(extra.currencyId) || extra.amount <= 0)
                    continue;

                money.Add(new ChargeLine(extra.currencyId, extra.amount));
            }

            for (int i = 0; i < recipe.Inputs.Count; i++)
            {
                ItemRef input = recipe.Inputs[i];
                items.Add(new ItemLine(input.guid, input.quantity));
            }

            var cost = new PriceBundle(money, items);

            // The caller's request id is passed through untouched, and nothing is minted in its place.
            // Economy dedups on the exact string, so an id invented here would differ on every call --
            // no protection, and a wasted slot in a window that only holds 32 per owner. Whitespace is
            // sanitised away upstream and lands as no id at all, which is the same as null.
            string source = EcoSource.Build(vendorId, requestId);

            return _crafting.Craft(crafter, _ledger, _store, cost, result, EcoReasons.Craft, source);
        }

        // RecipeResolve is the framework's supported seam for this: a RecipeCore asset comes back as
        // itself, and an authoring asset comes back converted, so the field does not have to be the
        // format RecipeCore's own remarks tell you not to author by hand.
        private bool TryResolveRecipe(out RecipeCore recipe, out string reason)
        {
            recipe = null;

            if (!recipeAsset)
            {
                reason = "No recipe assigned.";
                return false;
            }

            if (!RecipeResolve.TryResolve(recipeAsset, out recipe))
            {
                reason = $"'{recipeAsset.name}' is not a recipe this build can resolve. Assign a " +
                         "RecipeCore, or an authoring asset whose converter is registered.";
                return false;
            }

            return IsUsable(recipe, out reason);
        }
    }
}