using System.Globalization;
using System.Text;
using AcDream.Core.Items;
using AcDream.Core.Net.Messages;
using AcDream.Core.Spells;

namespace AcDream.App.UI.Layout;

/// <summary>
/// Pure text projection for retail's authored item-examination list.
/// Ordering and wording follow <c>ItemExamineUI::SetAppraiseInfo @ 0x004B72B0</c>
/// and its <c>Appraisal_Show*</c> helpers. Static spell prose comes from the
/// installed portal.dat spell table, like retail's <c>ClientMagicSystem</c>.
/// </summary>
public static class ItemAppraisalTextFormatter
{
    private static readonly (uint Requirement, uint Stat, uint Difficulty)[]
        WieldRequirements =
        [
            (158u, 159u, 160u),
            (270u, 271u, 272u),
            (273u, 274u, 275u),
            (276u, 277u, 278u),
        ];

    public static string Build(
        ClientObject obj,
        AppraiseInfoParser.Parsed appraisal,
        Func<uint, SpellMetadata?> resolveSpell,
        RetailAppraisalNameResolver? names = null)
        => BuildReport(obj, appraisal, resolveSpell, names).ToString();

    public static ItemAppraisalReport BuildReport(
        ClientObject obj,
        AppraiseInfoParser.Parsed appraisal,
        Func<uint, SpellMetadata?> resolveSpell,
        RetailAppraisalNameResolver? names = null)
    {
        ArgumentNullException.ThrowIfNull(obj);
        ArgumentNullException.ThrowIfNull(resolveSpell);
        names ??= RetailAppraisalNameResolver.Empty;

        PropertyBundle properties = appraisal.Properties;
        var report = new RetailReportBuilder();

        // ItemExamineUI::SetAppraiseInfo @ 0x004B72B0.
        ShowValueAndBurden(report, properties);
        ShowTinkering(report, properties);
        ShowSetAndRatings(report, properties);
        ShowWeaponAndArmor(report, obj, appraisal);
        ShowDefenseModifiers(report, appraisal);
        ShowArmorModifiers(report, appraisal);
        ShowShortMagicInfo(report, appraisal, resolveSpell);
        ShowSpecialProperties(report, properties, names);
        ShowUsage(report, properties);
        ShowLevelLimits(report, properties);
        ShowWieldRequirements(report, properties, names);
        ShowUsageLimits(report, properties);
        ShowItemLevel(report, properties);
        ShowActivationRequirements(
            report,
            properties,
            appraisal.Success,
            names);
        ShowCasterData(report, appraisal);
        ShowBoostAndHealing(report, obj, appraisal);
        ShowCapacityAndLock(report, obj, appraisal);
        ShowManaStone(report, appraisal);
        ShowRemainingUses(report, obj, appraisal);
        ShowCraftsman(report, properties);
        ShowSaleAndRareInfo(report, properties);
        ShowMagicInfo(report, appraisal, resolveSpell);
        ShowDescription(report, properties, names);

        return report.Build();
    }

    private static void ShowValueAndBurden(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        // Appraisal_ShowValueInfo @ 0x004ADEA0 and
        // Appraisal_ShowBurdenInfo @ 0x004AE180 query only the appraisal
        // profile. PublicWeenieDesc values must not leak through a failed or
        // deliberately incomplete assessment.
        report.Line(properties.Ints.TryGetValue(19u, out int value)
            ? $"Value: {value.ToString("N0", CultureInfo.InvariantCulture)}"
            : "Value: ???");
        report.Line(properties.Ints.TryGetValue(5u, out int burden)
            ? $"Burden: {burden.ToString("N0", CultureInfo.InvariantCulture)}"
            : "Burden: Unknown");
    }

    /// <summary>
    /// <c>Appraisal_ShowTinkeringInfo @ 0x004B0E70</c>.
    /// </summary>
    private static void ShowTinkering(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        if (properties.Ints.TryGetValue(171u, out int tinkers))
        {
            report.Line(
                $"This item has been tinkered {tinkers.ToString(CultureInfo.CurrentCulture)} "
                + (tinkers == 1 ? "time." : "times."));
        }

        string lastTinkeredBy = properties.GetString(39u);
        if (!string.IsNullOrWhiteSpace(lastTinkeredBy))
            report.Line($"Last tinkered by {lastTinkeredBy}.");
        string imbuedBy = properties.GetString(40u);
        if (!string.IsNullOrWhiteSpace(imbuedBy))
            report.Line($"Imbued by {imbuedBy}.");

        if (properties.Ints.TryGetValue(105u, out int workmanship))
        {
            if (properties.Ints.TryGetValue(170u, out int salvagedItems)
                && salvagedItems > 0)
            {
                double average = (double)workmanship / salvagedItems;
                int workmanshipBand = Math.Clamp(
                    (int)Math.Round(average),
                    0,
                    10);
                report.Line(
                    $"Workmanship: {WorkmanshipAdjective(workmanshipBand)} "
                    + $"({average.ToString("0.00", CultureInfo.CurrentCulture)})");
                report.Paragraph(
                    $"Salvaged from {salvagedItems.ToString(CultureInfo.CurrentCulture)} items.");
            }
            else
            {
                report.Line(
                    $"Workmanship: {WorkmanshipAdjective(Math.Clamp(workmanship, 0, 10))} "
                    + $"({workmanship.ToString(CultureInfo.CurrentCulture)})");
            }
        }

        // Appraisal_ShowTinkeringInfo @ 0x004B1090 appends an empty
        // AddItemInfo entry unconditionally, establishing the next section.
        report.BlankLine();
    }

    /// <summary>
    /// <c>Appraisal_ShowSet @ 0x004AE880</c> and
    /// <c>Appraisal_ShowRatings @ 0x004AF080</c>.
    /// </summary>
    private static void ShowSetAndRatings(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        string? setName = properties.Ints.TryGetValue(265u, out int setId)
            ? EquipmentSetName(setId)
            : null;
        bool setShown = setName is not null;
        if (setShown)
            report.Line($"Set: {setName}");

        (uint Property, string Label)[] ratingProperties =
        [
            (370u, "Dam"),
            (371u, "Dam Resist"),
            (372u, "Crit"),
            (374u, "Crit Dam"),
            (373u, "Crit Resist"),
            (375u, "Crit Dam Resist"),
            (376u, "Heal Boost"),
            (377u, "Nether Resist"),
            (378u, "Life Resist"),
        ];
        string[] ratings = ratingProperties
            .Where(pair => properties.Ints.TryGetValue(pair.Property, out int value)
                           && value > 0)
            .Select(pair =>
                $"{pair.Label} {properties.GetInt(pair.Property).ToString(CultureInfo.CurrentCulture)}")
            .ToArray();
        bool ratingsShown = ratings.Length != 0;
        if (ratingsShown)
            report.Line($"Ratings: {string.Join(", ", ratings)}");
        if (properties.GetInt(379u) is int vitality && vitality > 0)
        {
            report.Line(
                $"This item adds {vitality.ToString(CultureInfo.CurrentCulture)} Vitality.");
            ratingsShown = true;
        }

        // Appraisal_ShowRatings terminates its emitted block with an empty
        // append; SetAppraiseInfo adds another when either Set or Ratings
        // contributed content.
        if (ratingsShown)
            report.BlankLine();
        if (setShown || ratingsShown)
            report.BlankLine();
    }

    /// <summary>
    /// <c>Appraisal_ShowWeaponAndArmorData @ 0x004B10E0</c> and
    /// <c>Appraisal_ShowArmorModsData @ 0x004B1F60</c>.
    /// </summary>
    private static void ShowWeaponAndArmor(
        RetailReportBuilder report,
        ClientObject obj,
        AppraiseInfoParser.Parsed appraisal)
    {
        PropertyBundle properties = appraisal.Properties;
        uint validLocations = obj.IsHook && appraisal.HookProfile is { } hook
            ? hook.ValidLocations
            : (uint)obj.ValidLocations;
        uint ammoType = obj.IsHook && appraisal.HookProfile is { } hookProfile
            ? hookProfile.AmmoType
            : obj.AmmoType ?? 0u;
        const uint weaponAndShieldLocations = 0x03F0_0000u;
        bool hasWeaponOrShieldLocation =
            (validLocations & weaponAndShieldLocations) != 0u;

        if (hasWeaponOrShieldLocation
            && (validLocations & (uint)EquipMask.Shield) != 0)
        {
            if (properties.Ints.TryGetValue(28u, out int shieldLevel))
                report.Line(
                    $"Base Shield Level: {shieldLevel.ToString(CultureInfo.CurrentCulture)}",
                    EnchantmentStyle(
                        appraisal.ArmorEnchantments,
                        0x0001u));
            else
                report.Line("Shield Level: Unknown");
        }

        if (hasWeaponOrShieldLocation
            && appraisal.WeaponProfile is { } weapon)
        {
            string skill = SkillName((int)weapon.WeaponSkill);
            int weaponType = properties.GetInt(353u);
            report.Line(
                $"Skill: {skill}{WeaponSubtype(weaponType)}");

            bool launcher = (validLocations & (uint)EquipMask.MissileWeapon) != 0
                            && ammoType != 0u;
            string damageLabel = launcher ? "Damage Bonus" : "Damage";
            string damage;
            if (weapon.Damage == uint.MaxValue)
            {
                damage = "Unknown";
            }
            else
            {
                double minimumDamage =
                    (1d - weapon.DamageVariance) * weapon.Damage;
                damage = weapon.Damage - minimumDamage > 0.0002d
                    ? $"{FormatRetailDamage(minimumDamage)}"
                      + $" - {weapon.Damage.ToString(CultureInfo.CurrentCulture)}"
                    : weapon.Damage.ToString(CultureInfo.CurrentCulture);
                if (!launcher)
                {
                    damage += TryDamageTypeName(weapon.DamageType, out string? type)
                        ? $", {type}"
                        : ", unknown type";
                }
            }
            ItemAppraisalFontStyle damageStyle = EnchantmentStyle(
                appraisal.WeaponEnchantments,
                0x0008u);
            if (damageStyle == ItemAppraisalFontStyle.Normal)
            {
                damageStyle = EnchantmentStyle(
                    appraisal.WeaponEnchantments,
                    0x0010u);
            }
            report.Line($"{damageLabel}: {damage}", damageStyle);

            int elementalBonus = properties.GetInt(204u);
            if (elementalBonus > 0)
                report.Line(
                    $"Elemental Damage Bonus: "
                    + $"{elementalBonus.ToString(CultureInfo.CurrentCulture)}, "
                    + $"{DamageTypeName(weapon.DamageType)}.");

            if (launcher)
            {
                report.Line(
                    appraisal.Success
                        ? $"Damage Modifier: {FormatModifier(weapon.DamageMod)}."
                        : "Damage Modifier: Unknown",
                    EnchantmentStyle(
                        appraisal.WeaponEnchantments,
                        0x0020u));
            }

            const uint timedWeaponLocations =
                (uint)(EquipMask.MeleeWeapon
                       | EquipMask.MissileWeapon
                       | EquipMask.TwoHanded);
            if ((validLocations & timedWeaponLocations) != 0)
            {
                report.Line(
                    weapon.WeaponTime == uint.MaxValue
                        ? "Speed:  Unknown"
                        : $"Speed: {WeaponTimeName((int)weapon.WeaponTime)} "
                          + $"({weapon.WeaponTime.ToString(CultureInfo.CurrentCulture)})",
                    EnchantmentStyle(
                        appraisal.WeaponEnchantments,
                        0x0004u));
            }

            if (launcher)
            {
                if (!appraisal.Success)
                {
                    report.Line("Range:  Unknown");
                }
                else
                {
                    // Appraisal_ShowWeaponAndArmorData @ 0x004B1845:
                    // 2*v^2/g, converted from meters to yards and capped at 85.
                    double rawRange = Math.Min(
                        85d,
                        2d * Math.Pow(weapon.MaxVelocity, 2d)
                        * (1d / 9.8d)
                        * 1.094d);
                    int range = rawRange < 10d
                        ? (int)Math.Ceiling(rawRange)
                        : (int)rawRange - (int)rawRange % 5;
                    report.Line(
                        $"Range: {range.ToString(CultureInfo.CurrentCulture)} yds."
                        + (weapon.MaxVelocityEstimated != 0u
                            ? " (based on STRENGTH 100)"
                            : string.Empty));
                }
            }

            if (!launcher && Math.Abs(weapon.WeaponOffense - 1d) > 0.000001d)
                report.Line(
                    $"Bonus to Attack Skill: "
                    + $"{FormatSignedPercent(weapon.WeaponOffense - 1d)}.",
                    EnchantmentStyle(
                        appraisal.WeaponEnchantments,
                        0x0001u));
        }

        ShowAmmunitionDescription(report, validLocations, ammoType);

        if (!hasWeaponOrShieldLocation
            && (validLocations & 0x0800_7FFFu) != 0u
            && ClothingCoverage(obj.Priority) is { Length: > 0 } coverage)
        {
            report.Line($"Covers {coverage}");
        }
    }

    /// <summary><c>Appraisal_ShowArmorModsData @ 0x004B1F60</c>.</summary>
    private static void ShowArmorModifiers(
        RetailReportBuilder report,
        AppraiseInfoParser.Parsed appraisal)
    {
        if (appraisal.ArmorProfile is not { } armor
            || !appraisal.Properties.Ints.TryGetValue(28u, out int armorLevel)
            || armorLevel <= 0)
        {
            return;
        }

        // Retail's first armor string begins with a literal '\n' before
        // AddItemInfo adds its ordinary separator.
        report.Paragraph(
            $"Armor Level: {armorLevel.ToString(CultureInfo.CurrentCulture)}",
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0001u));
        ShowProtection(
            report, "Slashing", armorLevel, armor.SlashingProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0002u));
        ShowProtection(
            report, "Piercing", armorLevel, armor.PiercingProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0004u));
        ShowProtection(
            report, "Bludgeoning", armorLevel, armor.BludgeoningProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0008u));
        ShowProtection(
            report, "Fire", armorLevel, armor.FireProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0020u));
        ShowProtection(
            report, "Cold", armorLevel, armor.ColdProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0010u));
        ShowProtection(
            report, "Acid", armorLevel, armor.AcidProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0040u));
        ShowProtection(
            report, "Electric", armorLevel, armor.LightningProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0080u));
        ShowProtection(
            report, "Nether", armorLevel, armor.NetherProtection,
            EnchantmentStyle(appraisal.ArmorEnchantments, 0x0100u));
    }

    private static void ShowAmmunitionDescription(
        RetailReportBuilder report,
        uint validLocations,
        uint ammoType)
    {
        if (ammoType == 0u)
            return;

        // Retail gives the crystal and chorizite variants their own bits
        // (acclient.h:4221); each folds back to the base kind for this sentence.
        AmmoType baseAmmoType = (AmmoType)ammoType switch
        {
            AmmoType.ArrowCrystal or AmmoType.ArrowChorizite => AmmoType.Arrow,
            AmmoType.BoltCrystal or AmmoType.BoltChorizite => AmmoType.Bolt,
            AmmoType.AtlatlCrystal or AmmoType.AtlatlChorizite => AmmoType.Atlatl,
            var other => other,
        };
        bool launcher = (validLocations & (uint)EquipMask.MissileWeapon) != 0;
        string? description = (launcher, baseAmmoType) switch
        {
            (true, AmmoType.Arrow) => "Uses arrows as ammunition.",
            (true, AmmoType.Bolt) => "Uses quarrels as ammunition.",
            (true, AmmoType.Atlatl) => "Uses atlatl darts as ammunition.",
            (false, AmmoType.Arrow) => "Used as ammunition by bows.",
            (false, AmmoType.Bolt) => "Used as ammunition by crossbows.",
            (false, AmmoType.Atlatl) => "Used as ammunition by atlatls.",
            _ => null,
        };
        if (description is not null)
            report.Line(description);
    }

    private static void ShowProtection(
        RetailReportBuilder report,
        string damageType,
        int armorLevel,
        float modifier,
        ItemAppraisalFontStyle style)
    {
        // AppraisalSystem::DamageResistanceToString @ 0x005B5490.
        string quality = modifier switch
        {
            <= 0.0002f => "None",
            < 0.4f => "Poor",
            < 0.8f => "Below Average",
            < 1.2f => "Average",
            < 1.6f => "Above Average",
            < 2.0f => "Excellent",
            _ => "Unparalleled",
        };
        double effective = armorLevel * modifier;
        report.Line(
            $"{damageType}: {quality}  "
            + $"({effective.ToString("0", CultureInfo.CurrentCulture)})",
            style);
    }

    /// <summary><c>Appraisal_ShowDefenseModData @ 0x004B1DF0</c>.</summary>
    private static void ShowDefenseModifiers(
        RetailReportBuilder report,
        AppraiseInfoParser.Parsed appraisal)
    {
        PropertyBundle properties = appraisal.Properties;
        ShowModifier(
            report,
            properties,
            29u,
            "Bonus to Melee Defense",
            EnchantmentStyle(appraisal.WeaponEnchantments, 0x0002u));
        ShowModifier(report, properties, 149u, "Bonus to Missile Defense");
        ShowModifier(report, properties, 150u, "Bonus to Magic Defense");
    }

    private static void ShowModifier(
        RetailReportBuilder report,
        PropertyBundle properties,
        uint property,
        string label,
        ItemAppraisalFontStyle style = ItemAppraisalFontStyle.Normal)
    {
        if (!properties.Floats.TryGetValue(property, out double modifier)
            || Math.Abs(modifier - 1d) <= 0.000001d)
            return;
        report.Line(
            $"{label}: {FormatSignedPercent(modifier - 1d)}.",
            style);
    }

    /// <summary><c>Appraisal_ShowShortMagicInfo @ 0x004B2C90</c>.</summary>
    private static void ShowShortMagicInfo(
        RetailReportBuilder report,
        AppraiseInfoParser.Parsed appraisal,
        Func<uint, SpellMetadata?> resolveSpell)
    {
        if (appraisal.SpellBook.Length == 0)
            return;
        if (!appraisal.Success)
        {
            report.Paragraph("Spells: unknown.");
            return;
        }

        uint[] ordinary = appraisal.SpellBook
            .Where(raw => (raw & 0x8000_0000u) == 0u)
            .ToArray();
        if (ordinary.Length == 0)
            return;

        string names = string.Join(
            ", ",
            ordinary.Select(raw =>
            {
                return resolveSpell(raw)?.Name
                       ?? $"Spell {raw.ToString(CultureInfo.CurrentCulture)}";
            }));
        report.Paragraph($"Spells: {names}");
    }

    /// <summary><c>Appraisal_ShowSpecialProperties @ 0x004B0140</c>.</summary>
    private static void ShowSpecialProperties(
        RetailReportBuilder report,
        PropertyBundle properties,
        RetailAppraisalNameResolver names)
    {
        // Appraisal_ShowSpecialProperties @ 0x004B0159.
        report.BlankLine();

        int carryLimit = properties.GetInt(279u);
        if (carryLimit > 0)
        {
            report.BlankLine();
            report.Line(
                $"You can only carry "
                + $"{carryLimit.ToString("N0", CultureInfo.CurrentCulture)} "
                + "of these items.");
        }

        if (properties.Floats.TryGetValue(167u, out double cooldown)
            && cooldown > 0d)
        {
            report.Line($"Cooldown When Used: {FormatDeltaTime(cooldown)}");
            if (properties.Ints.ContainsKey(280u))
                report.BlankLine();
        }

        int cleave = properties.GetInt(292u);
        if (cleave > 1)
        {
            report.Line(
                $"Cleave: {cleave.ToString(CultureInfo.CurrentCulture)} enemies in front arc.");
            report.BlankLine();
        }

        var special = new List<string>();
        int slayer = properties.GetInt(166u);
        if (slayer != 0)
        {
            string slayerName = slayer == 31
                ? "Bael'Zharon's Hate"
                : names.ResolveCreature(slayer);
            if (!string.IsNullOrWhiteSpace(slayerName))
            {
                special.Add(slayer == 31
                    ? slayerName
                    : $"{slayerName} slayer");
            }
        }
        if ((properties.GetInt(47u) & 0x79E0) != 0)
            special.Add("Multi-Strike");

        uint imbuedEffects = unchecked((uint)(
            properties.GetInt(179u)
            | properties.GetInt(303u)
            | properties.GetInt(304u)
            | properties.GetInt(305u)
            | properties.GetInt(306u)));
        AppendImbuedEffects(special, imbuedEffects);

        if (properties.Floats.ContainsKey(159u))
            special.Add("Magic Absorbing");
        if (properties.GetInt(36u) >= 9_999)
            special.Add("Unenchantable");

        int attuned = properties.GetInt(114u);
        if (attuned is 1 or 2)
            special.Add("Attuned");
        int bonded = properties.GetInt(33u);
        switch (bonded)
        {
            case -2:
                special.Add("Destroyed on Death");
                break;
            case -1:
                special.Add("Dropped on Death");
                break;
            case 1:
                special.Add("Bonded");
                break;
        }

        if (properties.GetBool(91u))
            special.Add("Retained");
        if (properties.Floats.ContainsKey(136u))
            special.Add("Crushing Blow");
        if (properties.Floats.ContainsKey(147u))
            special.Add("Biting Strike");
        if (properties.Floats.ContainsKey(155u))
            special.Add("Armor Cleaving");
        if (properties.Floats.ContainsKey(157u)
            && properties.Ints.TryGetValue(263u, out int resistanceType))
            special.Add(
                $"Resistance Cleaving: {DamageTypeName((uint)resistanceType)}");
        if (properties.DataIds.ContainsKey(55u))
            special.Add("Cast on Strike");
        if (properties.GetBool(99u))
            special.Add("Ivoryable");
        if (properties.GetBool(100u))
            special.Add("Dyeable");

        if (special.Count != 0)
            report.Line($"Properties: {string.Join(", ", special)}");
        if (imbuedEffects != 0u)
            report.Line("This item cannot be further imbued.");
        if (properties.GetBool(130u))
            report.Line("This item is tethered to the left side.");
    }

    private static void AppendImbuedEffects(
        List<string> properties,
        uint imbuedEffects)
    {
        (uint Flag, string Text)[] names =
        [
            (0x0000_0001u, "Critical Strike"),
            (0x0000_0002u, "Crippling Blow"),
            (0x0000_0004u, "Armor Rending"),
            (0x0000_0008u, "Slash Rending"),
            (0x0000_0010u, "Pierce Rending"),
            (0x0000_0020u, "Bludgeon Rending"),
            (0x0000_0040u, "Acid Rending"),
            (0x0000_0080u, "Cold Rending"),
            (0x0000_0100u, "Lightning Rending"),
            (0x0000_0200u, "Fire Rending"),
            (0x0000_0400u, "+1 Melee Defense"),
            (0x0000_0800u, "+1 Missile Defense"),
            (0x0000_1000u, "+1 Magic Defense"),
            (0x0000_4000u, "Nether Rending"),
            (0x8000_0000u, "Phantasmal"),
        ];
        foreach ((uint flag, string text) in names)
            if ((imbuedEffects & flag) != 0)
                properties.Add(text);
    }

    private static void ShowUsage(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        string use = properties.GetString(14u);
        if (!string.IsNullOrWhiteSpace(use))
            report.Paragraph(use);
    }

    private static void ShowLevelLimits(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        int minimum = properties.GetInt(86u);
        int maximum = properties.GetInt(87u);
        if (minimum > 0 && maximum > 0)
        {
            report.Paragraph(minimum == maximum
                ? $"Restricted to characters of Level "
                  + $"{minimum.ToString(CultureInfo.CurrentCulture)}."
                : $"Restricted to characters of Levels "
                  + $"{minimum.ToString(CultureInfo.CurrentCulture)} to "
                  + $"{maximum.ToString(CultureInfo.CurrentCulture)}.");
        }
        else if (minimum > 0)
            report.Paragraph(
                $"Restricted to characters of Level "
                + $"{minimum.ToString(CultureInfo.CurrentCulture)} or greater.");
        else if (maximum > 0)
            report.Paragraph(
                $"Restricted to characters of Level "
                + $"{maximum.ToString(CultureInfo.CurrentCulture)} or below.");

        string destination = properties.GetString(38u);
        if (!string.IsNullOrWhiteSpace(destination))
            report.Paragraph($"Destination: {destination}");
    }

    /// <summary><c>Appraisal_ShowWieldRequirements @ 0x004AF9A0</c>.</summary>
    private static void ShowWieldRequirements(
        RetailReportBuilder report,
        PropertyBundle properties,
        RetailAppraisalNameResolver names)
    {
        if (properties.GetBool(85u))
        {
            string owner = properties.GetString(25u);
            report.Line(
                $"Wield requires "
                + $"{(string.IsNullOrWhiteSpace(owner) ? "the original owner" : owner)}");
        }
        if (properties.GetInt(26u) == 1)
            report.Line("Use requires Throne of Destiny.");

        // ItemExamineUI::Appraisal_ShowWieldRequirements @ 0x004AF9A0
        // queries the direct HeritageGroup property before the four generic
        // requirement triplets.
        if (properties.Ints.TryGetValue(324u, out int heritage))
        {
            string heritageName = names.ResolveHeritage(heritage);
            if (!string.IsNullOrEmpty(heritageName))
                report.Line($"Wield requires {heritageName}");
        }

        for (int index = 0; index < WieldRequirements.Length; index++)
        {
            (uint requirementId, uint statId, uint difficultyId) =
                WieldRequirements[index];
            if (!properties.Ints.TryGetValue(requirementId, out int requirement)
                || !properties.Ints.TryGetValue(statId, out int stat)
                || !properties.Ints.TryGetValue(difficultyId, out int difficulty))
                continue;

            string quality = RequirementQuality(
                requirement,
                stat,
                difficulty,
                names);
            if (requirement == 8)
            {
                string training = difficulty == 3
                    ? index == 3 ? "Specialized" : "specialized"
                    : index == 3 ? "Trained" : "trained";
                report.Line($"Wield requires {training} {quality}");
            }
            else if (requirement == 11)
            {
                report.Line($"Wield requires {quality} type");
            }
            else if (requirement == 12)
            {
                report.Line($"Wield requires {quality} race");
            }
            else if (!string.IsNullOrEmpty(quality))
            {
                report.Line(
                    $"Wield requires {quality} "
                    + $"{difficulty.ToString(CultureInfo.CurrentCulture)}");
            }
        }
    }

    private static string RequirementQuality(
        int requirement,
        int stat,
        int difficulty,
        RetailAppraisalNameResolver names)
    {
        string basePrefix = requirement is 2 or 4 or 6 ? "base " : string.Empty;
        return requirement switch
        {
            1 or 2 or 8 => basePrefix + SkillName(stat),
            3 or 4 => basePrefix + PrimaryAttributeName(stat),
            5 or 6 => basePrefix + SecondaryAttributeName(stat),
            7 => "level",
            9 or 10 => stat switch
            {
                0x11F => "Standing with the Celestial Hand",
                0x120 => "Standing with the Eldrytch Web",
                0x121 => "Standing with the Radiant Blood",
                _ => "unknown quality",
            },
            11 => names.ResolveCreature(difficulty),
            12 => names.ResolveHeritage(difficulty),
            _ => string.Empty,
        };
    }

    /// <summary><c>Appraisal_ShowUsageLimits @ 0x004B2A70</c>.</summary>
    private static void ShowUsageLimits(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        int level = properties.GetInt(369u);
        int skill = properties.GetInt(366u);
        int difficulty = properties.GetInt(367u);
        int specializedSkill = properties.GetInt(368u);
        if (level > 0
            || (skill > 0 && difficulty > 0)
            || specializedSkill > 0)
        {
            report.BlankLine();
        }

        if (level > 0)
            report.Line(
                $"Use requires level {level.ToString(CultureInfo.CurrentCulture)}.");
        if (skill > 0 && difficulty > 0)
            report.Line(
                $"Use requires {UsageSkillName(skill)} of at least "
                + $"{difficulty.ToString(CultureInfo.CurrentCulture)}.");
        if (specializedSkill > 0)
            report.Line(
                $"Use requires specialized {UsageSkillName(specializedSkill)}.");
    }

    /// <summary><c>Appraisal_ShowItemLevel @ 0x004B3C60</c>.</summary>
    private static void ShowItemLevel(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        if (!properties.Int64s.TryGetValue(5u, out long baseExperience)
            || baseExperience <= 0
            || !properties.Ints.TryGetValue(319u, out int maximum)
            || maximum <= 0
            || !properties.Ints.TryGetValue(320u, out int style)
            || style <= 0)
        {
            return;
        }

        long experience = Math.Max(0, properties.GetInt64(4u));
        int currentLevel = ItemTotalXpToLevel(
            experience,
            baseExperience,
            maximum,
            style);
        int displayedLevel = Math.Min(currentLevel + 1, maximum);
        long nextExperience = ItemLevelToTotalXp(
            Math.Min(currentLevel + 1, maximum),
            baseExperience,
            maximum,
            style);

        report.Line(
            $"Item Level: {displayedLevel.ToString(CultureInfo.CurrentCulture)} / "
            + $"{maximum.ToString(CultureInfo.CurrentCulture)}");
        report.Line(
            $"Item XP: {experience.ToString("N0", CultureInfo.CurrentCulture)} / "
            + $"{nextExperience.ToString("N0", CultureInfo.CurrentCulture)}");
        report.BlankLine();

        if (properties.GetInt(352u) == 2)
        {
            report.Line(
                "This cloak has a chance to reduce an incoming attack by 200 damage.");
            report.BlankLine();
        }
    }

    /// <summary>
    /// <c>Appraisal_ShowActivationRequirements @ 0x004B3270</c>.
    /// </summary>
    private static void ShowActivationRequirements(
        RetailReportBuilder report,
        PropertyBundle properties,
        bool appraisalSucceeded,
        RetailAppraisalNameResolver names)
    {
        if (!appraisalSucceeded)
            return;

        var requirements = new List<string>();
        AddRequirement(requirements, "Arcane Lore", properties.GetInt(109u));
        AddRequirement(requirements, "Allegiance Rank", properties.GetInt(110u));

        int heritage = properties.GetInt(188u);
        if (heritage != 0
            && names.ResolveHeritage(heritage) is { Length: > 0 } heritageName)
        {
            requirements.Add(heritageName);
        }

        int skillLevel = properties.GetInt(115u);
        int skill = properties.GetInt(176u);
        if (skillLevel > 0 && skill > 0)
            requirements.Add(
                $"{UsageSkillName(skill)}: {skillLevel.ToString(CultureInfo.CurrentCulture)}");
        int attributeLevel = properties.GetInt(258u);
        int attribute = properties.GetInt(257u);
        if (attributeLevel > 0 && attribute > 0)
            requirements.Add(
                $"{PrimaryAttributeName(attribute)}: "
                + $"{attributeLevel.ToString(CultureInfo.CurrentCulture)}");
        int secondaryLevel = properties.GetInt(260u);
        int secondary = properties.GetInt(259u);
        if (secondaryLevel > 0 && secondary > 0)
            requirements.Add(
                $"{SecondaryAttributeName(secondary)}: "
                + $"{secondaryLevel.ToString(CultureInfo.CurrentCulture)}");

        if (requirements.Count != 0)
            report.Line($"Activation requires {string.Join(", ", requirements)}");
        if (properties.GetBool(94u))
        {
            string owner = properties.GetString(25u);
            report.Line(
                $"This item can only be activated by "
                + $"{(string.IsNullOrWhiteSpace(owner) ? "the original owner" : owner)}.");
        }
    }

    private static void AddRequirement(
        List<string> requirements,
        string name,
        int value)
    {
        if (value > 0)
            requirements.Add(
                $"{name}: {value.ToString(CultureInfo.CurrentCulture)}");
    }

    /// <summary><c>Appraisal_ShowCasterData @ 0x004B1B10</c>.</summary>
    private static void ShowCasterData(
        RetailReportBuilder report,
        AppraiseInfoParser.Parsed appraisal)
    {
        PropertyBundle properties = appraisal.Properties;
        if (properties.Floats.TryGetValue(144u, out double manaConversion))
            report.Paragraph(
                $"Bonus to Mana Conversion: "
                + $"{FormatSignedPercent(manaConversion)}.",
                EnchantmentStyle(
                    appraisal.ResistEnchantments,
                    0x1000u));

        if (properties.Floats.TryGetValue(152u, out double elemental)
            && properties.Ints.TryGetValue(45u, out int damageType))
        {
            report.Paragraph(
                $"Damage bonus for {DamageTypeName((uint)damageType)} spells:",
                EnchantmentStyle(
                    appraisal.ResistEnchantments,
                    0x2000u));
            report.Line($" vs. Monsters: {FormatSignedPercent(elemental - 1d)}.");
            double playerModifier = 1d + (elemental - 1d) * 0.25d;
            report.Line(
                $" vs. Players: {FormatSignedPercent(playerModifier - 1d)}.");
        }
    }

    /// <summary>
    /// <c>Appraisal_ShowBoostValue @ 0x004B2480</c> and
    /// <c>Appraisal_ShowHealKitData @ 0x004B25A0</c>.
    /// </summary>
    private static void ShowBoostAndHealing(
        RetailReportBuilder report,
        ClientObject obj,
        AppraiseInfoParser.Parsed appraisal)
    {
        PropertyBundle properties = appraisal.Properties;
        bool healer =
            ((PublicWeenieFlags)obj.PublicWeenieBitfield.GetValueOrDefault()
             & PublicWeenieFlags.Healer) != 0
            || obj.IsHook
            && appraisal.HookProfile is { } hook
            && (hook.Flags & 0x2u) != 0u;
        int boost = properties.GetInt(90u);
        string? boostText = properties.GetInt(89u) switch
        {
            2 => $"{(boost >= 0 ? "Restores" : "Depletes")} "
                 + $"{Math.Abs(boost).ToString(CultureInfo.CurrentCulture)} "
                 + "Health when used.",
            4 => $"{(boost >= 0 ? "Restores" : "Depletes")} "
                 + $"{Math.Abs(boost).ToString(CultureInfo.CurrentCulture)} "
                 + "Stamina when consumed.",
            6 => $"{(boost >= 0 ? "Restores" : "Depletes")} "
                 + $"{Math.Abs(boost).ToString(CultureInfo.CurrentCulture)} "
                 + "Mana when used.",
            _ => null,
        };
        if (!healer && boostText is not null
            && properties.Ints.ContainsKey(90u))
        {
            report.Paragraph(boostText);
        }

        if (!healer)
            return;

        if (properties.Ints.TryGetValue(90u, out int healingBonus))
            report.Paragraph(
                $"Bonus to Healing Skill: {healingBonus.ToString(CultureInfo.CurrentCulture)}");
        if (properties.Floats.TryGetValue(100u, out double healKitModifier))
            report.Line(
                $"Restoration Bonus: "
                + $"{(healKitModifier * 100d).ToString("0", CultureInfo.CurrentCulture)}%");
    }

    /// <summary>
    /// <c>Appraisal_ShowCapacity @ 0x004B2680</c> and
    /// <c>Appraisal_ShowLockData @ 0x004B2790</c>.
    /// </summary>
    private static void ShowCapacityAndLock(
        RetailReportBuilder report,
        ClientObject obj,
        AppraiseInfoParser.Parsed appraisal)
    {
        PropertyBundle properties = appraisal.Properties;
        // Appraisal_ShowCapacity @ 0x004B2680 suppresses a hook object's own
        // capacity while a HookProfile describes the item mounted on it.
        // Non-container sentinels are independently preserved as -1 by
        // PublicWeenieDesc::UnPack's signed-byte loads, so they fail the
        // positive-capacity tests below exactly as they do in retail.
        if (!obj.IsHook || appraisal.HookProfile is null)
        {
            if (obj.ItemsCapacity > 0 && obj.ContainersCapacity > 0)
                report.Paragraph(
                    $"Can hold up to {obj.ItemsCapacity.ToString(CultureInfo.CurrentCulture)} "
                    + $"items and {obj.ContainersCapacity.ToString(CultureInfo.CurrentCulture)} containers.");
            else if (obj.ItemsCapacity > 0)
                report.Paragraph(
                    $"Can hold up to {obj.ItemsCapacity.ToString(CultureInfo.CurrentCulture)} items.");
            else if (obj.ContainersCapacity > 0)
                report.Paragraph(
                    $"Can hold up to {obj.ContainersCapacity.ToString(CultureInfo.CurrentCulture)} containers.");

            int pages = properties.GetInt(175u);
            int pagesUsed = properties.GetInt(174u);
            if (pages > 0)
                report.Paragraph(
                    $"{pagesUsed.ToString(CultureInfo.CurrentCulture)} of "
                    + $"{pages.ToString(CultureInfo.CurrentCulture)} pages full.");
        }

        // Appraisal_ShowLockAppraiseInfo @ 0x004B2790 does not present lock
        // data for hook objects.
        if (obj.IsHook)
            return;

        bool hasLocked = properties.Bools.TryGetValue(3u, out bool locked);
        bool hasResistance = properties.Ints.TryGetValue(
            38u,
            out int resistance);
        if (!hasLocked)
        {
            if (hasResistance && resistance != 0)
            {
                report.Paragraph(
                    $"Bonus to Lockpick Skill: "
                    + $"{resistance.ToString("+0;-0;0", CultureInfo.CurrentCulture)}");
            }
            return;
        }

        if (!locked)
        {
            report.Paragraph("Unlocked");
            return;
        }

        report.Paragraph("Locked");
        if (!hasResistance)
        {
            report.Paragraph("You can't tell how hard the lock is to pick.");
            return;
        }

        if (properties.Ints.TryGetValue(173u, out int chance)
            && LockpickDifficulty(chance) is { } difficulty)
        {
            report.Paragraph(
                $"The lock looks {difficulty} to pick "
                + $"(Resistance {resistance.ToString(CultureInfo.CurrentCulture)}).");
        }
    }

    /// <summary><c>Appraisal_ShowManaStoneInfo @ 0x004B3900</c>.</summary>
    private static void ShowManaStone(
        RetailReportBuilder report,
        AppraiseInfoParser.Parsed appraisal)
    {
        if (appraisal.SpellBook.Length != 0)
            return;
        PropertyBundle properties = appraisal.Properties;
        if (properties.Ints.TryGetValue(107u, out int storedMana))
            report.Line(
                $"Stored Mana: {storedMana.ToString(CultureInfo.CurrentCulture)}");
        if (properties.Floats.TryGetValue(87u, out double efficiency))
            report.Line(
                $"Efficiency: {(efficiency * 100d).ToString("0", CultureInfo.CurrentCulture)}%");
        if (properties.Floats.TryGetValue(137u, out double destruction))
            report.Line(
                $"Chance of Destruction: "
                + $"{(destruction * 100d).ToString("0", CultureInfo.CurrentCulture)}%");
    }

    /// <summary><c>Appraisal_ShowRemainingUses @ 0x004B3A20</c>.</summary>
    private static void ShowRemainingUses(
        RetailReportBuilder report,
        ClientObject obj,
        AppraiseInfoParser.Parsed appraisal)
    {
        PropertyBundle properties = appraisal.Properties;
        if (properties.Ints.TryGetValue(193u, out int keys))
            report.Line(
                $"Contains {keys.ToString(CultureInfo.CurrentCulture)} "
                + (keys == 1 ? "key." : "keys."));

        if (properties.GetBool(63u))
        {
            report.Line("Number of uses remaining:  Unlimited");
            return;
        }

        if (properties.Ints.TryGetValue(92u, out int uses))
        {
            report.Line(
                $"Number of uses remaining: {uses.ToString(CultureInfo.CurrentCulture)}");
            return;
        }

        var publicFlags =
            (PublicWeenieFlags)obj.PublicWeenieBitfield.GetValueOrDefault();
        if (!appraisal.Success
            && ((publicFlags
                 & (PublicWeenieFlags.Healer | PublicWeenieFlags.Lockpick)) != 0
                || appraisal.HookProfile is { Flags: var flags }
                && (flags & 0xAu) != 0))
        {
            report.Paragraph("Number of uses remaining:  Unknown");
        }
    }

    private static void ShowCraftsman(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        string craftsman = properties.GetString(25u);
        if (!string.IsNullOrWhiteSpace(craftsman)
            && !properties.GetBool(85u)
            && !properties.GetBool(94u))
            report.Line($"Created by {craftsman}.");
    }

    private static void ShowSaleAndRareInfo(
        RetailReportBuilder report,
        PropertyBundle properties)
    {
        if (properties.Bools.TryGetValue(69u, out bool sellable) && !sellable)
            report.Line("This item cannot be sold.");
        if (properties.GetBool(108u))
        {
            report.Paragraph(
                "This rare item has a timer restriction of 3 minutes. "
                + "You will not be able to use another rare item with a timer "
                + "within 3 minutes of using this one.");
        }
        int rare = properties.GetInt(17u);
        if (rare > 0)
            report.Paragraph($"Rare #{rare.ToString(CultureInfo.CurrentCulture)}");
    }

    /// <summary><c>Appraisal_ShowMagicInfo @ 0x004B2E10</c>.</summary>
    private static void ShowMagicInfo(
        RetailReportBuilder report,
        AppraiseInfoParser.Parsed appraisal,
        Func<uint, SpellMetadata?> resolveSpell)
    {
        if (appraisal.SpellBook.Length == 0)
            return;
        if (!appraisal.Success)
        {
            report.Paragraph("Spells: unknown.");
            return;
        }

        var ordinary = new List<(uint Id, SpellMetadata? Metadata)>();
        var enchantments = new List<(uint Id, SpellMetadata? Metadata)>();
        foreach (uint rawSpellId in appraisal.SpellBook)
        {
            uint spellId = rawSpellId & 0x7FFF_FFFFu;
            var spell = (spellId, resolveSpell(spellId));
            if ((rawSpellId & 0x8000_0000u) == 0)
                ordinary.Add(spell);
            else
                enchantments.Add(spell);
        }

        PropertyBundle properties = appraisal.Properties;
        if (ordinary.Count != 0)
        {
            if (properties.Ints.TryGetValue(106u, out int spellcraft))
                report.Line(
                    $"Spellcraft: {spellcraft.ToString(CultureInfo.CurrentCulture)}.");
            if (properties.Ints.TryGetValue(107u, out int currentMana)
                && properties.Ints.TryGetValue(108u, out int maximumMana))
                report.Line(
                    $"Mana: {currentMana.ToString(CultureInfo.CurrentCulture)} / "
                    + $"{maximumMana.ToString(CultureInfo.CurrentCulture)}.");

            if (properties.Floats.TryGetValue(5u, out double manaRate)
                && Math.Abs(manaRate) > 0.000001d)
            {
                int seconds = (int)Math.Round(1d / manaRate);
                report.Line(
                    $"Mana Cost: 1 point per {seconds.ToString(CultureInfo.CurrentCulture)} "
                    + (seconds == 1 ? "second." : "seconds."));
            }
            else if (properties.Ints.TryGetValue(117u, out int manaCost))
            {
                string manaCostText =
                    $"Mana Cost: {manaCost.ToString(CultureInfo.CurrentCulture)}.";
                if (manaCost > 0)
                {
                    manaCostText +=
                        "\n(Can be reduced by the Mana Conversion skill).";
                }
                report.Paragraph(manaCostText);
            }

            report.Paragraph(BuildSpellDescriptionBlock(
                "Spell Descriptions:",
                ordinary));
        }

        if (enchantments.Count != 0)
        {
            report.Paragraph(BuildSpellDescriptionBlock(
                "Enchantments:",
                enchantments));
        }
    }

    private static string BuildSpellDescriptionBlock(
        string heading,
        IReadOnlyList<(uint Id, SpellMetadata? Metadata)> spells)
    {
        var text = new StringBuilder(heading);
        foreach ((uint id, SpellMetadata? metadata) in spells)
        {
            string name = !string.IsNullOrWhiteSpace(metadata?.Name)
                ? metadata.Name
                : $"Spell {id.ToString(CultureInfo.CurrentCulture)}";
            text.Append("\n~ ").Append(name).Append(": ");
            if (!string.IsNullOrWhiteSpace(metadata?.Description))
                text.Append(metadata.Description);
        }
        return text.ToString();
    }

    private static void ShowDescription(
        RetailReportBuilder report,
        PropertyBundle properties,
        RetailAppraisalNameResolver names)
    {
        if (properties.Ints.ContainsKey(267u)
            && properties.Ints.ContainsKey(98u)
            && properties.Ints.TryGetValue(268u, out int remainingLifetime))
        {
            report.Line(remainingLifetime < 0
                ? "This item is in the act of disintegrating."
                : $"This item expires in {FormatExpiry(remainingLifetime)}");
        }

        string longDescription = properties.GetString(16u);
        if (string.IsNullOrWhiteSpace(longDescription))
        {
            string shortDescription = properties.GetString(15u);
            if (!string.IsNullOrWhiteSpace(shortDescription))
                report.Paragraph(shortDescription);
        }
        else
        {
            string description = properties.GetString(52u);
            if (string.IsNullOrWhiteSpace(description))
                description = longDescription;

            string prefix = string.Empty;
            string suffix = string.Empty;
            if (properties.Ints.TryGetValue(172u, out int decorations))
            {
                if ((decorations & 1) != 0
                    && properties.Ints.TryGetValue(105u, out int workmanship))
                {
                    prefix += WorkmanshipAdjective(
                        Math.Clamp(workmanship, 0, 10)) + " ";
                }

                int materialType = properties.GetInt(131u);
                string material = names.ResolveMaterial(materialType);
                if (!string.IsNullOrWhiteSpace(material))
                {
                    prefix += material + " ";
                    description = RemoveFirst(description, material).Trim();
                }

                if ((decorations & 4) != 0
                    && properties.Ints.TryGetValue(177u, out int gemCount)
                    && properties.Ints.TryGetValue(178u, out int gemMaterial))
                {
                    string gemName = gemCount == 1
                        ? names.ResolveMaterial(gemMaterial)
                        : PluralizedGemName(
                            gemMaterial,
                            names.ResolveMaterial(gemMaterial));
                    if (!string.IsNullOrWhiteSpace(gemName))
                    {
                        suffix =
                            $", set with {gemCount.ToString(CultureInfo.CurrentCulture)} "
                            + gemName;
                    }
                }
            }

            report.Paragraph(prefix + description + suffix);
        }

        int portalRestrictions = properties.GetInt(111u);
        if (portalRestrictions != 0)
        {
            var restrictions = new List<string>();
            if ((portalRestrictions & 2) != 0)
                restrictions.Add("Player Killers may not use this portal.");
            if ((portalRestrictions & 4) != 0)
                restrictions.Add("Lite Player Killers may not use this portal.");
            if ((portalRestrictions & 8) != 0)
                restrictions.Add("Non-Player Killers may not use this portal.");
            if ((portalRestrictions & 0x20) != 0)
                restrictions.Add("This portal cannot be recalled nor linked to.");
            if ((portalRestrictions & 0x10) != 0)
                restrictions.Add("This portal cannot be summoned.");
            if (restrictions.Count != 0)
                report.Paragraph(string.Join('\n', restrictions));
        }
    }

    private static string FormatRetailDamage(double damage)
        => damage.ToString(
            damage > 10d ? "G4" : "G3",
            CultureInfo.CurrentCulture);

    private static bool TryDamageTypeName(uint type, out string? name)
    {
        name = type switch
        {
            1u => "Slashing",
            2u => "Piercing",
            4u => "Bludgeoning",
            8u => "Cold",
            16u => "Fire",
            32u => "Acid",
            64u => "Electric",
            128u => "Health",
            256u => "Stamina",
            512u => "Mana",
            1024u => "Nether",
            _ => null,
        };
        return name is not null;
    }

    /// <summary><c>ClothingPriorityToString @ 0x005B4F30</c>.</summary>
    private static string ClothingCoverage(uint priority)
    {
        var coverage = new List<string>();
        if ((priority & 0x4000u) != 0u)
            coverage.Add("Head");
        if ((priority & (0x0008u | 0x0400u)) != 0u)
            coverage.Add("Chest");
        if ((priority & (0x0010u | 0x0800u)) != 0u)
            coverage.Add("Abdomen");
        if ((priority & (0x0020u | 0x1000u)) != 0u)
            coverage.Add("Upper Arms");
        if ((priority & (0x0040u | 0x2000u)) != 0u)
            coverage.Add("Lower Arms");
        if ((priority & 0x0080u) != 0u)
            coverage.Add("Hands");
        if ((priority & (0x0002u | 0x0100u)) != 0u)
            coverage.Add("Upper Legs");
        if ((priority & (0x0004u | 0x0200u)) != 0u)
            coverage.Add("Lower Legs");
        if ((priority & 0x10000u) != 0u)
            coverage.Add("Feet");
        return string.Join(", ", coverage);
    }

    /// <summary><c>ExperienceSystem::ItemLevelToTotalXP @ 0x005C8100</c>.</summary>
    private static long ItemLevelToTotalXp(
        int level,
        long baseExperience,
        int maximumLevel,
        int style)
    {
        int cappedLevel = Math.Clamp(level, 0, maximumLevel);
        return style switch
        {
            1 => baseExperience * cappedLevel,
            2 => SumGeometricExperience(baseExperience, cappedLevel),
            3 => baseExperience * cappedLevel * (cappedLevel + 1L) / 2L,
            _ => 0L,
        };
    }

    /// <summary><c>ExperienceSystem::ItemTotalXPToLevel @ 0x005C81B0</c>.</summary>
    private static int ItemTotalXpToLevel(
        long totalExperience,
        long baseExperience,
        int maximumLevel,
        int style)
    {
        if (totalExperience <= 0 || baseExperience <= 0 || maximumLevel <= 0)
            return 0;
        if (style == 1)
        {
            return (int)Math.Min(
                maximumLevel,
                totalExperience / baseExperience);
        }

        long remaining = totalExperience;
        long nextCost = baseExperience;
        int level = 0;
        while (level < maximumLevel && remaining >= nextCost)
        {
            remaining -= nextCost;
            level++;
            if (style == 2)
                nextCost *= 2L;
            else if (style == 3)
                nextCost = baseExperience * (level + 1L);
            else
                return 0;
        }
        return level;
    }

    private static long SumGeometricExperience(
        long baseExperience,
        int levels)
    {
        long total = 0;
        long cost = baseExperience;
        for (int i = 0; i < levels; i++)
        {
            total += cost;
            cost *= 2L;
        }
        return total;
    }

    private static string FormatExpiry(int remainingSeconds)
    {
        int remaining = Math.Max(0, remainingSeconds);
        var text = new StringBuilder();
        if (remaining > 31_536_000)
        {
            text.Append(remaining / 31_536_000).Append(" years, ");
            remaining %= 31_536_000;
        }
        if (remaining > 86_400)
        {
            text.Append(remaining / 86_400).Append(" days, ");
            remaining %= 86_400;
        }
        if (remaining > 3_600)
        {
            text.Append(remaining / 3_600).Append(" hours, ");
            remaining %= 3_600;
        }
        if (remaining > 60)
        {
            text.Append(remaining / 60).Append(" minutes, ");
            remaining %= 60;
        }
        text.Append(remaining).Append(" seconds.");
        return text.ToString();
    }

    /// <summary><c>AppraisalSystem::InqPluralizedGemName @ 0x005B5800</c>.</summary>
    private static string PluralizedGemName(int materialType, string material)
    {
        if (materialType == 0x26)
            return "Rubies";
        if (materialType is 0x0B or 0x18 or 0x1B or 0x1D or 0x20
            or 0x25 or 0x28 or 0x2E or 0x24 or 0x2D)
        {
            return $"pieces of {material}";
        }
        if (materialType is 0x1A or 0x31)
            return material + "es";
        return materialType == 0x1C ? material : material + "s";
    }

    private static string RemoveFirst(string value, string remove)
    {
        int index = value.IndexOf(remove, StringComparison.Ordinal);
        return index < 0
            ? value
            : value.Remove(index, remove.Length);
    }

    /// <summary><c>ItemExamineUI::Appraisal_ShowSet @ 0x004AE880</c>.</summary>
    private static string? EquipmentSetName(int setId)
    {
        if (setId is >= 94 and <= 129)
        {
            string tier = ((setId - 94) / 12) switch
            {
                0 => "Minor",
                1 => "Major",
                _ => "Blackfire",
            };
            int member = (setId - 94) % 12;
            string effect = (member % 4) switch
            {
                0 => "Stinging",
                1 => "Sparking",
                2 => "Smoldering",
                _ => "Shivering",
            };
            string soul = (member / 4) switch
            {
                0 => "Shrouded Soul",
                1 => "Darkened Mind",
                _ => "Clouded Spirit",
            };
            return $"{tier} {effect} {soul}";
        }

        return setId switch
        {
            4 => "Carraida's Benediction",
            5 => "Noble Relic",
            6 => "Ancient Relic",
            7 => "Alduressa Relic",
            8 => "Shou-jen",
            9 => "Empyrean Rings",
            10 => "Arm, Mind, Heart",
            11 => "Coat of Perfect Light",
            12 => "Leggings of Perfect Light",
            13 => "Soldier's",
            14 => "Adept's",
            15 => "Archer's",
            16 => "Defender's",
            17 => "Tinker's",
            18 => "Crafter's",
            19 => "Hearty",
            20 => "Dexterous",
            21 => "Wise",
            22 => "Swift",
            23 => "Hardened",
            24 => "Reinforced",
            25 => "Interlocking",
            26 => "Flame Proof",
            27 => "Acid Proof",
            28 => "Cold Proof",
            29 => "Lightning Proof",
            30 => "Dedication",
            31 => "Gladiatorial Clothing",
            32 => "Ceremonial Clothing",
            33 => "Protective Clothing",
            35 => "Sigil of Defense",
            36 => "Sigil of Destruction",
            37 => "Sigil of Fury",
            38 => "Sigil of Growth",
            39 => "Sigil of Vigor",
            40 => "Heroic Protector",
            41 => "Heroic Destroyer",
            49 => "Weave of Alchemy",
            50 => "Weave of Arcane Lore",
            51 => "Weave of Armor Tinkering",
            52 => "Weave of Assess Person",
            53 or 67 or 74 or 75 or 79 => "Weave of Light Weapons",
            54 or 57 or 77 => "Weave of Missile Weapons",
            55 => "Weave of Cooking",
            56 => "Weave of Creature Enchantment",
            58 => "Weave of Finesse Weapons",
            59 => "Weave of Deception",
            60 => "Weave of Fletching",
            61 => "Weave of Healing",
            62 => "Weave of Item Enchantment",
            63 => "Weave of Item Tinkering",
            64 => "Weave of Leadership",
            65 => "Weave of Life Magic",
            66 => "Weave of Loyalty",
            68 => "Weave of Magic Defense",
            69 => "Weave of Magic Item Tinkering",
            70 => "Weave of Mana Conversion",
            71 => "Weave of Melee Defense",
            72 => "Weave of Missile Defense",
            73 => "Weave of Salvaging",
            76 => "Weave of Heavy Weapons",
            78 => "Weave of Two Handed Combat",
            80 => "Weave of Void Magic",
            81 => "Weave of War Magic",
            82 => "Weave of Weapon Tinkering",
            83 => "Weave of Assess Creature",
            84 => "Weave of Dirty Fighting",
            85 => "Weave of Dual Wield",
            86 => "Weave of Recklessness",
            87 => "Weave of Shield",
            88 => "Weave of Sneak Attack",
            89 => "Shou-jen Shozoku",
            90 => "Weave of Summoning",
            91 => "Shrouded Soul",
            92 => "Darkened Mind",
            93 => "Clouded Spirit",
            130 => "Shimmering Shadows",
            _ => null,
        };
    }

    private static string WeaponTimeName(int weaponTime) => weaponTime switch
    {
        < 11 => "Very Fast",
        < 31 => "Fast",
        < 50 => "Average",
        < 80 => "Slow",
        _ => "Very Slow",
    };

    /// <summary><c>AppraisalSystem::InqWorkmanshipAdjective @ 0x005B48E0</c>.</summary>
    private static string WorkmanshipAdjective(int workmanship) => workmanship switch
    {
        <= 0 => string.Empty,
        1 => "Poorly crafted",
        2 => "Well-crafted",
        3 => "Finely crafted",
        4 => "Exquisitely crafted",
        5 => "Magnificent",
        6 => "Nearly flawless",
        7 => "Flawless",
        8 => "Utterly flawless",
        9 => "Incomparable",
        _ => "Priceless",
    };

    /// <summary><c>ClientUISystem::DeltaTimeToString @ 0x00565E10</c>.</summary>
    private static string FormatDeltaTime(double seconds)
    {
        int remaining = Math.Max(0, (int)Math.Truncate(seconds));
        int months = remaining / 2_592_000;
        remaining %= 2_592_000;
        int days = remaining / 86_400;
        remaining %= 86_400;
        int hours = remaining / 3_600;
        remaining %= 3_600;
        int minutes = remaining / 60;
        int finalSeconds = remaining % 60;

        var result = new StringBuilder();
        if (months != 0)
            result.Append(months).Append("mo ");
        if (days != 0)
            result.Append(days).Append("d ");
        if (hours != 0)
            result.Append(hours).Append("h ");
        if (minutes != 0)
            result.Append(minutes).Append("m ");
        result.Append(finalSeconds).Append("s ");
        return result.ToString();
    }

    private static string FormatModifier(double modifier)
        => FormatSignedPercent(modifier - 1d);

    private static string FormatSignedPercent(double modifier)
        => modifier.ToString("+0%;-0%;0%", CultureInfo.CurrentCulture);

    /// <summary>
    /// Port of <c>AppraisalSystem::LockpickSuccessPercentToString
    /// @ 0x005B4600</c>.
    /// </summary>
    private static string? LockpickDifficulty(int successPercent)
        => successPercent switch
        {
            < 0 => null,
            0 => "impossible",
            < 5 => "ridiculously difficult",
            < 15 => "extremely difficult",
            < 35 => "quite difficult",
            < 50 => "difficult",
            < 70 => "challenging",
            < 85 => "mildly challenging",
            < 95 => "easy",
            _ => "trivial",
        };

    /// <summary>
    /// Port of <c>AppraisalProfile::InqIntEnchantmentMod @ 0x005B2C10</c>
    /// and <c>InqFloatEnchantmentMod @ 0x005B2C70</c>. The wire carries the
    /// low/high halves as two consecutive u16 values: the low bit marks an
    /// enchanted value and the corresponding bit sixteen positions higher
    /// selects the beneficial color.
    /// </summary>
    private static ItemAppraisalFontStyle EnchantmentStyle(
        (ushort Highlight, ushort Color)? encoded,
        uint lowBit)
    {
        if (encoded is not { } halves)
            return ItemAppraisalFontStyle.Normal;

        uint bitfield = halves.Highlight | ((uint)halves.Color << 16);
        if ((bitfield & lowBit) == 0u)
            return ItemAppraisalFontStyle.Normal;
        return (bitfield & (lowBit << 16)) != 0u
            ? ItemAppraisalFontStyle.Beneficial
            : ItemAppraisalFontStyle.Detrimental;
    }

    private static string DamageTypeName(uint type)
        => TryDamageTypeName(type, out string? name)
            ? name!
            : $"type {type.ToString(CultureInfo.CurrentCulture)}";

    private static string WeaponSubtype(int type) => type switch
    {
        1 => " (Unarmed Weapon)",
        2 => " (Sword)",
        3 => " (Axe)",
        4 => " (Mace)",
        5 => " (Spear)",
        6 => " (Dagger)",
        7 => " (Staff)",
        8 => " (Bow)",
        9 => " (Crossbow)",
        10 => " (Thrown)",
        _ => string.Empty,
    };

    /// <summary><c>AppraisalSystem::SkillToString @ 0x005B4A30</c> — retail
    /// skill-id -&gt; display-name table. Made <c>internal</c> (Campaign CC
    /// slice CC4) so the chargen Skills page can reuse the same names
    /// instead of duplicating this table.</summary>
    internal static string SkillName(int skill) => skill switch
    {
        1 => "Axe",
        2 => "Bow",
        3 => "Crossbow",
        4 => "Dagger",
        5 => "Mace",
        6 => "Melee Defense",
        7 => "Missile Defense",
        8 => "Sling",
        9 => "Spear",
        10 => "Staff",
        11 => "Sword",
        12 => "Thrown Weapon",
        13 => "Unarmed Combat",
        14 => "Arcane Lore",
        15 => "Magic Defense",
        16 => "Mana Conversion",
        17 => "Spellcraft",
        18 => "Item Tinkering",
        19 => "Person Appraisal",
        20 => "Deception",
        21 => "Healing",
        22 => "Jump",
        23 => "Lockpick",
        24 => "Run",
        25 => "Awareness",
        26 => "Armor Repair",
        27 => "Creature Appraisal",
        28 => "Weapon Tinkering",
        29 => "Armor Tinkering",
        30 => "Magic Item Tinkering",
        31 => "Creature Enchantment",
        32 => "Item Enchantment",
        33 => "Life Magic",
        34 => "War Magic",
        35 => "Leadership",
        36 => "Loyalty",
        37 => "Fletching",
        38 => "Alchemy",
        39 => "Cooking",
        40 => "Salvaging",
        41 => "Two Handed Combat",
        42 => "Gearcraft",
        43 => "Void Magic",
        44 => "Heavy Weapons",
        45 => "Light Weapons",
        46 => "Finesse Weapons",
        47 => "Missile Weapons",
        49 => "Dual Wield",
        50 => "Recklessness",
        51 => "Sneak Attack",
        52 => "Dirty Fighting",
        53 => "Challenge",
        54 => "Summoning",
        _ => $"Skill {skill.ToString(CultureInfo.CurrentCulture)}",
    };

    private static string UsageSkillName(int skill)
    {
        string name = SkillName(skill);
        return name.StartsWith("Skill ", StringComparison.Ordinal)
            ? "Unknown Skill"
            : name;
    }

    private static string PrimaryAttributeName(int attribute) => attribute switch
    {
        1 => "Strength",
        2 => "Endurance",
        3 => "Quickness",
        4 => "Coordination",
        5 => "Focus",
        6 => "Self",
        _ => $"Attribute {attribute.ToString(CultureInfo.CurrentCulture)}",
    };

    private static string SecondaryAttributeName(int attribute) => attribute switch
    {
        1 => "Max Health",
        2 => "Health",
        3 => "Max Stamina",
        4 => "Stamina",
        5 => "Max Mana",
        6 => "Mana",
        _ => $"Vital {attribute.ToString(CultureInfo.CurrentCulture)}",
    };

    private sealed class RetailReportBuilder
    {
        private readonly ItemAppraisalReportBuilder _report = new();

        public void Line(
            string value,
            ItemAppraisalFontStyle style = ItemAppraisalFontStyle.Normal)
            => _report.Line(value, style);

        public void Paragraph(
            string value,
            ItemAppraisalFontStyle style = ItemAppraisalFontStyle.Normal)
            => _report.Paragraph(value, style);

        public void BlankLine(
            ItemAppraisalFontStyle style = ItemAppraisalFontStyle.Normal)
            => _report.BlankLine(style);

        public ItemAppraisalReport Build() => _report.Build();
    }
}