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

namespace Oxide.Plugins
{
    [Info("Clans", "k1lly0u", "0.1.55")]
    [Description("Universal Instance with alliance support")]
    public class Clans : CovalencePlugin
    {
        #region Fields 
        [PluginReference] Plugin BetterChat;

        private Dictionary<string, Clan> clanData = new Dictionary<string, Clan>();

        private DynamicConfigFile data;

        public Dictionary<string, string> playerClans;

        public Dictionary<string, Clan> clanCache;

        public static Clans Instance { get; private set; }
        #endregion
        
        #region Oxide Hooks
        private void Loaded()
        {
            data = Interface.Oxide.DataFileSystem.GetFile("clans_data");
            lang.RegisterMessages(Messages, this);

            Instance = this;

            clanCache = new Dictionary<string, Clan>();
            playerClans = new Dictionary<string, string>();
        }

        private void OnServerInitialized()
        {
            LoadVariables();
            LoadData();

            FillClanList();            
            SaveLoop();

            SetClanTag();

            foreach (IPlayer player in players.Connected)
                OnUserConnected(player);
        }

        private void OnPluginLoaded(Plugin plugin)
        {
            if (plugin.Title == "BetterChat")
                SetClanTag();
        }

        private void Unload()
        {
            SaveData();

            configData = null;
            Instance = null;            
        }

        private void OnUserConnected(IPlayer player)
        {
            timer.In(3, () =>
            {
                if (player == null)
                    return;

                if (!playerClans.ContainsKey(player.Id))
                    return;

                Clan clan = clanCache[playerClans[player.Id]];
                if (!clan.members.ContainsKey(player.Id))
                    return;

                clan.members[player.Id] = player.Name;

                if (configData.Settings.ShowJoinMessage)
                    clan.Broadcast(string.Format(Message("playerCon"), player.Name));
            });
        }

        private void OnUserDisconnected(IPlayer player)
        {
            if (configData.Settings.ShowLeaveMessage)
            {
                if (player == null)
                    return;

                if (!playerClans.ContainsKey(player.Id))
                    return;

                Clan clan = clanCache[playerClans[player.Id]];
                clan.Broadcast(string.Format(Message("playerDiscon"), player.Name));
            }
        }
        #endregion

        #region Functions
        private void FillClanList()
        {
            if (clanCache == null)
            {
                clanCache = new Dictionary<string, Clan>();
                return;
            }

            foreach (KeyValuePair<string, Clan> clan in clanCache)
            {
                foreach (KeyValuePair<string, string> member in clan.Value.members)
                {
                    playerClans.Add(member.Key, clan.Key);
                }
            }
        }

        public bool PlayerHasClan(string id) => playerClans.ContainsKey(id);

        public Clan FindClanByID(string id)
        {
            if (!PlayerHasClan(id))
                return null;

            Clan clan = FindClanByTag(playerClans[id]);
            if (clan == null)
                return null;

            return clan;
        }

        public Clan FindClanByTag(string tag)
        {
            Clan clan;
            if (clanCache.TryGetValue(tag, out clan))
                return clan;

            return null;
        }

        private void Reply(IPlayer player, string message, string message2 = null)
        {
            string formatMsg = $"<color={configData.MessageOptions.MSG}>{message}</color>";

            if (!string.IsNullOrEmpty(message2))
                formatMsg = $"<color={configData.MessageOptions.Main}>{message2}</color> {formatMsg}";

            player.Reply(formatMsg);
        }

        private void ReplyKey(IPlayer player, string message, string arg)
        {
            string formatMsg = $"<color={configData.MessageOptions.MSG}>{message}</color>".Replace("{0}", $"</color><color={configData.MessageOptions.Main}>{arg}</color><color={configData.MessageOptions.MSG}>");

            if (formatMsg.StartsWith("</color>"))
                formatMsg = formatMsg.Substring(9).Trim();  
            
            player.Reply(formatMsg);
        }

        private IPlayer FindPlayer(IPlayer player, string arg)
        {
            IEnumerable<IPlayer> targets = from p in players.All
                         where (p.Name.ToLower().Contains(arg.ToLower()) ? true : p.Id == arg)
                         select p;

            int targetCount = targets.Count();

            if (targetCount == 0)
            {
                if (player != null)
                    player.Reply(Message("noPlayers", player.Id));
                return null;
            }

            if (targetCount > 1)
            {
                for (int i = 0; i < targetCount; i++)
                {
                    IPlayer target = targets.ElementAt(i);
                    if (target.Name.Equals(arg) || target.Id.Equals(arg))
                        return target;
                }

                if (player != null)
                    player.Reply(Message("multiPlayers", player.Id));
                return null;
            }

            if (targets.Single() != null)
                return targets.Single();
            else player.Reply(Message("noPlayers", player.Id));

            return null;
        }

        private void SetClanTag() => BetterChat?.Call("API_RegisterThirdPartyTitle", new object[] { this, new Func<IPlayer, string>(GetClanTag) });

        private string GetClanTag(IPlayer player) => playerClans.ContainsKey(player.Id) ? $"[{configData.MessageOptions.ClanTag}][{playerClans[player.Id]}][/#]" : string.Empty;
        #endregion

        #region Commands       
        [Command("clan")]
        private void cmdClan(IPlayer player, string command, string[] args)
        {
            if (args == null || args.Length == 0)
            {
                Reply(player, "", $"{Title}  v {Version}");
                ReplyKey(player, Message("cMessHelp", player.Id), "/c <message>");
                ReplyKey(player, Message("aMessHelp", player.Id), "/a <message>");
                ReplyKey(player, Message("clanHelp", player.Id), "/clanhelp");
                ReplyKey(player, Message("clanMembers", player.Id), "/clan members");
                return;
            }

            switch (args[0].ToLower())
            {
                case "create":
                    CreateClan(player, args);
                    return;
                case "join":
                    if (args.Length == 2)
                        JoinClan(player, args[1]);
                    else Reply(player, "/clan join <tag>");
                    return;
                case "leave":
                    LeaveClan(player);
                    return;
                case "invite":
                    if (args.Length >= 2)
                        InviteMember(player, args);
                    else Reply(player, "", Message("noName", player.Id));
                    return;
                case "kick":
                    if (args.Length >= 2)
                        KickMember(player, args[1]);
                    else Reply(player, "", Message("noID", player.Id));
                    return;
                case "members":
                    ShowMembers(player);
                    return;
                case "promote":
                    if (args.Length >= 2)
                        PromoteMember(player, args[1]);
                    else Reply(player, "", Message("noID", player.Id));
                    return;
                case "demote":
                    if (args.Length >= 2)
                        DemoteMember(player, args[1]);
                    else Reply(player, "", Message("noID", player.Id));
                    return;
                case "disband":
                    DisbandClan(player);
                    return;
                case "ally":
                    Alliance(player, args);
                    return;
                default:
                    cmdClanHelp(player, "clanhelp", null);
                    break;
            }
        }

        [Command("c")]
        private void cmdClanChat(IPlayer player, string command, string[] args)
        {
            if (!PlayerHasClan(player.Id))
            {
                Reply(player, "", Message("noClanData", player.Id));
                return;
            }

            string clanName = playerClans[player.Id];
            if (!string.IsNullOrEmpty(clanName))
            {
                Clan clan = clanCache[clanName];
                string str = string.Join(" ", args);

                clan.Broadcast($"{player.Name} : {str}");
                Interface.CallHook("OnClanChat", player, str);
                return;
            }
        }

        [Command("a")]
        private void cmdAllianceChat(IPlayer player, string command, string[] args)
        {
            if (!PlayerHasClan(player.Id))
            {
                Reply(player, "", Message("noClanData", player.Id));
                return;
            }

            string clanName = playerClans[player.Id];
            if (!string.IsNullOrEmpty(clanName))
            {
                Clan clan = clanCache[clanName];
                if (clan.clanAlliances.Count == 0)
                    Reply(player, "", Message("noClanAlly", player.Id));
                else
                {
                    foreach (string clanAllyName in clan.clanAlliances)
                    {
                        Clan clanAlly = clanCache[clanAllyName];
                        clanAlly.Broadcast($"{player.Name} : {string.Join(" ", args)}", clan.clanTag);
                    }
                    clan.Broadcast($"{player.Name} : {string.Join(" ", args)}", clan.clanTag);
                }                 
            }
        }
       
        [Command("clanhelp")]
        private void cmdClanHelp(IPlayer player, string command, string[] args)
        {
            if (args == null || args.Length == 0)
            {
                Reply(player, "", Message("comHelp", player.Id));
                ReplyKey(player, Message("memHelp", player.Id), "/clanhelp member");
                ReplyKey(player, Message("modHelp", player.Id), "/clanhelp moderator");
                ReplyKey(player, Message("ownHelp", player.Id), "/clanhelp owner");
                return;
            }

            switch (args[0].ToLower())
            {
                case "member":
                    Reply(player, "", Message("memCom", player.Id));
                    ReplyKey(player, Message("cMessHelp", player.Id), "/c <message>");
                    ReplyKey(player, Message("aMessHelp", player.Id), "/a <message>");
                    ReplyKey(player, Message("createHelp", player.Id), "/clan create <tag>");
                    ReplyKey(player, Message("joinHelp", player.Id), "/clan join <tag>");
                    ReplyKey(player, Message("leaveHelp", player.Id), "/clan leave");
                    return;
                case "moderator":
                    Reply(player, "", Message("modCom", player.Id));
                    ReplyKey(player, Message("inviteHelp", player.Id), "/clan invite <playername>");
                    ReplyKey(player, Message("cancelHelp", player.Id), "/clan invite cancel <partialname/ID>");
                    ReplyKey(player, Message("kickHelp", player.Id), "/clan kick <partialname/ID>");
                    return;
                case "owner":
                    Reply(player, "", Message("ownerCom", player.Id));
                    ReplyKey(player, Message("promoteHelp", player.Id), "/clan promote <playername>");
                    ReplyKey(player, Message("demoteHelp", player.Id), "/clan demote <playername>");
                    ReplyKey(player, Message("disbandHelp", player.Id), "/clan disband");
                    ReplyKey(player, Message("allyReqHelp", player.Id), "/clan ally request <clantag>");
                    ReplyKey(player, Message("allyAccHelp", player.Id), "/clan ally accept <clantag>");
                    ReplyKey(player, Message("allyDecHelp", player.Id), "/clan ally decline <clantag>");
                    ReplyKey(player, Message("allyCanHelp", player.Id), "/clan ally cancel <clantag>");
                    return;
                default:
                    break;
            }
        }
        #endregion

        #region Command Functions
        public void CreateClan(IPlayer player, string[] args)
        {
            if (args.Length != 2)
                Reply(player, "", "/clan create <tag>");
            else
            {
                if (PlayerHasClan(player.Id))
                {
                    Reply(player, "", Message("alreadyMember", player.Id));
                    return;
                }

                string tag = new string(args[1].Where(c => char.IsLetterOrDigit(c) || char.IsWhiteSpace(c)).ToArray());
                if (tag.Length < configData.Settings.TagMinimum || tag.Length > configData.Settings.TagMaximum)
                {
                    Reply(player, "", string.Format(Message("tagForm1", player.Id), configData.Settings.TagMinimum, configData.Settings.TagMaximum));
                    return;
                }

                if (clanCache.ContainsKey(tag))
                    Reply(player, tag, Message("clanExists", player.Id));
                else
                {
                    Clan newClan = new Clan().CreateNewClan(tag, player.Id, player.Name);
                    clanCache.Add(tag, newClan);
                    playerClans.Add(player.Id, tag);
                    Reply(player, tag, Message("createSucc", player.Id));
                }
            }
        }

        public void JoinClan(IPlayer player, string tag)
        {
            if (PlayerHasClan(player.Id))
            {
                Reply(player, "", Message("alreadyMember", player.Id));
                return;
            }

            if (!clanCache.ContainsKey(tag))
                Reply(player, tag, Message("noFindClan", player.Id));
            else
            {
                Clan clan = clanCache[tag];
                if (!clan.invitedPlayers.ContainsKey(player.Id))
                    Reply(player, tag, Message("noInvite", player.Id));
                else
                {
                    if (configData.ClanLimits.Members != 0 && clan.members.Count >= configData.ClanLimits.Members)
                    {
                        Reply(player, "", Message("configData.ClanLimits.Members", player.Id));
                        clan.invitedPlayers.Remove(player.Id);
                        return;
                    }

                    clan.Broadcast(string.Format(Message("hasJoined"), player.Name));
                    clan.members.Add(player.Id, player.Name);
                    clan.invitedPlayers.Remove(player.Id);
                    playerClans.Add(player.Id, clan.clanTag);
                    Reply(player, tag, Message("joinSucc", player.Id));                    
                    ClanUpdate(clan.clanTag);
                }
            }
        }

        public void LeaveClan(IPlayer player)
        {
            if (PlayerHasClan(player.Id))
            {
                Clan clan = clanCache[playerClans[player.Id]];
                if (clan.IsOwner(player.Id))
                {
                    clan.RemoveOwner(player);
                    return;
                }
                if (clan.IsModerator(player.Id))
                    clan.moderators.Remove(player.Id);

                if (clan.IsMember(player.Id))
                    clan.RemoveUser(player.Id, ref clan.members);

                Reply(player, clan.clanTag, Message("leaveSucc", player.Id));
                ClanUpdate(clan.clanTag);
            }
            else Reply(player, "", Message("notInClan", player.Id));
        }

        public void InviteMember(IPlayer player, string[] args)
        {            
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];
                if (!clan.IsOwner(player.Id) && !clan.IsModerator(player.Id))
                {
                    Reply(player, "", Message("noInvPerm", player.Id));
                    return;
                }

                if (configData.ClanLimits.Members != 0 && clan.members.Count >= configData.ClanLimits.Members)
                {
                    Reply(player, "", Message("invMemberLimit", player.Id));
                    return;
                }

                if (args[1].ToLower() == "cancel")
                {
                    string targetName = clan.FindPlayer(args[2], clan.invitedPlayers, false);
                    if (string.IsNullOrEmpty(targetName))
                    {
                        Reply(player, args[2], Message("noPlayerInv", player.Id));
                        return;
                    }
                    else if (clan.RemoveUser(targetName, ref clan.invitedPlayers))
                        ReplyKey(player, Message("invCancelled", player.Id), targetName);
                    return;
                }

                IPlayer target = FindPlayer(player, args[1]);
                if (target != null)
                {
                    if (PlayerHasClan(target.Id))
                    {
                        ReplyKey(player, Message("playerInClan", player.Id), target.Name);
                        return;
                    }

                    if (clan.invitedPlayers.ContainsKey(target.Id))
                    {
                        ReplyKey(player, Message("alreadyInvited", player.Id), target.Name);
                        return;
                    }

                    clan.invitedPlayers.Add(target.Id, target.Name);
                    Reply(target, clan.clanTag, Message("clanInv"));
                    ReplyKey(player, "You have invited {0} to join your clan", target.Name);
                    ClanUpdate(clan.clanTag);
                    return;
                }                
            }
        }

        public object KickMember(IPlayer player, string targetplayer)
        {
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];
                if (!clan.IsOwner(player.Id) && !clan.IsModerator(player.Id))
                {
                    Reply(player, "", Message("noKickPerm", player.Id));
                    return null;
                }

                string target = clan.FindPlayer(targetplayer, clan.members, true);
                if (string.IsNullOrEmpty(target))
                {
                    Reply(player, "", Message("noClanMember", player.Id));
                    return null;
                }

                string targetName = clan.members[target];
                if (clan.IsOwner(target))
                {
                    Reply(player, "", Message("noKickOwner", player.Id));
                    return null;
                }

                if (!clan.IsOwner(player.Id) && clan.IsModerator(target))
                {
                    Reply(player, "", Message("noKickMod", player.Id));
                    return null;
                }

                if (target == player.Id)
                {
                    Reply(player, "", Message("noKickSelf", player.Id));
                    return null;
                }

                if (!clan.RemoveUser(target, ref clan.members))
                    ReplyKey(player, Message("kickError", player.Id), targetName);
                else
                {
                    if (clan.IsModerator(target))
                        clan.moderators.Remove(target);

                    playerClans.Remove(target);

                    Reply(player, string.Format(Message("kickSucc", player.Id), targetName));
                    ClanUpdate(clan.clanTag);

                    IPlayer targetPlayer = players.FindPlayer(target);
                    if (targetPlayer != null && targetPlayer.IsConnected)
                        Reply(targetPlayer, clan.clanTag, Message("kicked"));

                    return true;
                }
            }
            return null;
        }

        public object PromoteMember(IPlayer player, string targetplayer)
        {
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];
                if (clan == null)
                {
                    Reply(player, "", Message("noClanData", player.Id));
                    return null;
                }

                if (!clan.IsOwner(player.Id))
                {
                    Reply(player, "", Message("notOwnerProm", player.Id));
                    return null;
                }

                if (clan.moderators.Count != 0 && clan.moderators.Count >= configData.ClanLimits.Moderators)
                {
                    Reply(player, "", Message("modLimit", player.Id));
                    return null;
                }

                string target = clan.FindPlayer(targetplayer, clan.members, true);
                if (string.IsNullOrEmpty(target))
                {
                    Reply(player, "", Message("noClanMember", player.Id));
                    return null;
                }

                string targetName = clan.members[target];
                if (clan.IsModerator(target) || clan.IsOwner(target))
                {
                    ReplyKey(player, Message("alreadyMod", player.Id), targetName);
                    return null;
                }

                clan.moderators.Add(target);

                Reply(player, targetName, Message("promSucc", player.Id));
                ClanUpdate(clan.clanTag);

                IPlayer targetPlayer = players.FindPlayer(target);
                if (targetPlayer != null && targetPlayer.IsConnected)
                    ReplyKey(targetPlayer, Message("beenProm", targetPlayer.Id), player.Name);

                return true;
            }
            return null;
        }

        public object DemoteMember(IPlayer player, string targetplayer)
        {
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];

                string target = clan.FindPlayer(targetplayer, clan.members, true);
                if (string.IsNullOrEmpty(target))
                {
                    Reply(player, "", Message("noClanMember", player.Id));
                    return null;
                }

                string targetName = clan.members[target];

                if (clan.IsModerator(target) && clan.IsOwner(player.Id))
                {
                    clan.moderators.Remove(target);
                    Reply(player, string.Format(Message("demSucc", player.Id), targetName));
                    ClanUpdate(clan.clanTag);

                    IPlayer targetPlayer = players.FindPlayer(target);
                    if (targetPlayer != null && targetPlayer.IsConnected)
                        ReplyKey(targetPlayer, Message("beenDem", targetPlayer.Id), player.Name);

                    return true;
                }
                else ReplyKey(player, Message("notMod", player.Id), targetName);
            }
            return null;
        }

        public void DisbandClan(IPlayer player)
        {
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];
                if (!clan.IsOwner(player.Id))
                    Reply(player, "", Message("notOwnerDisb", player.Id));
                else
                {
                    foreach (KeyValuePair<string, string> member in clan.members)
                    {
                        if (member.Key != player.Id)
                        {
                            IPlayer targetPlayer = players.FindPlayer(member.Key);
                            if (targetPlayer != null && targetPlayer.IsConnected)
                                ReplyKey(targetPlayer, Message("beenDisb", targetPlayer.Id), player.Name);
                        }
                        playerClans.Remove(member.Key);
                    }
                    ClanDestroy(clan.clanTag);
                    clanCache.Remove(clan.clanTag);
                    Reply(player, "", Message("disbSucc", player.Id));
                }
            }
        }

        public void ShowMembers(IPlayer player)
        {
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];
                string returnString = $"<color={configData.MessageOptions.ClanChat}>{Message("clanmembers", player.Id)}</color>:\n";
                int i = 1;
                foreach (KeyValuePair<string, string> member in clan.members)
                {
                    returnString += $"{(clan.IsOwner(member.Key) ? $"{Message("owner", player.Id)} - " : clan.IsModerator(member.Key) ? $"{Message("moderator", player.Id)} - " : $"{Message("member", player.Id)} - ")}{member.Value} - {((covalence.Players.FindPlayerById(member.Key)?.IsConnected ?? false) ? $"<color=#3CD751>{Message("online", player.Id)}" : $"<color=#d85540>{Message("offline", player.Id)}")}</color>{(i < clan.members.Count ? "\n" : "")}";                    
                    i++;
                }
                Reply(player, returnString);
            }
        }

        public void Alliance(IPlayer player, string[] args)
        {
            if (!PlayerHasClan(player.Id))
                Reply(player, "", Message("notInClan", player.Id));
            else
            {
                Clan clan = clanCache[playerClans[player.Id]];
                if (!clan.IsOwner(player.Id))
                    Reply(player, "", Message("ownerAlly", player.Id));
                else
                {
                    if (args.Length != 3)
                        Reply(player, "Syntax:\n/clan ally request <clantag>\n/clan ally accept <clantag>");
                    else
                    {
                        if (!clanCache.ContainsKey(args[2]))
                            ReplyKey(player, Message("clanNoExist", player.Id), args[2]);
                        else
                        {
                            Clan targetClan = clanCache[args[2]];

                            switch (args[1].ToLower())
                            {
                                case "request":
                                    if (configData.ClanLimits.Alliances != 0 && clan.clanAlliances.Count >= configData.ClanLimits.Alliances)
                                    {
                                        Reply(player, "", Message("configData.ClanLimits.Alliances", player.Id));
                                        return;
                                    }

                                    if (clan.invitedAllies.Contains(targetClan.clanTag))
                                    {
                                        Reply(player, args[2], Message("invitePending", player.Id));
                                        return;
                                    }

                                    if (clan.clanAlliances.Contains(targetClan.clanTag))
                                    {
                                        Reply(player, args[2], Message("alreadyAllies", player.Id));
                                        return;
                                    }
                                    else
                                    {
                                        targetClan.pendingInvites.Add(clan.clanTag);
                                        clan.invitedAllies.Add(targetClan.clanTag);

                                        Reply(player, targetClan.clanTag, Message("allyReq", player.Id));
                                        ClanUpdate(clan.clanTag);

                                        IPlayer targetOwner = players.FindPlayer(targetClan.ownerID);
                                        if (targetOwner != null && targetOwner.IsConnected)
                                            ReplyKey(targetOwner, Message("reqAlliance", targetOwner.Id), clan.clanTag);
                                        return;
                                    }

                                case "accept":
                                    if (clan.pendingInvites.Contains(targetClan.clanTag))
                                    {
                                        if (configData.ClanLimits.Alliances != 0 && targetClan.clanAlliances.Count >= configData.ClanLimits.Alliances)
                                        {
                                            ReplyKey(player, Message("allyAccLimit", player.Id), targetClan.clanTag);
                                            targetClan.invitedAllies.Remove(clan.clanTag);
                                            clan.pendingInvites.Remove(targetClan.clanTag);
                                            return;
                                        }

                                        targetClan.invitedAllies.Remove(clan.clanTag);
                                        targetClan.clanAlliances.Add(clan.clanTag);
                                        clan.pendingInvites.Remove(targetClan.clanTag);
                                        clan.clanAlliances.Add(targetClan.clanTag);

                                        Reply(player, targetClan.clanTag, Message("allyAcc", player.Id));
                                        ClanUpdate(clan.clanTag);

                                        IPlayer targetOwner = players.FindPlayer(targetClan.ownerID);
                                        if (targetOwner != null && targetOwner.IsConnected)
                                            ReplyKey(targetOwner, Message("allyAccSucc", targetOwner.Id), clan.clanTag);
                                    }
                                    else Reply(player, args[2], Message("noAllyInv", player.Id));

                                    return;
                                case "decline":
                                    if (clan.pendingInvites.Contains(targetClan.clanTag))
                                    {
                                        targetClan.invitedAllies.Remove(clan.clanTag);
                                        Reply(player, targetClan.clanTag, Message("allyDec", player.Id));
                                        ClanUpdate(clan.clanTag);

                                        IPlayer targetOwner = players.FindPlayer(targetClan.ownerID);
                                        if (targetOwner != null && targetOwner.IsConnected)
                                            ReplyKey(targetOwner, Message("allyDecSucc", targetOwner.Id), clan.clanTag);
                                    }
                                    else Reply(player, args[2], Message("noAllyInv", player.Id));
                                    return;

                                case "cancel":
                                    if (clan.clanAlliances.Contains(args[2]))
                                    {
                                        targetClan.clanAlliances.Remove(clan.clanTag);
                                        clan.clanAlliances.Remove(clan.clanTag);
                                        Reply(player, targetClan.clanTag, Message("allyCan", player.Id));
                                        ClanUpdate(clan.clanTag);

                                        IPlayer targetOwner = players.FindPlayer(targetClan.ownerID);
                                        if (targetOwner != null && targetOwner.IsConnected)
                                            ReplyKey(targetOwner, Message("allyCanSucc", targetOwner.Id), clan.clanTag);
                                    }
                                    else if (clan.invitedAllies.Contains(args[2]))
                                    {
                                        targetClan.pendingInvites.Remove(clan.clanTag);
                                        clan.invitedAllies.Remove(clan.clanTag);
                                        Reply(player, targetClan.clanTag, Message("allyInvCan", player.Id));
                                        ClanUpdate(clan.clanTag);

                                        IPlayer targetOwner = players.FindPlayer(targetClan.ownerID);
                                        if (targetOwner != null && targetOwner.IsConnected)
                                            ReplyKey(targetOwner, Message("allyInvCan", targetOwner.Id), clan.clanTag);
                                    }
                                    else Reply(player, args[2], Message("noAlly", player.Id));
                                    return;

                                default:
                                    Reply(player, "Syntax:\n/clan ally request <clantag>\n/clan ally accept <clantag>\n/clan ally decline <clantag>\n/clan ally cancel <clantag>");
                                    return;
                            }
                        }
                    }
                }
            }
        }
        #endregion

        #region API
        private JObject GetClan(string tag)
        {
            Clan clan = FindClanByTag(tag);
            if (clan == null)
                return null;
            return clan.ToJObject();
        }

        private JArray GetAllClans() => new JArray(clanCache.Keys); 

        private string GetClanOf(object player)
        {
            if (player == null)            
                throw new ArgumentException("player");
            
            if (player is ulong)            
                player = player.ToString();
                        
            else if (player is IPlayer)            
                player = (player as IPlayer).Id;
            #if RUST
            else if (player is BasePlayer)
            player = (player as BasePlayer).UserIDString;
            #endif            
            if (!(player is string))            
                throw new ArgumentException("player");
            
            Clan clan = FindClanByID((string)player);
            if (clan == null)            
                return null;
            
            return clan.clanTag;
        }        

        private void ClanCreate(string tag) => Interface.CallHook("OnClanCreate", tag);

        private void ClanUpdate(string tag) => Interface.CallHook("OnClanUpdate", tag);

        private void ClanDestroy(string tag) => Interface.CallHook("OnClanDestroy", tag);

        private bool IsClanMember(string playerId, string otherId)
        {
            Clan playerClan = FindClanByID(playerId);
            if (playerClan == null)
                return false;

            Clan otherClan = FindClanByID(otherId);
            if (otherClan == null)
                return false;

            if (playerClan.clanTag != otherClan.clanTag)
                return false;

            return true;
        }

        private bool IsMemberOrAlly(string playerId, string otherId)
        {
            Clan playerClan = FindClanByID(playerId);
            if (playerClan == null)
                return false;

            Clan otherClan = FindClanByID(otherId);
            if (otherClan == null)
                return false;

            if ((playerClan.clanTag == otherClan.clanTag) || playerClan.clanAlliances.Contains(otherClan.clanTag))
                return true;

            return false;
        }

        private bool IsAllyPlayer(string playerId, string otherId)
        {
            Clan playerClan = FindClanByID(playerId);
            if (playerClan == null)
                return false;

            Clan otherClan = FindClanByID(otherId);
            if (otherClan == null)
                return false;

            if (playerClan.clanAlliances.Contains(otherClan.clanTag))
                return true;

            return false;
        }
        #endregion

        #region Config        
        public static ConfigData configData;

        public class ConfigData
        {
            [JsonProperty(PropertyName = "Limitations")]
            public ClanLimit ClanLimits { get; set; }

            [JsonProperty(PropertyName = "Message colors")]
            public Messaging MessageOptions { get; set; }

            [JsonProperty(PropertyName = "Settings")]
            public Options Settings { get; set; }

            public class Messaging
            {
                [JsonProperty(PropertyName = "Clan tag color")]
                public string ClanTag { get; set; }

                [JsonProperty(PropertyName = "Clan and Alliance chat color")]
                public string ClanChat { get; set; }

                [JsonProperty(PropertyName = "Highlight color")]
                public string Main { get; set; }

                [JsonProperty(PropertyName = "Message color")]
                public string MSG { get; set; }
            }
            public class ClanLimit
            {
                [JsonProperty(PropertyName = "Maximum clan member count")]
                public int Members { get; set; }

                [JsonProperty(PropertyName = "Maximum clan moderator count")]
                public int Moderators { get; set; }

                [JsonProperty(PropertyName = "Maximum clan alliance count")]
                public int Alliances { get; set; }
            }
            public class Options
            {
                [JsonProperty(PropertyName = "Minimum clan tag characters")]
                public int TagMinimum { get; set; }

                [JsonProperty(PropertyName = "Maximum clan tag characters")]
                public int TagMaximum { get; set; }

                [JsonProperty(PropertyName = "Show clan member connection message")]
                public bool ShowJoinMessage { get; set; }

                [JsonProperty(PropertyName = "Show clan member disconnection message")]
                public bool ShowLeaveMessage { get; set; }

                [JsonProperty(PropertyName = "Data save timer (seconds)")]
                public int SaveTimer { get; set; }
            }
        }

        private void LoadVariables()
        {
            LoadConfigVariables();
            SaveConfig();
        }

        protected override void LoadDefaultConfig()
        {
            ConfigData config = new ConfigData
            {
                ClanLimits = new ConfigData.ClanLimit
                {
                    Members = 8,
                    Moderators = 2,
                    Alliances = 2
                },
                MessageOptions = new ConfigData.Messaging
                {
                    ClanTag = "#783CD7",
                    ClanChat = "#3999D5",
                    Main = "#D85540",
                    MSG = "#D8D8D8"
                },
                Settings = new ConfigData.Options
                {
                    TagMaximum = 6,
                    TagMinimum = 2,
                    ShowJoinMessage = true,
                    ShowLeaveMessage = true,
                    SaveTimer = 600,
                }
            };
            SaveConfig(config);
        }

        private void LoadConfigVariables() => configData = Config.ReadObject<ConfigData>();

        private void SaveConfig(ConfigData config) => Config.WriteObject(config, true);
        #endregion

        #region Data Management
        private void SaveLoop() => timer.Once(configData.Settings.SaveTimer, () => { SaveData(); SaveLoop(); });

        private void SaveData()
        {
            clanData = clanCache;
            data.WriteObject(clanData);
        }

        private void LoadData()
        {
            try
            {
                clanData = data.ReadObject<Dictionary<string, Clan>>();
                clanCache = clanData;
            }
            catch
            {
                clanData = new Dictionary<string, Clan>();
            }
        }

        public class Clan
        {
            public string clanTag = string.Empty;
            public string ownerID = string.Empty;

            public List<string> moderators = new List<string>();
            public Dictionary<string, string> members = new Dictionary<string, string>();
            public List<string> clanAlliances = new List<string>();

            public Dictionary<string, string> invitedPlayers = new Dictionary<string, string>();
            public List<string> invitedAllies = new List<string>();
            public List<string> pendingInvites = new List<string>();

            public Clan CreateNewClan(string clanTag, string ownerID, string ownerName)
            {
                this.clanTag = clanTag;
                this.ownerID = ownerID;
                members.Add(ownerID, ownerName);
                Instance.ClanCreate(clanTag);
                return this;
            }

            public bool IsOwner(string ID) => ownerID == ID;

            public bool IsModerator(string ID) => moderators.Contains(ID);

            public bool IsMember(string ID) => members.ContainsKey(ID);

            public bool IsInvited(string ID) => invitedPlayers.ContainsKey(ID);

            public void RemoveOwner(IPlayer player)
            {
                RemoveUser(ownerID, ref members);
                string newOwner = null;

                if (moderators.Count > 0)
                    newOwner = moderators.First();
                else if (members.Count > 0)
                    newOwner = members.First().Key;

                if (!string.IsNullOrEmpty(newOwner))
                {
                    ownerID = newOwner;
                    IPlayer target = Instance.players.FindPlayer(newOwner);
                    if (target != null && target.IsConnected)
                        Instance.Reply(target, Instance.Message("ownerProm", target.Id));

                    Instance.Reply(player, clanTag, Instance.Message("leaveSucc", target.Id));
                    Instance.ClanUpdate(clanTag);
                }
                else
                {
                    Instance.ReplyKey(player, Instance.Message("clanDestroy", player.Id), clanTag);
                    Instance.clanCache.Remove(clanTag);
                    Instance.playerClans.Remove(player.Id);
                    Instance.ClanDestroy(clanTag);
                }
            }

            public bool RemoveUser(string IDName, ref Dictionary<string, string> targetDict)
            {
                if (targetDict.ContainsKey(IDName))
                {
                    targetDict.Remove(IDName);
                    Instance.playerClans.Remove(IDName);
                    return true;
                }

                if (targetDict.ContainsValue(IDName))
                {
                    string player = targetDict.FirstOrDefault(x => x.Value == IDName).Key;
                    targetDict.Remove(player);
                    Instance.playerClans.Remove(player);
                    return true;
                }
                else
                {
                    foreach (KeyValuePair<string, string> player in targetDict)
                    {
                        if (player.Value.Contains(IDName))
                        {
                            targetDict.Remove(player.Key);
                            Instance.playerClans.Remove(player.Key);
                            return true;
                        }
                    }
                }
                return false;
            }

            public string FindPlayer(string IDName, Dictionary<string, string> targetDict, bool ID)
            {
                if (targetDict.ContainsKey(IDName))
                {
                    if (ID)
                        return IDName;
                    else return targetDict[IDName];
                }
                else if (targetDict.ContainsValue(IDName))
                {
                    if (ID)
                        return targetDict.FirstOrDefault(x => x.Value == IDName).Key;
                    else return IDName;
                }
                else
                {
                    foreach (KeyValuePair<string, string> player in targetDict)
                    {
                        if (player.Value.Contains(IDName))
                        {
                            if (ID)
                                return player.Key;
                            else return player.Value;
                        }
                    }
                }
                return null;
            }

            public void Broadcast(string message, string sender = "Clan")
            {
                foreach (KeyValuePair<string, string> member in members)
                {
                    IPlayer target = Instance.players.FindPlayer(member.Value);
                    if (target != null && target.IsConnected)
                        target.Reply($"<color={configData.MessageOptions.ClanChat}>[{sender}]</color> :<color={configData.MessageOptions.MSG}> {message}</color>");
                }
            }

            internal JObject ToJObject()
            {
                JObject obj = new JObject();
                obj["tag"] = clanTag;
                obj["owner"] = ownerID;

                JArray jmoderators = new JArray();
                foreach (string moderator in moderators)
                    jmoderators.Add(moderator);
                obj["moderators"] = jmoderators;

                JArray jmembers = new JArray();
                foreach (KeyValuePair<string, string> member in members)
                    jmembers.Add(member.Key);
                obj["members"] = jmembers;

                JArray jinvited = new JArray();
                foreach (KeyValuePair<string, string> invite in invitedPlayers)
                    jinvited.Add(invite.Key);
                obj["invited"] = jinvited;

                JArray jallies = new JArray();
                foreach (string ally in clanAlliances)
                    jallies.Add(ally);
                obj["allies"] = jallies;

                JArray jinvallies = new JArray();
                foreach (string ally in invitedAllies)
                    jinvallies.Add(ally);
                obj["invitedallies"] = jinvallies;

                return obj;
            }
        }
      
        #endregion

        #region Messaging
        private string Message(string key, string id = null) => lang.GetMessage(key, this, id);

        private Dictionary<string, string> Messages = new Dictionary<string, string>
        {
            {"playerCon", "{0} has connected to the server" },
            {"outstandingMsgs", "You have {0} outstanding messages. Type /cmessage to view them" },
            {"playerDiscon", "{0} has disconnected from the server"},
            {"cMessHelp", "{0} - Sends a message to all your clan members"},
            {"aMessHelp", "{0} - Sends a message to all your allied clan members"},
            {"createHelp", "{0} - Creates a new clan"},
            {"joinHelp", "{0} - Joins a clan you have been invited to"},
            {"leaveHelp", "{0} - Leaves your current clan"},
            {"modCom", "Moderator Commands:"},
            {"inviteHelp", "{0} - Invites a player to your clan"},
            {"cancelHelp", "{0} - Cancel a players invite to your clan"},
            {"kickHelp", "{0} - Kicks a player from your clan"},
            {"ownerCom", "Owner Commands:"},
            {"promoteHelp", "{0} - Promotes a member to clan moderator"},
            {"demoteHelp", "{0} - Demotes a clan moderator to member"},
            {"disbandHelp", "{0} - Disbands your clan" },
            {"allyReqHelp", "{0} - Offer an alliance to another clan"},
            {"allyAccHelp", "{0} - Accept an alliance from another clan"},
            {"allyDecHelp", "{0} - Decline an alliance from another clan"},
            {"allyCanHelp", "{0} - Cancel an alliance with another clan"},
            {"tagForm1", "You clan tag must be between {0} and {1} characters, and must not contain any symbols"},
            {"createSucc", "You have successfully created a new clan with the tag:"},
            {"clanExists", "A clan already exists with the tag:"},
            {"alreadyMember", "You are already in a clan"},
            {"configData.ClanLimits.Members", "You can not join this clan as it has already reached its member limit"},
            {"joinSucc", "You have joined the clan:"},
            {"noInvite", "You do not have a pending invite from the clan:"},
            {"noFindClan", "Unable to find a clan with the tag:"},
            {"leaveSucc", "You have left the clan:"},
            {"notInClan", "You are not currently in a clan"},
            {"noInvPerm", "You do not have permission to invite players"},
            {"invMemberLimit", "You can not invite any more players to join your clan as it has reached its member limit"},
            {"noPlayerInv", "Unable to find a invite for player:"},
            {"invCancelled", "You have cancelled {0}'s clan invite"},
            {"playerInClan", "{0} is already in a clan"},
            {"alreadyInvited", "{0} already has a invitation to join your clan" },
            {"clanInv", "You have been invited to join the clan:"},
            {"noPlayerName", "Unable to find a player with that name"},
            {"noname", "You must enter a player's name"},
            {"nokickPerm", "You do not have permission to kick players"},
            {"noKickOwner", "You can not kick the clan owner"},
            {"noKickMod", "Only owners can kick moderators"},
            {"noKickSelf", "You can not kick yourself..."},
            {"kickSucc", "You have successfully kicked {0} from your clan"},
            {"kicked", "You have been kicked from the clan:"},
            {"kickError", "Error whilst removing {0} from your clan"},
            {"noClanMember", "Unable to find a clan member with that name"},
            {"noID", "You must enter a player's name or ID"},
            {"modLimit", "You can not assign any more moderators as you already have the maximum allowed amount"},
            {"alreadyMod", "{0} is already promoted"},
            {"promSucc", "You have successfully promoted"},
            {"beenProm", "{0} has promoted you to moderator"},
            {"demSucc", "You have successfully demoted {0}"},
            {"beenDem", "{0} has demoted you to member"},
            {"notMod", "{0} is not a clan moderator"},
            {"beenDisb", "{0} has disbanded your clan"},
            {"disbSucc", "You have successfully disbanded your clan"},
            {"notOwnerDisb", "Only the owner can disband a clan"},
            {"notOwnerProm", "Only the owner can promote clan members"},
            {"configData.ClanLimits.Alliances", "You can not request any more alliances as you already have the maximum allowed amount"},
            {"alreadyAllies", "You are already allies with"},
            {"allyReq", "You have requested a clan alliance from"},
            {"reqAlliance", "{0} has requested a clan alliance"},
            {"invitePending", "You already have a pending alliance invite for"},
            {"clanNoExist", "The clan {0} does not exist"},
            {"allyAccLimit", "You can not accept this clan alliance as {0} has already have the maximum allowed amount"},
            {"allyAcc", "You have accepted the clan alliance from"},
            {"allyAccSucc", "{0} has accepted your alliance request"},
            {"noAllyInv", "You do not have a alliance invite from"},
            {"allyDec", "You have declined the clan alliance from"},
            {"allyDecSucc", "{0} has declined your alliance request"},
            {"allyCan", "You have cancelled your alliance with"},
            {"allyCanSucc", "{0} has cancelled your clan alliance"},
            {"allyInvCan", "You have withdrawn your clan alliance invitation"},
            {"allyInvCanSucc", "{0} has withdrawn your clan alliance invitation"},
            {"noAlly", "You do not have a alliance with"},
            {"ownerAlly", "Only the clan owner can form alliances"},
            {"noClanData", "Unable to find your clan data or you are not a clan member"},
            {"noClanAlly", "You do not have any clan alliances"},
            {"cleardMsg", "You have cleared all outstanding messages"},
            {"clearSyn", "You can clear these messages by typing \"/cmessage clear\""},
            {"noOM", "You do not have any outstanding messages"},
            {"ownerProm", "You have been promoted to clan owner"},
            {"clanDestroy", "You have left the clan: {0} and it has been removed due to lack of members"},
            {"memCom", "Member Commands:" },
            {"comHelp", "Clans Help:" },
            {"clanHelp", "{0} - Display Clan commands" },
            {"clanMembers", "{0} - Show online and offline clan members" },
            {"memHelp", "{0} - Display member commands"},
            {"modHelp", "{0} - Display moderator commands"},
            {"ownHelp", "{0} - Display owner commands"},
            {"hasJoined", "{0} has joined the clan" },
            {"noPlayers", "Unable to find a player with the name or ID" },
            {"multiPlayers", "Multiple players found with that name" },
            {"owner", "[Owner]" },
            {"moderator", "[Moderator]" },
            {"member", "[Member]" },
            {"online", "Online" },
            {"offline", "Offline" },
            {"clanmembers", "Clan Members" }
        };
        #endregion
    }
}