CatStation/Content.Client/Guidebook/Controls/GuideMicrowaveEmbed.xaml.cs

using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Client.Guidebook.Richtext;
using Content.Client.Message;
using Content.Client.UserInterface.ControlExtensions;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Kitchen;
using JetBrains.Annotations;
using Robust.Client.AutoGenerated;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.XAML;
using Robust.Client.UserInterface;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;

namespace Content.Client.Guidebook.Controls;

/// <summary>
/// Control for embedding a microwave recipe into a guidebook.
/// </summary>
[UsedImplicitly, GenerateTypedNameReferences]
public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag, ISearchableControl, IPrototypeRepresentationControl
{
    [Dependency] private IPrototypeManager _prototype = default!;
    [Dependency] private ILogManager _logManager = default!;

    private readonly ISawmill _sawmill = default!;

    public IPrototype? RepresentedPrototype { get; private set; }

    public GuideMicrowaveEmbed()
    {
        RobustXamlLoader.Load(this);
        IoCManager.InjectDependencies(this);
        MouseFilter = MouseFilterMode.Stop;

        _sawmill = _logManager.GetSawmill("guidebook.microwave");
    }

    public GuideMicrowaveEmbed(string recipe) : this()
    {
        GenerateControl(_prototype.Index<MicrowaveMealRecipePrototype>(recipe));
    }

    public GuideMicrowaveEmbed(MicrowaveMealRecipePrototype recipe) : this()
    {
        GenerateControl(recipe);
    }

    public bool CheckMatchesSearch(string query)
    {
        return this.ChildrenContainText(query);
    }

    public void SetHiddenState(bool state, string query)
    {
        Visible = CheckMatchesSearch(query) ? state : !state;
    }

    public bool TryParseTag(Dictionary<string, string> args, [NotNullWhen(true)] out Control? control)
    {
        control = null;
        if (!args.TryGetValue("Recipe", out var id))
        {
            _sawmill.Error("Recipe embed tag is missing recipe prototype argument");
            return false;
        }

        if (!_prototype.TryIndex<MicrowaveMealRecipePrototype>(id, out var recipe))
        {
            _sawmill.Error($"Specified recipe prototype \"{id}\" is not a valid recipe prototype");
            return false;
        }

        GenerateControl(recipe);

        control = this;
        return true;
    }

    private void GenerateHeader(MicrowaveMealRecipePrototype recipe)
    {
        var entity = _prototype.Index<EntityPrototype>(recipe.Result);

        RepresentedPrototype = entity;

        IconContainer.AddChild(new GuideEntityEmbed(recipe.Result, false, false));
        ResultName.SetMarkup(entity.Name);
        ResultDescription.SetMarkup(entity.Description);
    }

    private void GenerateSolidIngredients(MicrowaveMealRecipePrototype recipe)
    {
        foreach (var (product, amount) in recipe.Ingredients.Solids.OrderByDescending(p => p.Value))
        {
            var ingredient = _prototype.Index<EntityPrototype>(product);

            IngredientsGrid.AddChild(new GuideEntityEmbed(product, false, false));

            // solid name

            var solidNameMsg = new FormattedMessage();
            solidNameMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-solid-name-display", ("ingredient", ingredient.Name)));
            solidNameMsg.Pop();

            var solidNameLabel = new GuidebookRichPrototypeLink();
            solidNameLabel.SetMessage(solidNameMsg);
            solidNameLabel.LinkedPrototype = ingredient;

            IngredientsGrid.AddChild(solidNameLabel);

            // solid quantity

            var solidQuantityMsg = new FormattedMessage();
            solidQuantityMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-solid-quantity-display", ("amount", amount)));
            solidQuantityMsg.Pop();

            var solidQuantityLabel = new RichTextLabel();
            solidQuantityLabel.SetMessage(solidQuantityMsg);

            IngredientsGrid.AddChild(solidQuantityLabel);
        }
    }

    private void GenerateLiquidIngredients(MicrowaveMealRecipePrototype recipe)
    {
        foreach (var (product, amount) in recipe.Ingredients.Reagents.OrderByDescending(p => p.Value))
        {
            var reagent = _prototype.Index<ReagentPrototype>(product);

            // liquid color

            var liquidColorMsg = new FormattedMessage();
            liquidColorMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-reagent-color-display", ("color", reagent.SubstanceColor)));
            liquidColorMsg.Pop();

            var liquidColorLabel = new GuidebookRichPrototypeLink();
            liquidColorLabel.SetMessage(liquidColorMsg);
            liquidColorLabel.HorizontalAlignment = Control.HAlignment.Center;
            liquidColorLabel.LinkedPrototype = reagent;

            IngredientsGrid.AddChild(liquidColorLabel);

            // liquid name

            var liquidNameMsg = new FormattedMessage();
            liquidNameMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-reagent-name-display", ("reagent", reagent.LocalizedName)));
            liquidNameMsg.Pop();

            var liquidNameLabel = new RichTextLabel();
            liquidNameLabel.SetMessage(liquidNameMsg);

            IngredientsGrid.AddChild(liquidNameLabel);

            // liquid quantity

            var liquidQuantityMsg = new FormattedMessage();
            liquidQuantityMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-reagent-quantity-display", ("amount", amount)));
            liquidQuantityMsg.Pop();

            var liquidQuantityLabel = new RichTextLabel();
            liquidQuantityLabel.SetMessage(liquidQuantityMsg);

            IngredientsGrid.AddChild(liquidQuantityLabel);
        }
    }

    private void GenerateStackIngredients(MicrowaveMealRecipePrototype recipe)
    {
        foreach (var (product, amount) in recipe.Ingredients.Stacks.OrderByDescending(p => p.Value))
        {
            var stack = _prototype.Index(product);

            // stack icon

            IngredientsGrid.AddChild(new GuideEntityEmbed(stack.Spawn, false, false));

            // stack name

            var stackName = Loc.GetString(stack.Name);
            var stackNameMsg = new FormattedMessage();
            stackNameMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-stack-name-display", ("stack", stackName)));
            stackNameMsg.Pop();

            var stackNameLabel = new RichTextLabel();
            stackNameLabel.SetMessage(stackNameMsg);

            IngredientsGrid.AddChild(stackNameLabel);

            // stack quantity

            var stackQuantityMsg = new FormattedMessage();
            stackQuantityMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-stack-quantity-display", ("amount", amount)));
            stackQuantityMsg.Pop();

            var stackQuantityLabel = new RichTextLabel();
            stackQuantityLabel.SetMessage(stackQuantityMsg);

            IngredientsGrid.AddChild(stackQuantityLabel);
        }
    }

    private void GenerateIngredients(MicrowaveMealRecipePrototype recipe)
    {
        GenerateLiquidIngredients(recipe);
        GenerateStackIngredients(recipe);
        GenerateSolidIngredients(recipe);
    }

    private void GenerateCookTime(MicrowaveMealRecipePrototype recipe)
    {
        var msg = new FormattedMessage();
        msg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-cook-time", ("time", recipe.Time)));
        msg.Pop();

        CookTimeLabel.SetMessage(msg);
    }

    private void GenerateControl(MicrowaveMealRecipePrototype recipe)
    {
        GenerateHeader(recipe);
        GenerateIngredients(recipe);
        GenerateCookTime(recipe);
    }
}