Loaded

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

namespace Oxide.Plugins
{
    [Info("Loaded Dependency Check", "RustPluginGenerator", "1.0.0")]
    [Description("Verifies that optional and required plugin references are present when this plugin loads.")]
    public class LoadedDependencyCheck : RustPlugin
    {
        private const string PermCheck = "loadeddependencycheck.check";

        [PluginReference] private Plugin Economics;

        private PluginConfig config;
        private Timer checkTimer;
        private List<string> missingAtLoad = new List<string>();

        private class PluginConfig
        {
            [JsonProperty("Require Economics plugin")]
            public bool RequireEconomics { get; set; } = true;

            [JsonProperty("Warn on server initialization")]
            public bool WarnOnStartup { get; set; } = true;
        }

        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>
            {
                ["Missing"] = "Missing plugin reference: {0}",
                ["AllPresent"] = "All required plugin references are present.",
                ["CheckSummary"] = "Loaded at {0}. Missing references: {1}",
                ["NoMissing"] = "No missing references recorded.",
                ["StartupOk"] = "{0} is ready and its dependencies are satisfied."
            }, 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(PermCheck, this);
        }

        private void Loaded()
        {
            missingAtLoad.Clear();

            if (Economics == null && config.RequireEconomics)
            {
                missingAtLoad.Add("Economics");
                PrintWarning(Msg("Missing", null, "Economics"));
            }

            if (missingAtLoad.Count == 0)
            {
                Puts(Msg("AllPresent"));
            }
        }

        private void OnServerInitialized()
        {
            if (!config.WarnOnStartup) return;

            checkTimer = timer.Once(3f, () =>
            {
                if (missingAtLoad.Count == 0)
                {
                    Puts(Msg("StartupOk", null, Name));
                }
            });
        }

        [ChatCommand("loaded.check")]
        private void CmdCheck(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermCheck))
            {
                player.ChatMessage("You do not have permission to run this command.");
                return;
            }

            string missing = missingAtLoad.Count == 0
                ? Msg("NoMissing", player.UserIDString)
                : string.Join(", ", missingAtLoad.ToArray());

            player.ChatMessage(Msg("CheckSummary", player.UserIDString, DateTime.UtcNow.ToString("u"), missing));

            if (Economics == null)
            {
                player.ChatMessage(Msg("Missing", player.UserIDString, "Economics"));
            }
            else
            {
                player.ChatMessage(Msg("AllPresent", player.UserIDString));
            }
        }

        private void Unload()
        {
            checkTimer?.Destroy();
            checkTimer = null;
        }
    }
}