using Oxide.Core;
using Oxide.Core.Plugins;
using Oxide.Game.Rust.Libraries;
using System;
using System.Collections.Generic;
using System.Linq;

//GatherRewards created with PluginMerge v(1.0.6.0) by MJSU @ https://github.com/dassjosh/Plugin.Merge
namespace Oxide.Plugins
{
    [Info("Gather Rewards", "Shady14u", "1.7.1")]
    [Description("Earn rewards through Economics/Server Rewards for killing and gathering")]
    public partial class GatherRewards : RustPlugin
    {
        #region GatherRewards.cs
        private const string _version = "1.7.0";
        
        private string _resource;
        
        [PluginReference] private Plugin Economics, ServerRewards, Friends, Clans, UINotify;
        #endregion

        #region GatherRewards.Config.cs
        private PluginConfig _config;
        
        PluginConfig DefaultConfig()
        {
            var defaultConfig = new PluginConfig
            {
                Settings = new PluginSettings
                {
                    ChatEditCommand = "gatherrewards",
                    ConsoleEditCommand = "gatherrewards",
                    EditPermission = "gatherrewards.canedit",
                    ShowMessagesOnKill = true,
                    ShowMessagesOnGather = true,
                    UseEconomics = true,
                    UseServerRewards = false,
                    PluginPrefix = "<color=#00FFFF>[GatherRewards]</color>",
                    AwardOnlyOnFullHarvest = false,
                    AddMissingRewards = false,
                    UseUINotify = false,
                    UINotifyMessageType = 1
                },
                Rewards = new Dictionary<string, float>
                {
                    { PluginRewards.Player, 0 },
                    { PluginRewards.PlayerFriend, -25 },
                    { PluginRewards.ClanMember, -25 },
                    { PluginRewards.Ore, 25 },
                    { PluginRewards.Wood, 25 },
                    { PluginRewards.Stone, 25 },
                    { PluginRewards.Corn, 25 },
                    { PluginRewards.Hemp, 25 },
                    { PluginRewards.Mushroom, 25 },
                    { PluginRewards.Pumpkin, 25 },
                    { PluginRewards.TeamMember, -25 },
                    { PluginRewards.Suicide, -100 }
                }
            };
            
            foreach (GameManifest.PooledString str in GameManifest.Current.pooledStrings)
            {
                if (str.str.StartsWith("assets/rust.ai/agents"))
                {
                    if (str.str.Contains("-") || str.str.Contains("_"))
                    {
                        continue;
                    }
                    
                    if (str.str.Contains("test"))
                    {
                        continue;
                    }
                    
                    if (str.str.Contains("npc"))
                    {
                        continue;
                    }
                    
                    var animal = str.str.Substring(str.str.LastIndexOf('/') + 1).Replace(".prefab", string.Empty);
                    if (animal.Contains("."))
                    {
                        continue;
                    }
                    
                    defaultConfig.Rewards[UppercaseFirst(animal)] = 25;
                }
            }
            
            defaultConfig.Rewards["Scientist"] = 25;
            defaultConfig.Rewards["Murderer"] = 25;
            return defaultConfig;
        }
        
        
        private bool _configChanged;
        
        protected override void LoadDefaultConfig()
        {
            Config.WriteObject(DefaultConfig(), true);
            PrintWarning("New configuration file created.");
        }
        
        private void LoadConfigValues()
        {
            _config = Config.ReadObject<PluginConfig>();
            var defaultConfig = DefaultConfig();
            Merge(_config.Rewards, defaultConfig.Rewards);
            if (_config.Settings.Version != _version)
            {
                _config.Settings.Version = _version;
                _configChanged = true;
            }
            if (!_configChanged) return;
            PrintWarning("Configuration file updated.");
            Config.WriteObject(_config);
        }
        
        private void Merge<T1, T2>(IDictionary<T1, T2> current, IDictionary<T1, T2> defaultDict)
        {
            foreach (var pair in defaultDict)
            {
                if (current.ContainsKey(pair.Key)) continue;
                current[pair.Key] = pair.Value;
                _configChanged = true;
            }
        }
        #endregion

        #region GatherRewards.Permissions.cs
        private bool CheckPermission(BasePlayer player, string perm)
        {
            return permission.UserHasPermission(player.UserIDString, perm);
        }
        
        private void RegisterPermsAndCommands()
        {
            permission.RegisterPermission(_config.Settings.EditPermission, this);
            foreach (var groupModifier in _config.Settings.GroupModifiers)
            {
                permission.RegisterPermission(groupModifier.Key,this);
            }
            
            var command = Interface.Oxide.GetLibrary<Command>();
            command.AddChatCommand(_config.Settings.ChatEditCommand, this, "cmdGatherRewards");
            command.AddConsoleCommand(_config.Settings.ConsoleEditCommand, this, "cmdConsoleGatherRewards");
        }
        #endregion

        #region GatherRewards.Lang.cs
        private string Lang(string key, string userId = null) =>
        lang.GetMessage(key, this, userId);
        
        private void Language()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                { "ReceivedForGather", "You have received ${0} for gathering {1}." },
                { "LostForGather", "You have lost ${0} for gathering {1}." },
                { "ReceivedForKill", "You have received ${0} for killing a {1}." },
                { "LostForKill", "You have lost ${0} for killing a {1}." },
                { "NoPermission", "You have no permission to use this command." },
                { "Usage", "Usage: /{0} [value] [amount]" },
                { "NotaNumber", "Error: value is not a number." },
                { "Success", "Successfully changed '{0}' to earn amount '{1}'." },
                { "ValueDoesNotExist", "Value '{0}' does not exist." }
            }, this);
            
            lang.RegisterMessages(new Dictionary<string, string>
            {
                { "ReceivedForGather", "Вы получили ${0} за сбор {1}." },
                { "LostForGather", "Вы потеряли ${0} за сбор {1}." },
                { "ReceivedForKill", "Вы получили ${0} за убийство {1}." },
                { "LostForKill", "Вы потеряли $ {0} за убийство {1}." },
                { "NoPermission", "У вас нет прав использовать эту команду." },
                { "Usage", "Использование: / {0} [значение] [количество]" },
                { "NotaNumber", "Ошибка: значение не является числом." },
                { "Success", "Успешно изменено '{0}', чтобы заработать деньги '{1}'." },
                { "ValueDoesNotExist", "Значение '{0}' не существует." }
            }, this, "ru");
        }
        #endregion

        #region GatherRewards.Hooks.cs
        private void Init()
        {
            LoadConfigValues();
            Language();
            RegisterPermsAndCommands();
        }
        
        private void OnCollectiblePickup(CollectibleEntity collectible, BasePlayer player)
        {
            if (!Economics && !ServerRewards) return;
            if (player == null) return;
            _resource = null;
            var amount = 0f;
            
            foreach (var configValue in _config.Rewards)
            {
                if (!collectible.ToString().ToLower().Contains(configValue.Key.ToLower())) continue;
                amount = _config.Rewards[configValue.Key];
                _resource = configValue.Key;
                break;
            }
            
            if(Interface.CallHook("OnGatherRewardsGiveCredit", player, collectible,amount)!=null) return;
            
            if (_resource != null && amount != 0)
            {
                GiveCredit(player, "gather", amount, _resource);
            }
        }
        
        private void OnDispenserGather(ResourceDispenser dispenser, BaseEntity entity, Item item)
        {
            if (!Economics && !ServerRewards) return;
            var player = entity?.ToPlayer();
            if (player==null) return;
            var amount = 0f;
            var shortName = item.info.shortname;
            _resource = null;
            
            foreach (KeyValuePair<string, float> configValue in _config.Rewards)
            {
                if (!shortName.Contains(configValue.Key.ToLower())) continue;
                amount = CheckPoints(configValue.Key);
                _resource = item.info.shortname;
                break;
            }
            
            if (_resource == null || amount == 0) return;
            
            if (player.GetHeldEntity() is Jackhammer)
            {
                amount *= _config.Settings.JackHammerModifier;
            }
            if(player.GetHeldEntity() is Chainsaw)
            {
                amount *= _config.Settings.ChainsawModifier;
            }
            
            if (_config.Settings.AwardOnlyOnFullHarvest)
            {
                var ent = dispenser.GetComponent<BaseEntity>();
                NextTick(() =>
                {
                    
                    if (dispenser.gatherType == ResourceDispenser.GatherType.Tree && dispenser.fractionRemaining <=0)
                    {
                        GiveCredit(player, "gather", amount, "Tree");
                        return;
                    }
                    
                    if (ent != null)
                    {
                        return;
                    }
                    
                    GiveCredit(player, "gather", amount, item.info.shortname);
                });
                
            }
            else
            {
                GiveCredit(player, "gather", amount, _resource);
            }
            
            
        }
        
        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null) return;
            if (!Economics && !ServerRewards) return;
            var player = info?.Initiator?.ToPlayer();
            if (player==null) return;
            
            string animal;
            float amount;
            
            if (entity.ToPlayer() != null && !(entity is NPCPlayer))
            {
                //Player Killed was a Real Player
                var victim = entity.ToPlayer();
                if (player == victim)
                {
                    GiveCredit(player, "suicide", CheckPoints(PluginRewards.Suicide), "suicide");
                    return;
                }
                
                amount = CheckPoints(PluginRewards.Player);
                animal = "player";
                
                if (Friends && _config.Rewards[PluginRewards.PlayerFriend] != 0)
                {
                    var isFriend = Friends.Call<bool>("HasFriend", victim.UserIDString, player.UserIDString);
                    var isFriendReverse = Friends.Call<bool>("HasFriend", player.UserIDString, victim.UserIDString);
                    if (isFriend || isFriendReverse)
                    {
                        amount = CheckPoints(PluginRewards.PlayerFriend);
                        animal = "friend";
                    }
                }
                
                if (Clans && _config.Rewards[PluginRewards.ClanMember] != 0)
                {
                    var victimClan = Clans.Call<string>("GetClanOf", victim.UserIDString);
                    var playerClan = Clans.Call<string>("GetClanOf", player.UserIDString);
                    if (victimClan == playerClan && !string.IsNullOrEmpty(playerClan))
                    {
                        amount = CheckPoints(PluginRewards.ClanMember);
                        animal = "clan member";
                    }
                }
                
                if(player.Team!=null && player.Team.members.Contains(victim.userID.Get()) && _config.Rewards[PluginRewards.TeamMember] != 0)
                {
                    amount = CheckPoints(PluginRewards.TeamMember);
                    animal = "team member";
                }
                
            }
            else
            {
                if (entity is NPCPlayer)
                {
                    var npcPlayer = (NPCPlayer)entity;
                    animal = npcPlayer.displayName ?? "Murderer";
                    
                    //Patch Tunnel Dwellers
                    if (entity.ShortPrefabName.Contains("npc_tunnel"))
                    {
                        animal = "Tunnel Dweller";
                    }
                    
                    //set the default amount to that of a murdered or 125
                    amount = CheckPoints(animal, CheckPoints("Murderer", 125));
                    
                    if (long.TryParse(animal, out var npcId))
                    {
                        //override names that are just numbers
                        amount = CheckPoints(entity.ShortPrefabName, CheckPoints("Murderer", 125));
                        animal = "Scientist";
                    }
                }
                else
                {
                    animal = entity.ShortPrefabName;
                    amount = CheckPoints(animal);
                }
            }
            
            if (amount != 0)
            {
                GiveCredit(player, "kill", amount, animal);
            }
        }
        #endregion

        #region GatherRewards.Helpers.cs
        private float CheckPoints(string animal, float defaultAmount = 0)
        {
            foreach (var configValue in _config.Rewards.Where(configValue =>
            string.Equals(animal, configValue.Key, StringComparison.CurrentCultureIgnoreCase)))
            {
                animal = configValue.Key;
                return _config.Rewards[configValue.Key];
            }
            
            if (defaultAmount == 0) return defaultAmount;
            
            if (_config.Settings.AddMissingRewards)
            {
                _config.Rewards.Add(animal, defaultAmount);
                Config.WriteObject(_config);
            }
            
            return defaultAmount;
        }
        
        private void GiveCredit(BasePlayer player, string type, float amount, string gathered)
        {
            if(amount==0) return;
            foreach (var groupModifier in _config.Settings.GroupModifiers.OrderByDescending(x=>x.Value))
            {
                if (permission.UserHasPermission(player.UserIDString, groupModifier.Key))
                {
                    amount *= float.Parse(groupModifier.Value.ToString());
                    break;
                }
            }
            
            if (amount > 0)
            {
                if (_config.Settings.UseEconomics && Economics)
                {
                    Economics.Call("Deposit", player.UserIDString, (double)amount);
                }
                
                if (_config.Settings.UseServerRewards && ServerRewards)
                {
                    ServerRewards.Call("AddPoints", new object[] { player.userID, (int)amount });
                }
                
                if (type == "gather" && _config.Settings.ShowMessagesOnGather)
                {
                    var message = _config.Settings.PluginPrefix + " " + string.Format(
                    Lang("ReceivedForGather", player.UserIDString), amount,
                    gathered.ToLower());
                    PrintToChat(player, message);
                    if (_config.Settings.UseUINotify)
                    {
                        UINotify?.Call("SendNotify", player.userID, _config.Settings.UINotifyMessageType, message);
                    }
                }
                else if (type == "kill" && _config.Settings.ShowMessagesOnKill)
                {
                    var message = _config.Settings.PluginPrefix + " " +
                    string.Format(Lang("ReceivedForKill", player.UserIDString), amount, gathered.ToLower());
                    PrintToChat(player, message);
                    if (_config.Settings.UseUINotify)
                    {
                        UINotify?.Call("SendNotify", player.userID, _config.Settings.UINotifyMessageType, message);
                    }
                }
            }
            else
            {
                amount = Math.Abs(amount);
                
                if (_config.Settings.UseEconomics && Economics)
                {
                    Economics.Call("Withdraw", player.UserIDString, (double)amount);
                }
                
                if (_config.Settings.UseServerRewards && ServerRewards)
                {
                    var points = ServerRewards.Call<int>("CheckPoints", player.userID);
                    if (points < amount && points > 0)
                    {
                        amount = points;
                    }
                    ServerRewards.Call("TakePoints", new object[] { player.userID, (int)amount });
                }
                
                if (type == "gather" && _config.Settings.ShowMessagesOnGather)
                {
                    var message = _config.Settings.PluginPrefix + " " +
                    string.Format(Lang("LostForGather", player.UserIDString), amount, gathered.ToLower());
                    PrintToChat(player,message);
                    if (_config.Settings.UseUINotify)
                    {
                        UINotify?.Call("SendNotify", player.userID, _config.Settings.UINotifyMessageType, message);
                    }
                }
                else if (type == "kill" && _config.Settings.ShowMessagesOnKill)
                {
                    var message = _config.Settings.PluginPrefix + " " +
                    string.Format(Lang("LostForKill", player.UserIDString), amount, gathered.ToLower());
                    PrintToChat(player,message);
                    if (_config.Settings.UseUINotify)
                    {
                        UINotify?.Call("SendNotify", player.userID, _config.Settings.UINotifyMessageType, message);
                    }
                }
            }
        }
        
        private static string UppercaseFirst(string s)
        {
            if (string.IsNullOrEmpty(s))
            return string.Empty;
            var a = s.ToCharArray();
            a[0] = char.ToUpper(a[0]);
            return new string(a);
        }
        #endregion

        #region GatherRewards.Commands.cs
        private void cmdGatherRewards(BasePlayer player, string command, string[] args)
        {
            if (!(CheckPermission(player, _config.Settings.EditPermission)))
            {
                SendReply(player, _config.Settings.PluginPrefix + " " + Lang("NoPermission", player.UserIDString));
                return;
            }
            
            if (args.Length < 2)
            {
                SendReply(player,
                _config.Settings.PluginPrefix + " " + string.Format(Lang("Usage", player.UserIDString),
                _config.Settings.ChatEditCommand));
                return;
            }
            
            float value;
            if (float.TryParse(args[1], out value) == false)
            {
                SendReply(player, _config.Settings.PluginPrefix + " " + Lang("NotaNumber", player.UserIDString));
                return;
            }
            
            switch (args[0].ToLower())
            {
                case "clan":
                {
                    _config.Rewards[PluginRewards.ClanMember] = value;
                    Config.WriteObject(_config);
                    SendReply(player,
                    _config.Settings.PluginPrefix + " " +
                    string.Format(Lang("Success", player.UserIDString), "clan member", value));
                    break;
                }
                case "friend":
                {
                    _config.Rewards[PluginRewards.PlayerFriend] = value;
                    Config.WriteObject(_config);
                    SendReply(player,
                    _config.Settings.PluginPrefix + " " +
                    string.Format(Lang("Success", player.UserIDString), "friend", value));
                    break;
                }
                default:
                {
                    if (!_config.Rewards.ContainsKey(UppercaseFirst(args[0].ToLower())))
                    {
                        SendReply(player,
                        _config.Settings.PluginPrefix + " " +
                        string.Format(Lang("ValueDoesNotExist", player.UserIDString), args[0].ToLower()));
                        break;
                    }
                    
                    _config.Rewards[UppercaseFirst(args[0].ToLower())] = float.Parse(args[1]);
                    Config.WriteObject(_config);
                    
                    SendReply(player,
                    _config.Settings.PluginPrefix + " " + string.Format(Lang("Success", player.UserIDString),
                    args[0].ToLower(), value));
                    
                    break;
                }
            }
        }
        
        private void cmdConsoleGatherRewards(ConsoleSystem.Arg arg)
        {
            if (arg.IsAdmin != true)
            {
                return;
            }
            
            if (arg.Args == null)
            {
                Puts(string.Format(Lang("Usage"), _config.Settings.ConsoleEditCommand));
                return;
            }
            
            if (arg.Args.Length <= 1)
            {
                Puts(string.Format(Lang("Usage"), _config.Settings.ConsoleEditCommand));
                return;
            }
            
            float value = 0;
            if (float.TryParse(arg.Args[1], out value) == false)
            {
                Puts(Lang("NotaNumber"));
                return;
            }
            
            switch (arg.Args[0].ToLower())
            {
                case "clan":
                {
                    _config.Rewards[PluginRewards.ClanMember] = value;
                    Config.WriteObject(_config);
                    Puts(string.Format(Lang("Success"), "clan member", value));
                    break;
                }
                case "friend":
                {
                    _config.Rewards[PluginRewards.PlayerFriend] = value;
                    Config.WriteObject(_config);
                    Puts(string.Format(Lang("Success"), "friend", value));
                    break;
                }
                default:
                {
                    if (!_config.Rewards.ContainsKey(UppercaseFirst(arg.Args[0].ToLower())))
                    {
                        Puts(string.Format(Lang("ValueDoesNotExist"), arg.Args[0].ToLower()));
                        break;
                    }
                    
                    _config.Rewards[UppercaseFirst(arg.Args[0].ToLower())] = float.Parse(arg.Args[1]);
                    Config.WriteObject(_config);
                    Puts(string.Format(Lang("Success"), arg.Args[0].ToLower(), value));
                    
                    break;
                }
            }
        }
        #endregion

        #region GatherRewards.Class.PluginSettings.cs
        private class PluginSettings
        {
            public int UINotifyMessageType = 1;
            public bool AddMissingRewards { get; set; }
            
            public bool AwardOnlyOnFullHarvest { get; set; }
            public float ChainsawModifier { get; set; } = .25f;
            public string ChatEditCommand { get; set; }
            public string ConsoleEditCommand { get; set; }
            public string EditPermission { get; set; }
            
            public Dictionary<string, object> GroupModifiers { get; set; } = new Dictionary<string, object>
            {
                {"gatherrewards.vip1", 4.0},
                {"gatherrewards.vip2", 3.0},
                {"gatherrewards.vip3", 2.0}
            };
            
            public float JackHammerModifier { get; set; } = .25f;
            public string PluginPrefix { get; set; }
            public bool ShowMessagesOnGather { get; set; }
            public bool ShowMessagesOnKill { get; set; }
            public bool UseEconomics { get; set; }
            public bool UseServerRewards { get; set; }
            public bool UseUINotify { get; set; }
            public string Version { get; set; }
        }
        #endregion

        #region GatherRewards.Class.PluginRewards.cs
        private static class PluginRewards
        {
            public const string ClanMember = "Clan Member";
            public const string Corn = "Corn";
            public const string Hemp = "Hemp";
            public const string Mushroom = "Mushroom";
            public const string Ore = "Ore";
            public const string Player = "Player";
            public const string PlayerFriend = "Player's Friend";
            public const string Pumpkin = "Pumpkin";
            public const string Stone = "Stone";
            public const string TeamMember = "Team Member";
            public const string Wood = "Wood";
            public const string Suicide = "Suicide";
        }
        #endregion

        #region GatherRewards.Class.PluginConfig.cs
        private class PluginConfig
        {
            #region Properties and Indexers
            
            public Dictionary<string, float> Rewards { get; set; }
            public PluginSettings Settings { get; set; }
            
            #endregion
        }
        #endregion

    }

}