How to make a Rust chat shop plugin (scrap currency)

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

namespace Oxide.Plugins
{
    [Info("ScrapShop", "RustPluginGenerator", "1.0.0")]
    [Description("Chat shop that sells configured items for scrap from the player's inventory.")]
    public class ScrapShop : RustPlugin
    {
        private const string PermUse = "scrapshop.use";
        private const string PermAdmin = "scrapshop.admin";
        private const int ScrapId = -932201673;

        private PluginConfig config;

        private class ShopItem
        {
            [JsonProperty("Id")]
            public int Id { get; set; }

            [JsonProperty("Shortname")]
            public string Shortname { get; set; } = "scrap";

            [JsonProperty("DisplayName")]
            public string DisplayName { get; set; } = "Item";

            [JsonProperty("Price")]
            public int Price { get; set; } = 10;

            [JsonProperty("MaxAmount")]
            public int MaxAmount { get; set; } = 100;
        }

        private class PluginConfig
        {
            [JsonProperty("Items per page")]
            public int ItemsPerPage { get; set; } = 10;

            [JsonProperty("Items")]
            public List<ShopItem> Items { get; set; } = new List<ShopItem>
            {
                new ShopItem { Id = 1, Shortname = "metal.refined", DisplayName = "High Quality Metal", Price = 30, MaxAmount = 50 },
                new ShopItem { Id = 2, Shortname = "rifle.ak", DisplayName = "Assault Rifle", Price = 500, MaxAmount = 1 }
            };
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use the shop.",
                ["ShopHeader"] = "Shop page {0}/{1} - use /buy <id> [amount]",
                ["ShopLine"] = "#{0} {1} - {2} scrap each (max {3})",
                ["ShopEmpty"] = "The shop has no items configured.",
                ["InvalidItem"] = "No shop item with that id.",
                ["InvalidAmount"] = "Amount must be a positive number.",
                ["NoFunds"] = "You need {0} scrap but have {1}.",
                ["NoSpace"] = "You do not have enough inventory space for {0}x {1}.",
                ["PurchaseComplete"] = "You bought {0}x {1} for {2} scrap.",
                ["Reloaded"] = "Config reloaded with {0} shop items.",
                ["UnknownShortname"] = "Item '{0}' does not exist on this server."
            }, this);
        }

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

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

        [ChatCommand("shop")]
        private void ShopCommand(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (config.Items == null || config.Items.Count == 0)
            {
                SendReply(player, Msg("ShopEmpty", player.UserIDString));
                return;
            }

            int perPage = Mathf.Max(1, config.ItemsPerPage);
            int pages = Mathf.CeilToInt((float)config.Items.Count / perPage);
            int page = 1;
            if (args != null && args.Length > 0) int.TryParse(args[0], out page);
            page = Mathf.Clamp(page, 1, pages);

            SendReply(player, Msg("ShopHeader", player.UserIDString, page, pages));
            int start = (page - 1) * perPage;
            int end = Mathf.Min(start + perPage, config.Items.Count);
            for (int i = start; i < end; i++)
            {
                ShopItem entry = config.Items[i];
                if (entry == null) continue;
                SendReply(player, Msg("ShopLine", player.UserIDString, entry.Id, entry.DisplayName, entry.Price, entry.MaxAmount));
            }
        }

        [ChatCommand("buy")]
        private void BuyCommand(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 < 1)
            {
                SendReply(player, Msg("ShopHeader", player.UserIDString, 1, 1));
                return;
            }

            int id;
            if (!int.TryParse(args[0], out id))
            {
                SendReply(player, Msg("InvalidItem", player.UserIDString));
                return;
            }

            ShopItem entry = config.Items?.Find(x => x != null && x.Id == id);
            if (entry == null)
            {
                SendReply(player, Msg("InvalidItem", player.UserIDString));
                return;
            }

            int amount = 1;
            if (args.Length > 1 && !int.TryParse(args[1], out amount))
            {
                SendReply(player, Msg("InvalidAmount", player.UserIDString));
                return;
            }

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

            if (entry.MaxAmount > 0 && amount > entry.MaxAmount) amount = entry.MaxAmount;

            ItemDefinition def = ItemManager.FindItemDefinition(entry.Shortname);
            if (def == null)
            {
                SendReply(player, Msg("UnknownShortname", player.UserIDString, entry.Shortname));
                return;
            }

            int cost = entry.Price * amount;
            int held = player.inventory.GetAmount(ScrapId);
            if (held < cost)
            {
                SendReply(player, Msg("NoFunds", player.UserIDString, cost, held));
                return;
            }

            if (FreeSpace(player, def) < amount)
            {
                SendReply(player, Msg("NoSpace", player.UserIDString, amount, def.displayName.english));
                return;
            }

            var collected = new List<Item>();
            player.inventory.Take(collected, ScrapId, cost);

            Item item = ItemManager.CreateByItemID(def.itemid, amount);
            if (item == null)
            {
                SendReply(player, Msg("UnknownShortname", player.UserIDString, entry.Shortname));
                return;
            }

            player.GiveItem(item);
            SendReply(player, Msg("PurchaseComplete", player.UserIDString, amount, def.displayName.english, cost));
        }

        private int FreeSpace(BasePlayer player, ItemDefinition def)
        {
            int free = 0;
            ItemContainer[] containers = { player.inventory.containerMain, player.inventory.containerBelt };
            foreach (ItemContainer container in containers)
            {
                if (container == null) continue;
                for (int i = 0; i < container.capacity; i++)
                {
                    Item slot = container.GetSlot(i);
                    if (slot == null) free += def.stackable;
                    else if (slot.info.itemid == def.itemid) free += Mathf.Max(0, def.stackable - slot.amount);
                }
            }
            return free;
        }

        [ConsoleCommand("scrapshop.reload")]
        private void ReloadCommand(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            BasePlayer player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            LoadConfig();
            string message = Msg("Reloaded", player?.UserIDString, config.Items?.Count ?? 0);
            if (player != null) SendReply(player, message);
            else arg.ReplyWith(message);
        }
    }
}