RB Announcements

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

namespace Oxide.Plugins
{
    [Info("Raidable Bases Announcements", "nivex", "0.1.1")]
    [Description("Outputs all Raidable Bases announcements to a Discord channel.")]
    public class RaidableBasesAnnouncements : RustPlugin
    {
        private void Init()
        {
            Unsubscribe(nameof(OnPlayerPvpDelayEntry));
            Unsubscribe(nameof(OnPlayerPvpDelayExpired));
            Unsubscribe(nameof(OnPlayerEnteredRaidableBase));
            Unsubscribe(nameof(OnPlayerExitedRaidableBase));
            Unsubscribe(nameof(OnRaidableBaseDespawn));
            Unsubscribe(nameof(OnRaidableBaseDespawned));
            Unsubscribe(nameof(OnRaidableBaseEnded));
            Unsubscribe(nameof(OnRaidableBaseStarted));
            Unsubscribe(nameof(OnRaidablePlayerCorpse));
        }

        private void OnServerInitialized(bool isStartup)
        {
            if (!CanSendDiscordMessage())
            {
                return;
            }

            /*if (config.OnPlayerPvpDelayEntry)
            {
                Subscribe(nameof(OnPlayerPvpDelayEntry));
            }

            if (config.OnPlayerPvpDelayExpired)
            {
                Subscribe(nameof(OnPlayerPvpDelayExpired));
            }*/

            if (config.OnPlayerEnteredRaidableBase)
            {
                Subscribe(nameof(OnPlayerEnteredRaidableBase));
            }

            if (config.OnPlayerExitedRaidableBase)
            {
                Subscribe(nameof(OnPlayerExitedRaidableBase));
            }

            if (config.OnRaidableBaseDespawn)
            {
                Subscribe(nameof(OnRaidableBaseDespawn));
            }

            if (config.OnRaidableBaseDespawned)
            {
                Subscribe(nameof(OnRaidableBaseDespawned));
            }

            if (config.OnRaidableBaseEnded)
            {
                Subscribe(nameof(OnRaidableBaseEnded));
            }

            if (config.OnRaidableBaseStarted)
            {
                Subscribe(nameof(OnRaidableBaseStarted));
            }

            if (config.OnRaidablePlayerCorpse)
            {
                Subscribe(nameof(OnRaidablePlayerCorpse));
            }
        }

        private void OnPlayerPvpDelayEntry(BasePlayer player)
        {
            // set time
        }

        private void OnPlayerPvpDelayExpired(BasePlayer player)
        {
            // reset time
        }

        private void OnPlayerEnteredRaidableBase(BasePlayer player, Vector3 raidPos, bool allowPvp)
        {
            SendDiscordMessage(_("OnPlayerEnteredRaidableBase", player.displayName, PositionToGrid(raidPos), raidPos));
        }

        private void OnPlayerExitedRaidableBase(BasePlayer player, Vector3 raidPos, bool allowPVP)
        {
            SendDiscordMessage(_("OnPlayerExitedRaidableBase", player.displayName, PositionToGrid(raidPos), raidPos));
        }

        private void OnRaidableBaseDespawn(Vector3 raidPos, float despawnTime, string identifier)
        {
            SendDiscordMessage(_("OnRaidableBaseDespawn", PositionToGrid(raidPos), raidPos, despawnTime - Time.realtimeSinceStartup));
        }

        private void OnRaidableBaseDespawned(Vector3 raidPos)
        {
            SendDiscordMessage(_("OnRaidableBaseDespawned", PositionToGrid(raidPos), raidPos));
        }

        private void OnRaidableBaseEnded(Vector3 raidPos, int mode)
        {
            var player = BasePlayer.activePlayerList.FirstOrDefault(x => x.Distance(raidPos) <= 50f);

            SendDiscordMessage(_("OnRaidableBaseEnded", GetDifficulty(mode), player?.displayName ?? "a player", PositionToGrid(raidPos), raidPos));
        }

        private void OnRaidableBaseEnded(Vector3 raidPos, int mode, BasePlayer player)
        {
            SendDiscordMessage(_("OnRaidableBaseEnded", GetDifficulty(mode), player.displayName, PositionToGrid(raidPos), raidPos));
        }

        private void OnRaidableBaseStarted(Vector3 raidPos, int mode, float spawnTime)
        {
            SendDiscordMessage(_("OnRaidableBaseStarted", GetDifficulty(mode), PositionToGrid(raidPos), raidPos));
        }

        private void OnRaidablePlayerCorpse(BasePlayer player, DroppedItemContainer container)
        {
            SendDiscordMessage(_("OnRaidablePlayerCorpse", player.displayName, PositionToGrid(container.transform.position), container.transform.position));
        }

        #region Discord Messages

        private bool CanSendDiscordMessage()
        {
            if (string.IsNullOrEmpty(config.WebhookUrl) || config.WebhookUrl == "https://support.discordapp.com/hc/en-us/articles/228383668-Intro-to-Webhooks")
            {
                return false;
            }

            return true;
        }

        private string GetDifficulty(int mode)
        {
            switch (mode)
            {
                case 0:
                    return "easy";
                case 1:
                    return "medium";
                case 2:
                    return "hard";
                case 3:
                    return "expert";
                case 4:
                default:
                    return "nightmare";
            }
        }

        private static string PositionToGrid(Vector3 position) => PhoneController.PositionToGridCoord(position);

        private void SendDiscordMessage(string text)
        {
            try
            {
                var headers = new Dictionary<string, string>() { { "Content-Type", "application/json" } };
                var body = new DiscordMessage(text).ToJson();

                webrequest.Enqueue(config.WebhookUrl, body, (code, response) =>
                {
                    if (code != 204)
                    {
                        PrintError(response);
                    }
                }, this, RequestMethod.POST, headers);
            }
            catch { }
        }

        #endregion Discord Messages

        #region Configuration

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                //{"OnPlayerPvpDelayEntry", ""},
                //{"OnPlayerPvpDelayExpired", ""},
                {"OnPlayerEnteredRaidableBase", "{0} entered a raid at {1} {2}"},
                {"OnPlayerExitedRaidableBase", "{0} exited a raid at {1} {2}"},
                {"OnRaidableBaseDespawn", "A raid is going to despawn at {0} {1} in {2} seconds"},
                {"OnRaidableBaseDespawned", "A raid has despawned at {0} {1}"},
                {"OnRaidableBaseEnded", "A {0} raid has been completed by {1} at {2} {3}" },
                {"OnRaidableBaseStarted", "A {0} raid has started at {1} {2}"},
                {"OnRaidablePlayerCorpse", "{0} has died in a raid at {1} {2}"},
            }, this);
        }

        public string _(string key, params object[] args)
        {
            string message = lang.GetMessage(key, this, null);

            return args.Length > 0 ? string.Format(message, args) : message;
        }

        private Configuration config;

        public class Configuration
        {
            [JsonProperty(PropertyName = "Message - Webhook URL")]
            public string WebhookUrl { get; set; } = "https://support.discordapp.com/hc/en-us/articles/228383668-Intro-to-Webhooks";

            //[JsonProperty(PropertyName = "Show PVP Delay Entry Message")]
            //public bool OnPlayerPvpDelayEntry { get; set; }

            //[JsonProperty(PropertyName = "Show PVP Delay Expired Message")]
            //public bool OnPlayerPvpDelayExpired { get; set; }

            [JsonProperty(PropertyName = "Show Player Entered Base Message")]
            public bool OnPlayerEnteredRaidableBase { get; set; } = true;

            [JsonProperty(PropertyName = "Show Player Exited Base Message")]
            public bool OnPlayerExitedRaidableBase { get; set; }

            [JsonProperty(PropertyName = "Show Despawning Message")]
            public bool OnRaidableBaseDespawn { get; set; }

            [JsonProperty(PropertyName = "Show Despawned Message")]
            public bool OnRaidableBaseDespawned { get; set; }

            [JsonProperty(PropertyName = "Show Raid Ended Message")]
            public bool OnRaidableBaseEnded { get; set; } = true;

            [JsonProperty(PropertyName = "Show Raid Started Message")]
            public bool OnRaidableBaseStarted { get; set; } = true;

            [JsonProperty(PropertyName = "Show Player Died Message")]
            public bool OnRaidablePlayerCorpse { get; set; }
        }

        public class DiscordMessage
        {
            [JsonProperty("content")]
            public string Content { get; set; }

            public DiscordMessage(string content)
            {
                Content = content;
            }

            public string ToJson() => JsonConvert.SerializeObject(this);
        }

        protected override void LoadConfig()
        {
            base.LoadConfig();

            try
            {
                config = Config.ReadObject<Configuration>();
            }
            catch
            {

            }

            if (config == null)
            {
                LoadDefaultConfig();
            }

            SaveConfig();
        }

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

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

        #endregion Configuration
    }
}