How to make a Rust sell items plugin (scrap economy)

using System.Linq;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Core.Plugins;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Sell Items", "RustPluginGenerator", "1.0.0")]
    [Description("Sells items from a player's inventory for scrap at configured per-shortname prices")]
    public class SellItems : RustPlugin
    {
        private const string PermUse = "sellitems.use";

        [PluginReference] private Plugin Economics;

        private PluginConfig config;
        private readonly Dictionary<string, int> validPrices = new Dictionary<string, int>();

        private class PluginConfig
        {
            [JsonProperty("Give scrap directly")]
            public bool GiveScrap { get; set; } = true;

            [JsonProperty("Maximum scrap per single sale")]
            public int MaxPayoutPerSale { get; set; } = 5000;

            [JsonProperty("Prices")]
            public Dictionary<string, int> Prices { get; set; } = new Dictionary<string, int>
            {
                ["scrap"] = 0,
                ["rifle.ak"] = 200,
                ["smg.2"] = 80,
                ["pistol.semiauto"] = 50,
                ["metal.fragments"] = 1,
                ["metal.refined"] = 6,
                ["sulfur"] = 2,
                ["charcoal"] = 1,
                ["gears"] = 10,
                ["sheetmetal"] = 4
            };
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Sold"] = "Sold {0} x {1} for {2} scrap.",
                ["Nothing"] = "You are not holding an item.",
                ["NoPrice"] = "{0} cannot be sold on this server.",
                ["InventoryEmpty"] = "You have no {0} to sell.",
                ["SellAllUsage"] = "Usage: /sell all <shortname>",
                ["PayoutCapped"] = "Payout capped at {0} scrap for this sale.",
                ["NoPermission"] = "You do not have permission to sell items."
            }, this);
        }

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnServerInitialized()
        {
            validPrices.Clear();
            foreach (var entry in config.Prices)
            {
                if (entry.Key == "scrap")
                {
                    validPrices[entry.Key] = entry.Value;
                    continue;
                }

                if (ItemManager.FindItemDefinition(entry.Key) == null)
                {
                    PrintWarning($"Unknown item shortname in prices: {entry.Key}");
                    continue;
                }

                validPrices[entry.Key] = entry.Value;
            }
        }

        private string Msg(string key, string userId = null, params object[] args)
        {
            return string.Format(lang.GetMessage(key, this, userId), args);
        }

        [ChatCommand("sell")]
        private void CmdSell(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (args != null && args.Length > 0 && args[0].Equals("all", StringComparison.OrdinalIgnoreCase))
            {
                SellAll(player, args);
                return;
            }

            Item active = player.GetActiveItem();
            if (active == null || active.info == null)
            {
                SendReply(player, Msg("Nothing", player.UserIDString));
                return;
            }

            string shortname = active.info.shortname;
            int price;
            if (!validPrices.TryGetValue(shortname, out price) || price <= 0)
            {
                SendReply(player, Msg("NoPrice", player.UserIDString, active.info.displayName.english));
                return;
            }

            int amount = 1;
            player.inventory.Take(null, active.info.itemid, amount);
            PayScrap(player, price * amount, shortname, amount);
        }

        private void SellAll(BasePlayer player, string[] args)
        {
            if (args.Length < 2)
            {
                SendReply(player, Msg("SellAllUsage", player.UserIDString));
                return;
            }

            string shortname = args[1].ToLowerInvariant();
            int price;
            if (!validPrices.TryGetValue(shortname, out price) || price <= 0)
            {
                var def = ItemManager.FindItemDefinition(shortname);
                string label = def != null ? def.displayName.english : shortname;
                SendReply(player, Msg("NoPrice", player.UserIDString, label));
                return;
            }

            var itemDef = ItemManager.FindItemDefinition(shortname);
            if (itemDef == null) return;

            int owned = player.inventory.GetAmount(itemDef.itemid);
            if (owned <= 0)
            {
                SendReply(player, Msg("InventoryEmpty", player.UserIDString, itemDef.displayName.english));
                return;
            }

            player.inventory.Take(null, itemDef.itemid, owned);
            PayScrap(player, price * owned, shortname, owned);
        }

        private void PayScrap(BasePlayer player, int total, string shortname, int amount)
        {
            int payout = Mathf.Max(0, total);
            if (config.MaxPayoutPerSale > 0 && payout > config.MaxPayoutPerSale)
            {
                payout = config.MaxPayoutPerSale;
                SendReply(player, Msg("PayoutCapped", player.UserIDString, payout));
            }

            if (payout <= 0)
            {
                SendReply(player, Msg("Sold", player.UserIDString, amount, shortname, 0));
                return;
            }

            if (!config.GiveScrap && Economics != null)
            {
                Economics.Call("Deposit", player.UserIDString, (double)payout);
            }
            else
            {
                Item scrap = ItemManager.CreateByName("scrap", payout);
                if (scrap != null) player.GiveItem(scrap);
            }

            LogSale(player, shortname, amount, payout);
            SendReply(player, Msg("Sold", player.UserIDString, amount, shortname, payout));
        }

        private void LogSale(BasePlayer player, string shortname, int amount, int payout)
        {
            try
            {
                var store = Interface.Oxide.DataFileSystem.GetDatafile("SellItems/sales");
                string stamp = Facepunch.Math.Epoch.Current + "_" + player.userID.Get();
                store[stamp] = new Dictionary<string, object>
                {
                    ["shortname"] = shortname,
                    ["amount"] = amount,
                    ["payout"] = payout,
                    ["time"] = Facepunch.Math.Epoch.Current
                };
                Interface.Oxide.DataFileSystem.SaveDatafile("SellItems/sales");
            }
            catch
            {
                // Logging failures must not block a sale
            }
        }
    }
}