using Microsoft.Win32.TaskScheduler;
using Newtonsoft.Json;
using NeXt.Vdf;
using NLog;
using ServerManagerTool.Common.Enums;
using ServerManagerTool.Common.JsonConverters;
using ServerManagerTool.Common.Lib;
using ServerManagerTool.Common.Model;
using ServerManagerTool.Common.Utils;
using ServerManagerTool.Enums;
using ServerManagerTool.Utils;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Windows;
using WPFSharp.Globalizer;

namespace ServerManagerTool.Lib
{
    [DataContract]
    public class ServerProfile : DependencyObject
    {
        private readonly GlobalizedApplication _globalizer = GlobalizedApplication.Instance;
        private static readonly Logger Logger = LogManager.GetCurrentClassLogger();

        private string _lastSaveLocation = string.Empty;
        private FileSystemWatcher _serverFilesWatcher = null;

        private ServerProfile()
        {
            ResetProfileId();

            ServerPassword = SecurityUtils.GeneratePassword(16);
            AdminPassword = SecurityUtils.GeneratePassword(16);
            RconPassword = string.Empty;
            BranchPassword = string.Empty;

            ServerFilesBlacklisted = new PlayerUserList();
            ServerFilesWhitelisted = new PlayerUserList();

            // initialise the nullable properties

            // initialise the complex properties

            GetDefaultDirectories();
        }

        #region Properties

        public static bool EnableServerFilesWatcher { get; set; } = true;

        public static bool KeepConfigValues { get; set; } = false;

        #region Profile Properties
        public static readonly DependencyProperty ProfileIDProperty = DependencyProperty.Register(nameof(ProfileID), typeof(string), typeof(ServerProfile), new PropertyMetadata(Guid.NewGuid().ToString()));
        [DataMember]
        public string ProfileID
        {
            get { return (string)GetValue(ProfileIDProperty); }
            set
            {
                SetValue(ProfileIDProperty, value);
                UpdateProfileToolTip();
            }
        }

        public static readonly DependencyProperty ProfileNameProperty = DependencyProperty.Register(nameof(ProfileName), typeof(string), typeof(ServerProfile), new PropertyMetadata(Config.Default.DefaultServerProfileName));
        [DataMember]
        public string ProfileName
        {
            get { return (string)GetValue(ProfileNameProperty); }
            set
            {
                SetValue(ProfileNameProperty, value);
                UpdateProfileToolTip();
            }
        }

        public static readonly DependencyProperty InstallDirectoryProperty = DependencyProperty.Register(nameof(InstallDirectory), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string InstallDirectory
        {
            get { return (string)GetValue(InstallDirectoryProperty); }
            set { SetValue(InstallDirectoryProperty, value); }
        }

        public static readonly DependencyProperty LastInstalledVersionProperty = DependencyProperty.Register(nameof(LastInstalledVersion), typeof(string), typeof(ServerProfile), new PropertyMetadata(new Version(0, 0).ToString()));
        [DataMember]
        public string LastInstalledVersion
        {
            get { return (string)GetValue(LastInstalledVersionProperty); }
            set { SetValue(LastInstalledVersionProperty, value); }
        }

        public static readonly DependencyProperty SequenceProperty = DependencyProperty.Register(nameof(Sequence), typeof(int), typeof(ServerProfile), new PropertyMetadata(99));
        [DataMember]
        public int Sequence
        {
            get { return (int)GetValue(SequenceProperty); }
            set { SetValue(SequenceProperty, value); }
        }

        public static readonly DependencyProperty LastStartedProperty = DependencyProperty.Register(nameof(LastStarted), typeof(DateTime), typeof(ServerProfile), new PropertyMetadata(DateTime.MinValue));
        [DataMember]
        public DateTime LastStarted
        {
            get { return (DateTime)GetValue(LastStartedProperty); }
            set { SetValue(LastStartedProperty, value); }
        }

        public static readonly DependencyProperty ProfileToolTipProperty = DependencyProperty.Register(nameof(ProfileToolTip), typeof(string), typeof(ServerProfile), new PropertyMetadata(string.Empty));
        public string ProfileToolTip
        {
            get { return (string)GetValue(ProfileToolTipProperty); }
            set { SetValue(ProfileToolTipProperty, value); }
        }

        public string SortKey
        {
            get
            {
                return $"{Sequence:0000000000}|{ProfileName}|{ProfileID}";
            }
        }
        #endregion

        #region Administration
        public static readonly DependencyProperty ServerNameProperty = DependencyProperty.Register(nameof(ServerName), typeof(string), typeof(ServerProfile), new PropertyMetadata(Config.Default.DefaultServerName));
        [DataMember]
        [IniFileEntry(IniFiles.Engine, IniSections.Engine_OnlineSubsystem, ServerProfileCategory.Administration)]
        public string ServerName
        {
            get { return (string)GetValue(ServerNameProperty); }
            set
            {
                SetValue(ServerNameProperty, value);
                ValidateServerName();
            }
        }

        public static readonly DependencyProperty ServerNameLengthProperty = DependencyProperty.Register(nameof(ServerNameLength), typeof(int), typeof(ServerProfile), new PropertyMetadata(0));
        public int ServerNameLength
        {
            get { return (int)GetValue(ServerNameLengthProperty); }
            set { SetValue(ServerNameLengthProperty, value); }
        }

        public static readonly DependencyProperty ServerNameLengthToLongProperty = DependencyProperty.Register(nameof(ServerNameLengthToLong), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        public bool ServerNameLengthToLong
        {
            get { return (bool)GetValue(ServerNameLengthToLongProperty); }
            set { SetValue(ServerNameLengthToLongProperty, value); }
        }

        public static readonly DependencyProperty ServerPasswordProperty = DependencyProperty.Register(nameof(ServerPassword), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        [IniFileEntry(IniFiles.Engine, IniSections.Engine_OnlineSubsystem, ServerProfileCategory.Administration)]
        public string ServerPassword
        {
            get { return (string)GetValue(ServerPasswordProperty); }
            set { SetValue(ServerPasswordProperty, value); }
        }

        public static readonly DependencyProperty AdminPasswordProperty = DependencyProperty.Register(nameof(AdminPassword), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration)]
        public string AdminPassword
        {
            get { return (string)GetValue(AdminPasswordProperty); }
            set { SetValue(AdminPasswordProperty, value); }
        }

        public static readonly DependencyProperty ServerIPProperty = DependencyProperty.Register(nameof(ServerIP), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string ServerIP
        {
            get { return (string)GetValue(ServerIPProperty); }
            set { SetValue(ServerIPProperty, value); }
        }

        public static readonly DependencyProperty ServerPortProperty = DependencyProperty.Register(nameof(ServerPort), typeof(int), typeof(ServerProfile), new PropertyMetadata(7777));
        [DataMember]
        [IniFileEntry(IniFiles.Engine, IniSections.Engine_URL, ServerProfileCategory.Administration, "Port")]
        public int ServerPort
        {
            get { return (int)GetValue(ServerPortProperty); }
            set 
            { 
                SetValue(ServerPortProperty, value);
                ServerPeerPort = value + 1;
            }
        }

        public static readonly DependencyProperty ServerPeerPortProperty = DependencyProperty.Register(nameof(ServerPeerPort), typeof(int), typeof(ServerProfile), new PropertyMetadata(7778));
        [IniFileEntry(IniFiles.Engine, IniSections.Engine_URL, ServerProfileCategory.Administration, "PeerPort", ClearWhenOff = nameof(KeepConfigValues))]
        public int ServerPeerPort
        {
            get { return (int)GetValue(ServerPeerPortProperty); }
            set { SetValue(ServerPeerPortProperty, value); }
        }

        public static readonly DependencyProperty QueryPortProperty = DependencyProperty.Register(nameof(QueryPort), typeof(int), typeof(ServerProfile), new PropertyMetadata(27015));
        [DataMember]
        [IniFileEntry(IniFiles.Engine, IniSections.Engine_OnlineSubsystemSteam, ServerProfileCategory.Administration, "GameServerQueryPort", ClearWhenOff = nameof(KeepConfigValues))]
        public int QueryPort
        {
            get { return (int)GetValue(QueryPortProperty); }
            set { SetValue(QueryPortProperty, value); }
        }

        public static readonly DependencyProperty ServerMapProperty = DependencyProperty.Register(nameof(ServerMap), typeof(string), typeof(ServerProfile), new PropertyMetadata("ConanSandbox"));
        [DataMember]
        public string ServerMap
        {
            get { return (string)GetValue(ServerMapProperty); }
            set 
            { 
                SetValue(ServerMapProperty, value);
                SyncMapSaveFileName();
            }
        }

        public static readonly DependencyProperty ServerMapSaveFileNameProperty = DependencyProperty.Register(nameof(ServerMapSaveFileName), typeof(string), typeof(ServerProfile), new PropertyMetadata("game.db"));
        [DataMember]
        public string ServerMapSaveFileName
        {
            get { return (string)GetValue(ServerMapSaveFileNameProperty); }
            set { SetValue(ServerMapSaveFileNameProperty, value); }
        }

        public static readonly DependencyProperty ServerModIdsProperty = DependencyProperty.Register(nameof(ServerModIds), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string ServerModIds
        {
            get { return (string)GetValue(ServerModIdsProperty); }
            set { SetValue(ServerModIdsProperty, value); }
        }

        public static readonly DependencyProperty RconEnabledProperty = DependencyProperty.Register(nameof(RconEnabled), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        [IniFileEntry(IniFiles.Game, IniSections.Game_RconPlugin, ServerProfileCategory.Administration, ConditionedOn = nameof(RconEnabled), WriteBooleanAsInteger = true)]
        public bool RconEnabled
        {
            get { return (bool)GetValue(RconEnabledProperty); }
            set { SetValue(RconEnabledProperty, value); }
        }

        public static readonly DependencyProperty RconPortProperty = DependencyProperty.Register(nameof(RconPort), typeof(int), typeof(ServerProfile), new PropertyMetadata(25575));
        [DataMember]
        [IniFileEntry(IniFiles.Game, IniSections.Game_RconPlugin, ServerProfileCategory.Administration, ConditionedOn = nameof(RconEnabled))]
        public int RconPort
        {
            get { return (int)GetValue(RconPortProperty); }
            set { SetValue(RconPortProperty, value); }
        }

        public static readonly DependencyProperty RconPasswordProperty = DependencyProperty.Register(nameof(RconPassword), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        [IniFileEntry(IniFiles.Game, IniSections.Game_RconPlugin, ServerProfileCategory.Administration, ConditionedOn = nameof(RconEnabled))]
        public string RconPassword
        {
            get { return (string)GetValue(RconPasswordProperty); }
            set { SetValue(RconPasswordProperty, value); }
        }

        public static readonly DependencyProperty MOTDProperty = DependencyProperty.Register(nameof(MOTD), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration, "ServerMessageOfTheDay", Multiline = true, MultilineSeparator = "<br>", QuotedString = QuotedStringType.Remove)]
        public string MOTD
        {
            get { return (string)GetValue(MOTDProperty); }
            set
            {
                SetValue(MOTDProperty, value);
                ValidateMOTD();
            }
        }

        public static readonly DependencyProperty MOTDLineCountProperty = DependencyProperty.Register(nameof(MOTDLineCount), typeof(int), typeof(ServerProfile), new PropertyMetadata(0));
        public int MOTDLineCount
        {
            get { return (int)GetValue(MOTDLineCountProperty); }
            set { SetValue(MOTDLineCountProperty, value); }
        }

        public static readonly DependencyProperty MOTDLineCountToLongProperty = DependencyProperty.Register(nameof(MOTDLineCountToLong), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        public bool MOTDLineCountToLong
        {
            get { return (bool)GetValue(MOTDLineCountToLongProperty); }
            set { SetValue(MOTDLineCountToLongProperty, value); }
        }

        public static readonly DependencyProperty MOTDLengthProperty = DependencyProperty.Register(nameof(MOTDLength), typeof(int), typeof(ServerProfile), new PropertyMetadata(0));
        public int MOTDLength
        {
            get { return (int)GetValue(MOTDLengthProperty); }
            set { SetValue(MOTDLengthProperty, value); }
        }

        public static readonly DependencyProperty MOTDLengthToLongProperty = DependencyProperty.Register(nameof(MOTDLengthToLong), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        public bool MOTDLengthToLong
        {
            get { return (bool)GetValue(MOTDLengthToLongProperty); }
            set { SetValue(MOTDLengthToLongProperty, value); }
        }

        public static readonly DependencyProperty MOTDIntervalEnabledProperty = DependencyProperty.Register(nameof(MOTDIntervalEnabled), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool MOTDIntervalEnabled
        {
            get { return (bool)GetValue(MOTDIntervalEnabledProperty); }
            set { SetValue(MOTDIntervalEnabledProperty, value); }
        }

        public static readonly DependencyProperty MOTDIntervalProperty = DependencyProperty.Register(nameof(MOTDInterval), typeof(int), typeof(ServerProfile), new PropertyMetadata(60));
        [DataMember]
        public int MOTDInterval
        {
            get { return (int)GetValue(MOTDIntervalProperty); }
            set { SetValue(MOTDIntervalProperty, value); }
        }

        public static readonly DependencyProperty UseVACProperty = DependencyProperty.Register(nameof(UseVAC), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration, "IsVACEnabled")]
        public bool UseVAC
        {
            get { return (bool)GetValue(UseVACProperty); }
            set { SetValue(UseVACProperty, value); }
        }

        public static readonly DependencyProperty UseBattlEyeProperty = DependencyProperty.Register(nameof(UseBattlEye), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration, "IsBattlEyeEnabled")]
        public bool UseBattlEye
        {
            get { return (bool)GetValue(UseBattlEyeProperty); }
            set { SetValue(UseBattlEyeProperty, value); }
        }

        public static readonly DependencyProperty AllowFamilySharedAccountProperty = DependencyProperty.Register(nameof(AllowFamilySharedAccount), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration)]
        public bool AllowFamilySharedAccount
        {
            get { return (bool)GetValue(AllowFamilySharedAccountProperty); }
            set { SetValue(AllowFamilySharedAccountProperty, value); }
        }

        public static readonly DependencyProperty ServerRegionProperty = DependencyProperty.Register(nameof(ServerRegion), typeof(string), typeof(ServerProfile), new PropertyMetadata("0"));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration, QuotedString = QuotedStringType.Remove)]
        public string ServerRegion
        {
            get { return (string)GetValue(ServerRegionProperty); }
            set { SetValue(ServerRegionProperty, value); }
        }

        public static readonly DependencyProperty MaxPlayersProperty = DependencyProperty.Register(nameof(MaxPlayers), typeof(int), typeof(ServerProfile), new PropertyMetadata(70));
        [IniFileEntry(IniFiles.Game, IniSections.Game_GameSession, ServerProfileCategory.Administration)]
        public int MaxPlayers
        {
            get { return (int)GetValue(MaxPlayersProperty); }
            set { SetValue(MaxPlayersProperty, value); }
        }

        public static readonly DependencyProperty KickIdlePlayersPercentageProperty = DependencyProperty.Register(nameof(KickIdlePlayersPercentage), typeof(int), typeof(ServerProfile), new PropertyMetadata(80));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration, "KickAFKPercentage")]
        public int KickIdlePlayersPercentage
        {
            get { return (int)GetValue(KickIdlePlayersPercentageProperty); }
            set { SetValue(KickIdlePlayersPercentageProperty, value); }
        }

        public static readonly DependencyProperty KickIdlePlayersPeriodProperty = DependencyProperty.Register(nameof(KickIdlePlayersPeriod), typeof(int), typeof(ServerProfile), new PropertyMetadata(3600));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration, "KickAFKTime")]
        public int KickIdlePlayersPeriod
        {
            get { return (int)GetValue(KickIdlePlayersPeriodProperty); }
            set { SetValue(KickIdlePlayersPeriodProperty, value); }
        }

        public static readonly DependencyProperty ServerTransferEnabledProperty = DependencyProperty.Register(nameof(ServerTransferEnabled), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration)]
        public bool ServerTransferEnabled
        {
            get { return (bool)GetValue(ServerTransferEnabledProperty); }
            set { SetValue(ServerTransferEnabledProperty, value); }
        }

        public static readonly DependencyProperty CanImportDirectlyFromSameServerProperty = DependencyProperty.Register(nameof(CanImportDirectlyFromSameServer), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.Administration)]
        public bool CanImportDirectlyFromSameServer
        {
            get { return (bool)GetValue(CanImportDirectlyFromSameServerProperty); }
            set { SetValue(CanImportDirectlyFromSameServerProperty, value); }
        }

        public static readonly DependencyProperty BranchNameProperty = DependencyProperty.Register(nameof(BranchName), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string BranchName
        {
            get { return (string)GetValue(BranchNameProperty); }
            set { SetValue(BranchNameProperty, value); }
        }

        public static readonly DependencyProperty BranchPasswordProperty = DependencyProperty.Register(nameof(BranchPassword), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string BranchPassword
        {
            get { return (string)GetValue(BranchPasswordProperty); }
            set { SetValue(BranchPasswordProperty, value); }
        }

        public static readonly DependencyProperty ProcessPriorityProperty = DependencyProperty.Register(nameof(ProcessPriority), typeof(string), typeof(ServerProfile), new PropertyMetadata("normal"));
        [DataMember]
        public string ProcessPriority
        {
            get { return (string)GetValue(ProcessPriorityProperty); }
            set { SetValue(ProcessPriorityProperty, value); }
        }

        public static readonly DependencyProperty ProcessAffinityProperty = DependencyProperty.Register(nameof(ProcessAffinity), typeof(BigInteger), typeof(ServerProfile), new PropertyMetadata(BigInteger.Zero));
        [DataMember]
        public BigInteger ProcessAffinity
        {
            get { return (BigInteger)GetValue(ProcessAffinityProperty); }
            set { SetValue(ProcessAffinityProperty, value); }
        }

        public static readonly DependencyProperty AdditionalArgsProperty = DependencyProperty.Register(nameof(AdditionalArgs), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string AdditionalArgs
        {
            get { return (string)GetValue(AdditionalArgsProperty); }
            set { SetValue(AdditionalArgsProperty, value); }
        }

        public static readonly DependencyProperty LauncherArgsOverrideProperty = DependencyProperty.Register(nameof(LauncherArgsOverride), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool LauncherArgsOverride
        {
            get { return (bool)GetValue(LauncherArgsOverrideProperty); }
            set { SetValue(LauncherArgsOverrideProperty, value); }
        }

        public static readonly DependencyProperty LauncherArgsProperty = DependencyProperty.Register(nameof(LauncherArgs), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string LauncherArgs
        {
            get { return (string)GetValue(LauncherArgsProperty); }
            set { SetValue(LauncherArgsProperty, value); }
        }
        #endregion

        #region Automatic Management
        public static readonly DependencyProperty EnableAutoBackupProperty = DependencyProperty.Register(nameof(EnableAutoBackup), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool EnableAutoBackup
        {
            get { return (bool)GetValue(EnableAutoBackupProperty); }
            set { SetValue(EnableAutoBackupProperty, value); }
        }

        public static readonly DependencyProperty EnableAutoStartProperty = DependencyProperty.Register(nameof(EnableAutoStart), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool EnableAutoStart
        {
            get { return (bool)GetValue(EnableAutoStartProperty); }
            set { SetValue(EnableAutoStartProperty, value); }
        }

        public static readonly DependencyProperty EnableAutoUpdateProperty = DependencyProperty.Register(nameof(EnableAutoUpdate), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool EnableAutoUpdate
        {
            get { return (bool)GetValue(EnableAutoUpdateProperty); }
            set { SetValue(EnableAutoUpdateProperty, value); }
        }

        public static readonly DependencyProperty EnableAutoShutdown1Property = DependencyProperty.Register(nameof(EnableAutoShutdown1), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool EnableAutoShutdown1
        {
            get { return (bool)GetValue(EnableAutoShutdown1Property); }
            set { SetValue(EnableAutoShutdown1Property, value); }
        }

        public static readonly DependencyProperty AutoShutdownTime1Property = DependencyProperty.Register(nameof(AutoShutdownTime1), typeof(string), typeof(ServerProfile), new PropertyMetadata("00:00"));
        [DataMember]
        public string AutoShutdownTime1
        {
            get { return (string)GetValue(AutoShutdownTime1Property); }
            set { SetValue(AutoShutdownTime1Property, value); }
        }

        public static readonly DependencyProperty ShutdownDaysOfTheWeek1Property = DependencyProperty.Register(nameof(ShutdownDaysOfTheWeek1), typeof(DaysOfTheWeek), typeof(ServerProfile), new PropertyMetadata(DaysOfTheWeek.AllDays));
        [DataMember]
        public DaysOfTheWeek ShutdownDaysOfTheWeek1
        {
            get { return (DaysOfTheWeek)GetValue(ShutdownDaysOfTheWeek1Property); }
            set { SetValue(ShutdownDaysOfTheWeek1Property, value); }
        }

        public static readonly DependencyProperty RestartAfterShutdown1Property = DependencyProperty.Register(nameof(RestartAfterShutdown1), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool RestartAfterShutdown1
        {
            get { return (bool)GetValue(RestartAfterShutdown1Property); }
            set { SetValue(RestartAfterShutdown1Property, value); }
        }

        public static readonly DependencyProperty UpdateAfterShutdown1Property = DependencyProperty.Register(nameof(UpdateAfterShutdown1), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool UpdateAfterShutdown1
        {
            get { return (bool)GetValue(UpdateAfterShutdown1Property); }
            set { SetValue(UpdateAfterShutdown1Property, value); }
        }

        public static readonly DependencyProperty EnableAutoShutdown2Property = DependencyProperty.Register(nameof(EnableAutoShutdown2), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool EnableAutoShutdown2
        {
            get { return (bool)GetValue(EnableAutoShutdown2Property); }
            set { SetValue(EnableAutoShutdown2Property, value); }
        }

        public static readonly DependencyProperty AutoShutdownTime2Property = DependencyProperty.Register(nameof(AutoShutdownTime2), typeof(string), typeof(ServerProfile), new PropertyMetadata("00:00"));
        [DataMember]
        public string AutoShutdownTime2
        {
            get { return (string)GetValue(AutoShutdownTime2Property); }
            set { SetValue(AutoShutdownTime2Property, value); }
        }

        public static readonly DependencyProperty ShutdownDaysOfTheWeek2Property = DependencyProperty.Register(nameof(ShutdownDaysOfTheWeek2), typeof(DaysOfTheWeek), typeof(ServerProfile), new PropertyMetadata(DaysOfTheWeek.AllDays));
        [DataMember]
        public DaysOfTheWeek ShutdownDaysOfTheWeek2
        {
            get { return (DaysOfTheWeek)GetValue(ShutdownDaysOfTheWeek2Property); }
            set { SetValue(ShutdownDaysOfTheWeek2Property, value); }
        }

        public static readonly DependencyProperty RestartAfterShutdown2Property = DependencyProperty.Register(nameof(RestartAfterShutdown2), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool RestartAfterShutdown2
        {
            get { return (bool)GetValue(RestartAfterShutdown2Property); }
            set { SetValue(RestartAfterShutdown2Property, value); }
        }

        public static readonly DependencyProperty UpdateAfterShutdown2Property = DependencyProperty.Register(nameof(UpdateAfterShutdown2), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool UpdateAfterShutdown2
        {
            get { return (bool)GetValue(UpdateAfterShutdown2Property); }
            set { SetValue(UpdateAfterShutdown2Property, value); }
        }

        public static readonly DependencyProperty AutoRestartIfShutdownProperty = DependencyProperty.Register(nameof(AutoRestartIfShutdown), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [DataMember]
        public bool AutoRestartIfShutdown
        {
            get { return (bool)GetValue(AutoRestartIfShutdownProperty); }
            set { SetValue(AutoRestartIfShutdownProperty, value); }
        }
        #endregion

        #region Discord Bot
        public static readonly DependencyProperty DiscordChannelIdProperty = DependencyProperty.Register(nameof(DiscordChannelId), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string DiscordChannelId
        {
            get { return (string)GetValue(DiscordChannelIdProperty); }
            set { SetValue(DiscordChannelIdProperty, value); }
        }

        public static readonly DependencyProperty DiscordAliasProperty = DependencyProperty.Register(nameof(DiscordAlias), typeof(string), typeof(ServerProfile), new PropertyMetadata(String.Empty));
        [DataMember]
        public string DiscordAlias
        {
            get { return (string)GetValue(DiscordAliasProperty); }
            set { SetValue(DiscordAliasProperty, value); }
        }

        public static readonly DependencyProperty AllowDiscordBackupProperty = DependencyProperty.Register(nameof(AllowDiscordBackup), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool AllowDiscordBackup
        {
            get { return (bool)GetValue(AllowDiscordBackupProperty); }
            set { SetValue(AllowDiscordBackupProperty, value); }
        }

        public static readonly DependencyProperty AllowDiscordRestartProperty = DependencyProperty.Register(nameof(AllowDiscordRestart), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool AllowDiscordRestart
        {
            get { return (bool)GetValue(AllowDiscordRestartProperty); }
            set { SetValue(AllowDiscordRestartProperty, value); }
        }

        public static readonly DependencyProperty AllowDiscordShutdownProperty = DependencyProperty.Register(nameof(AllowDiscordShutdown), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool AllowDiscordShutdown
        {
            get { return (bool)GetValue(AllowDiscordShutdownProperty); }
            set { SetValue(AllowDiscordShutdownProperty, value); }
        }

        public static readonly DependencyProperty AllowDiscordStartProperty = DependencyProperty.Register(nameof(AllowDiscordStart), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool AllowDiscordStart
        {
            get { return (bool)GetValue(AllowDiscordStartProperty); }
            set { SetValue(AllowDiscordStartProperty, value); }
        }

        public static readonly DependencyProperty AllowDiscordStopProperty = DependencyProperty.Register(nameof(AllowDiscordStop), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool AllowDiscordStop
        {
            get { return (bool)GetValue(AllowDiscordStopProperty); }
            set { SetValue(AllowDiscordStopProperty, value); }
        }

        public static readonly DependencyProperty AllowDiscordUpdateProperty = DependencyProperty.Register(nameof(AllowDiscordUpdate), typeof(bool), typeof(ServerProfile), new PropertyMetadata(true));
        [DataMember]
        public bool AllowDiscordUpdate
        {
            get { return (bool)GetValue(AllowDiscordUpdateProperty); }
            set { SetValue(AllowDiscordUpdateProperty, value); }
        }
        #endregion

        #region Server Files 
        public static readonly DependencyProperty ServerFilesBlacklistedProperty = DependencyProperty.Register(nameof(ServerFilesBlacklisted), typeof(PlayerUserList), typeof(ServerProfile), new PropertyMetadata(null));
        [DataMember]
        public PlayerUserList ServerFilesBlacklisted
        {
            get { return (PlayerUserList)GetValue(ServerFilesBlacklistedProperty); }
            set { SetValue(ServerFilesBlacklistedProperty, value); }
        }

        public static readonly DependencyProperty EnableWhitelistProperty = DependencyProperty.Register(nameof(EnableWhitelist), typeof(bool), typeof(ServerProfile), new PropertyMetadata(false));
        [IniFileEntry(IniFiles.ServerSettings, IniSections.ServerSettings_ServerSettings, ServerProfileCategory.ServerFiles)]
        public bool EnableWhitelist
        {
            get { return (bool)GetValue(EnableWhitelistProperty); }
            set { SetValue(EnableWhitelistProperty, value); }
        }

        public static readonly DependencyProperty ServerFilesWhitelistedProperty = DependencyProperty.Register(nameof(ServerFilesWhitelisted), typeof(PlayerUserList), typeof(ServerProfile), new PropertyMetadata(null));
        [DataMember]
        public PlayerUserList ServerFilesWhitelisted
        {
            get { return (PlayerUserList)GetValue(ServerFilesWhitelistedProperty); }
            set { SetValue(ServerFilesWhitelistedProperty, value); }
        }
        #endregion

        #region RCON
        public static readonly DependencyProperty RconWindowExtentsProperty = DependencyProperty.Register(nameof(RconWindowExtents), typeof(Rect), typeof(ServerProfile), new PropertyMetadata(new Rect(0f, 0f, 0f, 0f)));
        [DataMember]
        public Rect RconWindowExtents
        {
            get { return (Rect)GetValue(RconWindowExtentsProperty); }
            set { SetValue(RconWindowExtentsProperty, value); }
        }

        public static readonly DependencyProperty RconPlayerListWidthProperty = DependencyProperty.Register(nameof(RconPlayerListWidth), typeof(double), typeof(ServerProfile), new PropertyMetadata(200d));
        [DataMember]
        public double RconPlayerListWidth
        {
            get { return (double)GetValue(RconPlayerListWidthProperty); }
            set { SetValue(RconPlayerListWidthProperty, value); }
        }
        #endregion

        #region Player List
        public static readonly DependencyProperty PlayerListWindowExtentsProperty = DependencyProperty.Register(nameof(PlayerListWindowExtents), typeof(Rect), typeof(ServerProfile), new PropertyMetadata(new Rect(0f, 0f, 0f, 0f)));
        [DataMember]
        public Rect PlayerListWindowExtents
        {
            get { return (Rect)GetValue(PlayerListWindowExtentsProperty); }
            set { SetValue(PlayerListWindowExtentsProperty, value); }
        }
        #endregion

        #endregion

        #region Methods

        #region Common Methods
        public void ChangeInstallationFolder(string folder)
        {
            InstallDirectory = folder;

            LoadServerFiles(true, true);
            SetupServerFilesWatcher();
        }

        private void CheckLauncherArgs()
        {
            // do not process if overriding the launcher args
            if (this.LauncherArgsOverride)
                return;

            var launcherArgs = LauncherArgs?.ToLower() ?? string.Empty;

            // check Launcher Args for priority
            var priorityValues = ProcessUtils.GetProcessPriorityList();
            foreach (var priority in priorityValues)
            {
                var priorityArg = $"/{priority}";
                if (launcherArgs.Contains(priorityArg))
                {
                    launcherArgs = launcherArgs.Replace(priorityArg, "");
                    ProcessPriority = priority;
                }
            }

            LauncherArgs = launcherArgs;

            if (string.IsNullOrWhiteSpace(LauncherArgs))
            {
                LauncherArgs = string.Empty;

                // check if the launcher args override is enabled, but nothing has been defined in the launcher args
                if (LauncherArgsOverride)
                    LauncherArgsOverride = false;
            }
        }

        public void ClearSteamAppManifestBranch()
        {
            if (!string.IsNullOrWhiteSpace(BranchName))
                return;

            try
            {
                var manifestFile = ModUtils.GetSteamManifestFile(InstallDirectory);
                if (string.IsNullOrWhiteSpace(manifestFile) || !File.Exists(manifestFile))
                    return;

                // load the manifest files
                var vdfDeserializer = VdfDeserializer.FromFile(manifestFile);
                var vdf = vdfDeserializer.Deserialize();

                // clear any of th beta keys values
                var updated = SteamCmdManifestDetailsResult.ClearUserConfigBetaKeys(vdf);

                // save the manifest file
                if (updated)
                {
                    var vdfSerializer = new VdfSerializer(vdf);
                    vdfSerializer.Serialize(manifestFile);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, _globalizer.GetResourceString("ServerSettings_BranchClearErrorTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        internal static ServerProfile FromDefaults()
        {
            var settings = new ServerProfile();
            settings.LoadServerFiles(true, true);
            settings.SetupServerFilesWatcher();
            return settings;
        }

        private void GetDefaultDirectories()
        {
            if (!string.IsNullOrWhiteSpace(InstallDirectory))
                return;

            // get the root servers folder
            var installDirectory = Path.IsPathRooted(Config.Default.ServersInstallPath)
                                       ? Path.Combine(Config.Default.ServersInstallPath)
                                       : Path.Combine(Config.Default.DataPath, Config.Default.ServersInstallPath);
            var index = 1;
            while (true)
            {
                // create a test profile folder name
                var profileFolder = $"{Config.Default.DefaultServerRelativePath}{index}";
                // get the test profile directory
                var profileDirectory = Path.Combine(installDirectory, profileFolder);

                // check if the profile directory exists
                if (!Directory.Exists(profileDirectory))
                {
                    // profile directory does not exist, assign the test profile directory to the profile
                    InstallDirectory = profileDirectory;
                    break;
                }

                index++;
            }
        }

        private static IEnumerable<Enum> GetExclusions()
        {
            return new List<Enum>();
        }

        public string GetLauncherFile() => Path.Combine(GetProfileServerConfigDir(), Config.Default.LauncherFile);

        [Obsolete("This method will be removed in a future version.")]
        public string GetProfileConfigDir_Old() => Path.Combine(Path.GetDirectoryName(GetProfileFile()), this.ProfileName);

        public string GetProfileFile() => Path.Combine(Config.Default.ConfigPath, Path.ChangeExtension(this.ProfileID.ToLower(), Config.Default.ProfileExtension));

        public string GetProfileKey() => TaskSchedulerUtils.ComputeKey(this.InstallDirectory);

        public string GetProfileServerConfigDir() => GetProfileServerConfigDir(this);

        public static string GetProfileServerConfigDir(ServerProfile profile) => Path.Combine(profile.InstallDirectory, Config.Default.ServerConfigRelativePath);

        public string GetServerAppId()
        {
            try
            {
                var appFile = Path.Combine(InstallDirectory, Config.Default.ServerBinaryRelativePath, Config.Default.ServerAppIdFile);
                return File.Exists(appFile) ? File.ReadAllText(appFile).Trim() : string.Empty;
            }
            catch
            {
                return string.Empty;
            }
        }

        public string GetServerArgs()
        {
            var serverArgs = new StringBuilder();

            serverArgs.Append(GetProfileMapName(this));

            if (!string.IsNullOrWhiteSpace(this.ServerIP))
            {
                serverArgs.Append(" ");
                serverArgs.AppendFormat(Config.Default.ServerCommandLineArgsIPMatchFormat, this.ServerIP);
            }
            serverArgs.Append($" -Port={this.ServerPort}");
            serverArgs.Append(" ");
            serverArgs.AppendFormat(Config.Default.ServerCommandLineArgsPortMatchFormat, this.QueryPort);
            if (this.RconEnabled)
            {
                serverArgs.AppendFormat($" -RconPort={this.RconPort}");
            }

            if (!string.IsNullOrWhiteSpace(this.AdditionalArgs))
            {
                serverArgs.Append($" {this.AdditionalArgs.Trim()}");
            }

            serverArgs.Append(" ");
            serverArgs.Append(Config.Default.ServerCommandLineStandardArgs);

            return serverArgs.ToString();
        }

        public string GetServerExeFile() => Path.Combine(this.InstallDirectory, Config.Default.ServerBinaryRelativePath, Config.Default.ServerExeFile);

        public string GetServerSavedFilePath() => Path.Combine(this.InstallDirectory, Config.Default.SavedFilesRelativePath);

        public string GetServerWorldFile()
        {
            var saveFolder = GetServerSavedFilePath();
            return IOUtils.NormalizePath(Path.Combine(saveFolder, ServerMapSaveFileName));
        }

        public static ServerProfile LoadFrom(string file, ServerProfile profile = null)
        {
            if (string.IsNullOrWhiteSpace(file) || !File.Exists(file))
                return null;

            if (Path.GetExtension(file) == Config.Default.ProfileExtension)
                return LoadFromProfileFile(file, profile);

            var filePath = Path.GetDirectoryName(file);
            profile = LoadFromConfigFiles(file, profile);

            if (filePath.EndsWith(Config.Default.ServerConfigRelativePath))
            {
                var installDirectory = filePath.Replace(Config.Default.ServerConfigRelativePath, string.Empty).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
                profile.ChangeInstallationFolder(installDirectory);
            }

            return profile;
        }

        public static ServerProfile LoadFromConfigFiles(string file, ServerProfile profile, IEnumerable<Enum> exclusions = null)
        {
            if (string.IsNullOrWhiteSpace(file) || !File.Exists(file))
                return null;

            if (exclusions == null)
                exclusions = GetExclusions();

            var iniPath = Path.GetDirectoryName(file);
            var iniFile = new SystemIniFile(iniPath);
            profile = profile ?? new ServerProfile();
            iniFile.Deserialize(profile, exclusions);

            return profile;
        }

        public static ServerProfile LoadFromProfileFile(string file, ServerProfile profile)
        {
            if (string.IsNullOrWhiteSpace(file) || !File.Exists(file))
                return null;

            if (Path.GetExtension(file) != Config.Default.ProfileExtension)
                return null;

            profile = profile ?? new ServerProfile();

            try
            {
                var settings = new JsonSerializerSettings();
                settings.Converters.Add(new NullableValueConverter<int>());
                settings.Converters.Add(new NullableValueConverter<float>());

                profile = JsonUtils.DeserializeFromFile<ServerProfile>(file, settings);
                if (profile == null)
                    return null;
            }
            catch
            {
                // could not load the profile file, just exit
                return null;
            }

            // check if profile id and filename match
            var fileName = Path.GetFileNameWithoutExtension(file);
            if (Guid.TryParse(fileName, out Guid fileId) && Guid.TryParse(profile.ProfileID, out Guid profileId))
            {
                // filename is a guid - check it against the profile id
                if (!Guid.Equals(fileId, profileId))
                {
                    // id values are not in sync, change the profile id to be the same as the filename
                    profile.ProfileID = fileId.ToString();
                }
            }

            profile.CheckLauncherArgs();

            var serverConfigFile = Path.Combine(GetProfileServerConfigDir(profile), Config.Default.ServerGameConfigFile);
            if (File.Exists(serverConfigFile))
            {
                profile = LoadFromConfigFiles(serverConfigFile, profile);
            }

            profile.LoadServerFiles(true, true);
            profile.SetupServerFilesWatcher();

            profile._lastSaveLocation = file;
            return profile;
        }

        public void Save(bool updateFolderPermissions, bool updateSchedules, ProgressDelegate progressCallback)
        {
            if (string.IsNullOrWhiteSpace(Config.Default.DataPath))
                return;

            progressCallback?.Invoke(0, _globalizer.GetResourceString("ProfileSave_Saving"));

            UpdateProfileToolTip();
            ClearSteamAppManifestBranch();
            CheckLauncherArgs();

            // check if the processor affinity is valid
            if (!ProcessUtils.IsProcessorAffinityValid(ProcessAffinity))
                // processor affinity is not valid, set back to 0 (default ALL processors)
                ProcessAffinity = 0;

            //
            // Save the profile
            //
            progressCallback?.Invoke(0, _globalizer.GetResourceString("ProfileSave_SavingProfileFile"));
            SaveProfile();

            try
            {
                DestroyServerFilesWatcher();

                SaveServerFileBlacklisted();
                SaveServerFileWhitelisted();
            }
            finally
            {
                SetupServerFilesWatcher();
            }

            //
            // Write the config files
            //
            progressCallback?.Invoke(0, _globalizer.GetResourceString("ProfileSave_SavingConfigFiles"));
            SaveConfigFiles();

            // update the modlist file
            ModUtils.CreateModListFile(InstallDirectory, ModUtils.GetModIdList(ServerModIds));

            //
            // If this was a rename, remove the old profile after writing the new one.
            //
            if (!String.Equals(GetProfileFile(), this._lastSaveLocation, StringComparison.OrdinalIgnoreCase))
            {
                try
                {
                    if (File.Exists(this._lastSaveLocation))
                        File.Delete(this._lastSaveLocation);

                    var profileFile = Path.ChangeExtension(this._lastSaveLocation, Config.Default.ProfileExtension);
                    if (File.Exists(profileFile))
                        File.Delete(profileFile);

                    var profileIniDir = Path.ChangeExtension(this._lastSaveLocation, null);
                    if (Directory.Exists(profileIniDir))
                        Directory.Delete(profileIniDir, true);
                }
                catch (IOException)
                {
                    // We tried...
                }

                this._lastSaveLocation = GetProfileFile();
            }

            progressCallback?.Invoke(0, _globalizer.GetResourceString("ProfileSave_SavingLauncherFile"));
            SaveLauncher();

            if (updateFolderPermissions)
            {
                progressCallback?.Invoke(0, _globalizer.GetResourceString("ProfileSave_CheckingDirectoryPermissions"));
                UpdateDirectoryPermissions();
            }

            if (updateSchedules)
            {
                progressCallback?.Invoke(0, _globalizer.GetResourceString("ProfileSave_CheckingScheduledTasks"));
                UpdateSchedules();
            }
        }

        public void SaveProfile()
        {
            //
            // Save the profile
            //
            JsonUtils.SerializeToFile(this, GetProfileFile());
        }

        public void SaveLauncher()
        {
            var commandArgs = new StringBuilder();

            if (this.LauncherArgsOverride)
            {
                commandArgs.Append(this.LauncherArgs);
            }
            else
            {
                var drive = Path.GetPathRoot(this.InstallDirectory);
                drive = drive.Replace(Path.DirectorySeparatorChar.ToString(), string.Empty);
                drive = drive.Replace(Path.AltDirectorySeparatorChar.ToString(), string.Empty);

                commandArgs.Append("start");
                commandArgs.Append($" \"{this.ProfileName}\"");

                commandArgs.Append($" /{ProcessPriority}");
                if (ProcessAffinity > 0 && ProcessUtils.IsProcessorAffinityValid(ProcessAffinity))
                {
                    commandArgs.Append($" /affinity {ProcessAffinity.ToString("X")}");
                }

                if (!string.IsNullOrWhiteSpace(this.LauncherArgs))
                {
                    commandArgs.Append($" {this.LauncherArgs.Trim()}");
                }

                commandArgs.Append($" \"{GetServerExeFile()}\"");
                commandArgs.Append($" {GetServerArgs()}");
            }

            Directory.CreateDirectory(Path.GetDirectoryName(GetLauncherFile()));
            File.WriteAllText(GetLauncherFile(), commandArgs.ToString());
        }

        public void SaveConfigFiles()
        {
            //
            // Remove the old profile ini backups
            //
            var profileIniDir = GetProfileConfigDir_Old();
            if (Directory.Exists(profileIniDir))
            {
                // set the folder permissions
                SecurityUtils.SetDirectoryOwnershipForAllUsers(profileIniDir);
                try
                {
                    Directory.Delete(profileIniDir, true);
                }
                catch (Exception) { }
            }

            //
            // Save to the installation location
            //
            string serverConfigDir = GetProfileServerConfigDir();
            Directory.CreateDirectory(serverConfigDir);
            SaveConfigFile(serverConfigDir);
        }

        public void SaveConfigFile(string configDir, IEnumerable<Enum> exclusions = null)
        {
            if (exclusions == null)
                exclusions = GetExclusions();

            var iniFile = new SystemIniFile(configDir);
            iniFile.Serialize(this, exclusions);
        }

        public bool UpdateDirectoryPermissions()
        {
            if (!SecurityUtils.IsAdministrator())
                return true;

            if (!SecurityUtils.SetDirectoryOwnershipForAllUsers(this.InstallDirectory))
            {
                Logger.Debug($"Unable to set directory permissions for {this.InstallDirectory}.");
                return false;
            }

            return true;
        }

        public bool UpdateSchedules()
        {
            SaveLauncher();

            if (!SecurityUtils.IsAdministrator())
                return true;

            var taskKey = GetProfileKey();

            if(!TaskSchedulerUtils.ScheduleAutoStart(taskKey, null, this.EnableAutoStart, GetLauncherFile(), ProfileName, true))
            {
                return false;
            }

            TimeSpan shutdownTime;
            var command = Assembly.GetEntryAssembly().Location;
            if (!TaskSchedulerUtils.ScheduleAutoShutdown(taskKey, "#1", command, this.EnableAutoShutdown1 ? (TimeSpan.TryParseExact(this.AutoShutdownTime1, "g", null, out shutdownTime) ? shutdownTime : (TimeSpan?)null) : null, ShutdownDaysOfTheWeek1, ProfileName, TaskSchedulerUtils.ShutdownType.Shutdown1))
            {
                return false;
            }

            if (!TaskSchedulerUtils.ScheduleAutoShutdown(taskKey, "#2", command, this.EnableAutoShutdown2 ? (TimeSpan.TryParseExact(this.AutoShutdownTime2, "g", null, out shutdownTime) ? shutdownTime : (TimeSpan?)null) : null, ShutdownDaysOfTheWeek2, ProfileName, TaskSchedulerUtils.ShutdownType.Shutdown2))
            {
                return false;
            }

            return true;
        }

        public bool Validate(bool forceValidate, out string validationMessage)
        {
            validationMessage = string.Empty;
            StringBuilder result = new StringBuilder();

            var appId = Config.Default.AppId;

            // checking the port values are within the valid range
            if (ServerPort < ushort.MinValue || ServerPort > ushort.MaxValue)
            {
                var message = _globalizer.GetResourceString("ProfileValidation_ServerPort")?.Replace("{PortMinimum}", ushort.MinValue.ToString()).Replace("{PortMaximum}", ushort.MaxValue.ToString());
                result.AppendLine(message);
            }
            if (ServerPeerPort < ushort.MinValue || ServerPeerPort > ushort.MaxValue)
            {
                var message = _globalizer.GetResourceString("ProfileValidation_ServerPeerPort")?.Replace("{PortMinimum}", ushort.MinValue.ToString()).Replace("{PortMaximum}", ushort.MaxValue.ToString());
                result.AppendLine(message);
            }
            if (QueryPort < ushort.MinValue || QueryPort > ushort.MaxValue)
            {
                var message = _globalizer.GetResourceString("ProfileValidation_QueryPort")?.Replace("{PortMinimum}", ushort.MinValue.ToString()).Replace("{PortMaximum}", ushort.MaxValue.ToString());
                result.AppendLine(message);
            }
            if (RconPort < ushort.MinValue || RconPort > ushort.MaxValue)
            {
                var message = _globalizer.GetResourceString("ProfileValidation_RconPort")?.Replace("{PortMinimum}", ushort.MinValue.ToString()).Replace("{PortMaximum}", ushort.MaxValue.ToString());
                result.AppendLine(message);
            }

            if (forceValidate || Config.Default.ValidateProfileOnServerStart)
            {
                // build a list of mods to be processed
                var modIds = ModUtils.GetModIdList(ServerModIds);
                modIds = ModUtils.ValidateModList(modIds);

                var modIdList = new List<string>();
                modIdList.AddRange(modIds);

                modIdList = ModUtils.ValidateModList(modIdList);

                var modDetails = SteamUtils.GetSteamModDetails(modIdList);

                // check for map name.
                if (string.IsNullOrWhiteSpace(ServerMap))
                {
                    var message = _globalizer.GetResourceString("ProfileValidation_MapNameBlank");
                    result.AppendLine(message);
                }

                // check if the server executable exists
                var serverFolder = Path.Combine(InstallDirectory, Config.Default.ServerBinaryRelativePath);
                var serverFile = Path.Combine(serverFolder, Config.Default.ServerExeFile);
                if (!Directory.Exists(serverFolder))
                {
                    var message = _globalizer.GetResourceString("ProfileValidation_ServerNotDownloaded");
                    result.AppendLine(message);
                }
                else if (!File.Exists(serverFile))
                {
                    var message = _globalizer.GetResourceString("ProfileValidation_ServerExeNotDownloaded")?.Replace("{ServerExe}", Config.Default.ServerExeFile);
                    result.AppendLine(message);
                }
                else
                {
                    var serverAppId = GetServerAppId();
                    if (!serverAppId.Equals(appId))
                    {
                        var message = _globalizer.GetResourceString("ProfileValidation_ServerDifferentApplication");
                        result.AppendLine(message);
                    }
                }

                // check for the mods
                foreach (var modId in modIds)
                {
                    var modFilename = $"{modId}.pak";
                    var modFile = IOUtils.NormalizePath(Path.Combine(ModUtils.GetModRootPath(InstallDirectory), modFilename));
                    if (!File.Exists(modFile))
                    {
                        var message = _globalizer.GetResourceString("ProfileValidation_ModFileNotDownloaded")?.Replace("{modId}", modId);
                        result.AppendLine(message);
                    }
                    else
                    {
                        var modDetail = modDetails?.publishedfiledetails?.FirstOrDefault(d => d.publishedfileid.Equals(modId));
                        if (modDetail != null && modDetail.consumer_app_id != null)
                        {
                            if (!modDetail.consumer_app_id.Equals(appId))
                            {
                                var message = _globalizer.GetResourceString("ProfileValidation_ModDifferentApplication")?.Replace("modId", modId);
                                result.AppendLine(message);
                            }
                            else
                            {
                                var modVersion = ModUtils.GetModLatestTime(ModUtils.GetLatestModTimeFile(InstallDirectory, modId));
                                if (modVersion == 0 || !modVersion.Equals(modDetail.time_updated))
                                {
                                    var message = _globalizer.GetResourceString("ProfileValidation_ModOutdated")?.Replace("{modId}", modId);
                                    result.AppendLine(message);
                                }
                            }
                        }
                        else
                        {
                            var message = _globalizer.GetResourceString("ProfileValidation_ModSteamError")?.Replace("{modId}", modId);
                            result.AppendLine(message);
                        }
                    }
                }
            }

            validationMessage = result.ToString();
            return string.IsNullOrWhiteSpace(validationMessage);
        }

        public string ToOutputString()
        {
            //
            // serializes the profile to a string
            //
            return JsonUtils.Serialize<ServerProfile>(this);
        }

        public int RestoreSaveFiles(string restoreFile, bool isArchiveFile)
        {
            if (string.IsNullOrWhiteSpace(restoreFile) || !File.Exists(restoreFile))
            {
                var message = _globalizer.GetResourceString("RestoreSaveFiles_BackupFileNotFound");
                throw new FileNotFoundException(message, restoreFile);
            }

            var saveFolder = GetProfileSavePath(this);
            if (!Directory.Exists(saveFolder))
            {
                var message = _globalizer.GetResourceString("RestoreSaveFiles_SaveFolderNotFound")?.Replace("{saveFolder}", saveFolder);
                throw new DirectoryNotFoundException(message);
            }

            var worldFileName = ServerMapSaveFileName;

            // check if the archive file contains the world save file at minimum
            if (isArchiveFile)
            {
                if (!ZipUtils.DoesFileExist(restoreFile, worldFileName))
                {
                    var message = _globalizer.GetResourceString("RestoreSaveFiles_MissingWorldSaveFile");
                    throw new Exception(message);
                }
            }

            // create a backup of the existing save folder
            var app = new ServerApp(true)
            {
                BackupWorldFile = false,
                DeleteOldBackupFiles = false,
                SendAlerts = false,
                SendEmails = false,
                OutputLogs = false
            };
            app.CreateServerBackupArchiveFile(null, ServerProfileSnapshot.Create(this));

            var worldFile = IOUtils.NormalizePath(Path.Combine(saveFolder, worldFileName));
            var restoreFileInfo = new FileInfo(restoreFile);
            var restoredFileCount = 0;

            if (isArchiveFile)
            {
                // create a list of files to be deleted
                var files = new List<string>();
                // add the current world save file
                files.Add(worldFile);
                // add the world save support files
                files.AddRange(Directory.GetFiles(saveFolder, $"{worldFileName}-*"));

                // delete the selected files
                foreach (var file in files)
                {
                    try
                    {
                        File.Delete(file);
                    }
                    catch
                    {
                        // if unable to delete, do not bother
                    }
                }

                // restore the files from the backup
                restoredFileCount = ZipUtils.ExtractAFile(restoreFile, worldFileName, saveFolder);
            }
            else
            {
                // copy the selected file
                File.Copy(restoreFile, worldFile, true);
                File.SetCreationTime(worldFile, restoreFileInfo.CreationTime);
                File.SetLastWriteTime(worldFile, restoreFileInfo.LastWriteTime);
                File.SetLastAccessTime(worldFile, restoreFileInfo.LastAccessTime);

                restoredFileCount = 1;
            }

            return restoredFileCount;
        }

        public void UpdateProfileToolTip()
        {
            ProfileToolTip = $"{ProfileName ?? string.Empty} ({ProfileID ?? string.Empty})";
        }

        public void ValidateServerName()
        {
            ServerNameLength = Encoding.UTF8.GetByteCount(ServerName);
            ServerNameLengthToLong = ServerNameLength > 48;
        }

        public void ValidateMOTD()
        {
            MOTDLength = Encoding.UTF8.GetByteCount(MOTD);
            MOTDLengthToLong = MOTDLength > 200;

            MOTDLineCount = string.IsNullOrWhiteSpace(MOTD) ? 0 : MOTD.Split(new string[] { Environment.NewLine }, StringSplitOptions.None).Length;
            MOTDLineCountToLong = MOTDLineCount > 5;
        }

        #endregion

        #region Reset Methods
        public void ResetProfileId()
        {
            this.ProfileID = Guid.NewGuid().ToString();
        }

        public void ResetRconWindowExtents()
        {
            this.ClearValue(RconWindowExtentsProperty);
        }

        public void ResetServerOptions()
        {
            this.ClearValue(UseVACProperty);
            this.ClearValue(UseBattlEyeProperty);
            this.ClearValue(AllowFamilySharedAccountProperty);
            this.ClearValue(ServerRegionProperty);
            this.ClearValue(MaxPlayersProperty);

            this.ClearValue(KickIdlePlayersPercentageProperty);
            this.ClearValue(KickIdlePlayersPeriodProperty);
        }

        // section reset methods
        public void ResetAdministrationSection()
        {
            this.ClearValue(ServerNameProperty);
            this.ClearValue(ServerPasswordProperty);
            this.ClearValue(AdminPasswordProperty);

            this.ClearValue(ServerIPProperty);
            this.ClearValue(ServerPortProperty);
            this.ClearValue(ServerPeerPortProperty);
            this.ClearValue(QueryPortProperty);

            this.ClearValue(ServerMapProperty);
            this.ClearValue(ServerMapSaveFileNameProperty);
            this.ClearValue(ServerModIdsProperty);

            this.ClearValue(RconEnabledProperty);
            this.ClearValue(RconPortProperty);
            this.ClearValue(RconPasswordProperty);

            this.ClearValue(MOTDProperty);
            this.ClearValue(MOTDIntervalEnabledProperty);
            this.ClearValue(MOTDIntervalProperty);

            ResetServerOptions();

            this.ClearValue(BranchNameProperty);
            this.ClearValue(BranchPasswordProperty);

            this.ClearValue(ProcessPriorityProperty);
            this.ClearValue(ProcessAffinityProperty);

            this.ClearValue(LauncherArgsOverrideProperty);
            this.ClearValue(LauncherArgsProperty);
            this.ClearValue(AdditionalArgsProperty);
        }

        public void ResetDiscordBotSection()
        {
            this.ClearValue(DiscordChannelIdProperty);
            this.ClearValue(DiscordAliasProperty);

            this.ClearValue(AllowDiscordBackupProperty);
            this.ClearValue(AllowDiscordRestartProperty);
            this.ClearValue(AllowDiscordShutdownProperty);
            this.ClearValue(AllowDiscordStartProperty);
            this.ClearValue(AllowDiscordStopProperty);
            this.ClearValue(AllowDiscordUpdateProperty);
        }
        #endregion

        #region Sync Methods
        public void SyncSettings(ServerProfileCategory category, ServerProfile sourceProfile)
        {
            if (sourceProfile == null)
                return;

            switch (category)
            {
                case ServerProfileCategory.Administration:
                    SyncAdministrationSection(sourceProfile);
                    break;
                case ServerProfileCategory.AutomaticManagement:
                    SyncAutomaticManagement(sourceProfile);
                    break;
                case ServerProfileCategory.DiscordBot:
                    SyncDiscordBot(sourceProfile);
                    break;
                case ServerProfileCategory.ServerFiles:
                    SyncServerFiles(sourceProfile);
                    break;
            }
        }

        private void SyncAdministrationSection(ServerProfile sourceProfile)
        {
            this.SetValue(ServerModIdsProperty, sourceProfile.ServerModIds);

            this.SetValue(MOTDProperty, sourceProfile.MOTD);
            this.SetValue(MOTDIntervalEnabledProperty, sourceProfile.MOTDIntervalEnabled);
            this.SetValue(MOTDIntervalProperty, sourceProfile.MOTDInterval);

            this.SetValue(UseVACProperty, sourceProfile.UseVAC);
            this.SetValue(UseBattlEyeProperty, sourceProfile.UseBattlEye);
            this.SetValue(AllowFamilySharedAccountProperty, sourceProfile.AllowFamilySharedAccount);
            this.SetValue(ServerRegionProperty, sourceProfile.ServerRegion);
            this.SetValue(MaxPlayersProperty, sourceProfile.MaxPlayers);

            this.SetValue(KickIdlePlayersPercentageProperty, sourceProfile.KickIdlePlayersPercentage);
            this.SetValue(KickIdlePlayersPeriodProperty, sourceProfile.KickIdlePlayersPeriod);

            this.SetValue(BranchNameProperty, sourceProfile.BranchName);
            this.SetValue(BranchPasswordProperty, sourceProfile.BranchPassword);

            this.SetValue(LauncherArgsOverrideProperty, sourceProfile.LauncherArgsOverride);
            this.SetValue(LauncherArgsProperty, sourceProfile.LauncherArgs);
            this.SetValue(AdditionalArgsProperty, sourceProfile.AdditionalArgs);
        }

        private void SyncAutomaticManagement(ServerProfile sourceProfile)
        {
            this.SetValue(EnableAutoBackupProperty, sourceProfile.EnableAutoBackup);
            this.SetValue(EnableAutoStartProperty, sourceProfile.EnableAutoStart);
            this.SetValue(EnableAutoUpdateProperty, sourceProfile.EnableAutoUpdate);
            this.SetValue(EnableAutoShutdown1Property, sourceProfile.EnableAutoShutdown1);
            this.SetValue(AutoShutdownTime1Property, sourceProfile.AutoShutdownTime1);
            this.SetValue(ShutdownDaysOfTheWeek1Property, sourceProfile.ShutdownDaysOfTheWeek1);
            this.SetValue(RestartAfterShutdown1Property, sourceProfile.RestartAfterShutdown1);
            this.SetValue(UpdateAfterShutdown1Property, sourceProfile.UpdateAfterShutdown1);
            this.SetValue(EnableAutoShutdown2Property, sourceProfile.EnableAutoShutdown2);
            this.SetValue(AutoShutdownTime2Property, sourceProfile.AutoShutdownTime2);
            this.SetValue(ShutdownDaysOfTheWeek2Property, sourceProfile.ShutdownDaysOfTheWeek2);
            this.SetValue(RestartAfterShutdown2Property, sourceProfile.RestartAfterShutdown2);
            this.SetValue(UpdateAfterShutdown2Property, sourceProfile.UpdateAfterShutdown2);
            this.SetValue(AutoRestartIfShutdownProperty, sourceProfile.AutoRestartIfShutdown);
        }

        private void SyncDiscordBot(ServerProfile sourceProfile)
        {
            this.SetValue(DiscordChannelIdProperty, sourceProfile.DiscordChannelId);
            this.SetValue(DiscordAliasProperty, sourceProfile.DiscordAlias);

            this.SetValue(AllowDiscordBackupProperty, sourceProfile.AllowDiscordBackup);
            this.SetValue(AllowDiscordRestartProperty, sourceProfile.AllowDiscordRestart);
            this.SetValue(AllowDiscordShutdownProperty, sourceProfile.AllowDiscordShutdown);
            this.SetValue(AllowDiscordStartProperty, sourceProfile.AllowDiscordStart);
            this.SetValue(AllowDiscordStopProperty, sourceProfile.AllowDiscordStop);
            this.SetValue(AllowDiscordUpdateProperty, sourceProfile.AllowDiscordUpdate);
        }

        private void SyncServerFiles(ServerProfile sourceProfile)
        {
            this.SetValue(ServerFilesBlacklistedProperty, sourceProfile.ServerFilesBlacklisted);
            this.SetValue(EnableWhitelistProperty, sourceProfile.EnableWhitelist);
            this.SetValue(ServerFilesWhitelistedProperty, sourceProfile.ServerFilesWhitelisted);

            SaveServerFileBlacklisted();
            SaveServerFileWhitelisted();
        }

        public void SyncMapSaveFileName()
        {
            var mapSaveFileName = GameData.MapSaveNameForClass(ServerMap, true);
            if (!string.IsNullOrWhiteSpace(mapSaveFileName))
            {
                this.ServerMapSaveFileName = mapSaveFileName;
            }
        }
        #endregion

        #region Server Files 
        private void ServerFilesWatcher_Changed(object sender, FileSystemEventArgs e)
        {
            var blacklistFile = false;
            var whitelistFile = false;

            if (e.Name.Equals(Config.Default.ServerBlacklistFile, StringComparison.OrdinalIgnoreCase))
            {
                blacklistFile = true;
            }
            if (e.Name.Equals(Config.Default.ServerWhitelistFile, StringComparison.OrdinalIgnoreCase))
            {
                whitelistFile = true;
            }

            TaskUtils.RunOnUIThreadAsync(() => LoadServerFiles(blacklistFile, whitelistFile)).DoNotWait();
        }

        private void ServerFilesWatcher_Error(object sender, ErrorEventArgs e)
        {
            TaskUtils.RunOnUIThreadAsync(() => SetupServerFilesWatcher()).DoNotWait();
        }

        public void DestroyServerFilesWatcher()
        {
            if (_serverFilesWatcher == null)
                return;

            _serverFilesWatcher.EnableRaisingEvents = false;
            _serverFilesWatcher.Changed -= ServerFilesWatcher_Changed;
            _serverFilesWatcher.Created -= ServerFilesWatcher_Changed;
            _serverFilesWatcher.Deleted -= ServerFilesWatcher_Changed;
            _serverFilesWatcher.Error -= ServerFilesWatcher_Error;
            _serverFilesWatcher = null;
        }

        public void SetupServerFilesWatcher()
        {
            if (_serverFilesWatcher != null)
                DestroyServerFilesWatcher();

            if (!EnableServerFilesWatcher)
                return;

            var path = GetServerSavedFilePath();
            if (string.IsNullOrWhiteSpace(path) || !Directory.Exists(path))
                return;

            _serverFilesWatcher = new FileSystemWatcher
            {
                Path = path,
                NotifyFilter = NotifyFilters.LastWrite,
            };

            _serverFilesWatcher.Changed += ServerFilesWatcher_Changed;
            _serverFilesWatcher.Created += ServerFilesWatcher_Changed;
            _serverFilesWatcher.Deleted += ServerFilesWatcher_Changed;
            _serverFilesWatcher.Error += ServerFilesWatcher_Error;
            _serverFilesWatcher.EnableRaisingEvents = true;
        }

        public void LoadServerFiles(bool blacklistFile, bool whitelistFile)
        {
            try
            {
                var list1 = this.ServerFilesBlacklisted ?? new PlayerUserList();
                var list2 = this.ServerFilesWhitelisted ?? new PlayerUserList();

                var allSteamIds = new List<string>();
                string[] blacklistSteamIds = null;
                string[] whitelistSteamIds = null;

                if (blacklistFile)
                {
                    var file = Path.Combine(InstallDirectory, Config.Default.ServerBinaryRelativePath, Config.Default.ServerBlacklistFile);
                    if (File.Exists(file))
                    {
                        blacklistSteamIds = File.ReadAllLines(file);
                        allSteamIds.AddRange(blacklistSteamIds);
                    }
                }

                if (whitelistFile)
                {
                    var file = Path.Combine(InstallDirectory, Config.Default.ServerBinaryRelativePath, Config.Default.ServerWhitelistFile);
                    if (File.Exists(file))
                    {
                        whitelistSteamIds = File.ReadAllLines(file);
                        allSteamIds.AddRange(whitelistSteamIds);
                    }
                }

                // remove all duplicates
                allSteamIds = allSteamIds.Distinct().ToList();

                // fetch the details of all steam users in the list
                var steamUsers = SteamUtils.GetSteamUserDetails(allSteamIds);

                if (blacklistFile && blacklistSteamIds != null)
                {
                    list1 = PlayerUserList.GetList(steamUsers, blacklistSteamIds);
                }

                if (whitelistFile && whitelistSteamIds != null)
                {
                    list2 = PlayerUserList.GetList(steamUsers, whitelistSteamIds);
                }

                this.ServerFilesBlacklisted = list1;
                this.ServerFilesWhitelisted = list2;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, _globalizer.GetResourceString("ServerSettings_ServerFilesLoadErrorTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        public void SaveServerFileBlacklisted()
        {
            try
            {
                var folder = Path.Combine(InstallDirectory, Config.Default.SavedFilesRelativePath);
                if (!Directory.Exists(folder))
                    Directory.CreateDirectory(folder);

                var file = Path.Combine(folder, Config.Default.ServerBlacklistFile);
                File.WriteAllLines(file, this.ServerFilesBlacklisted.ToEnumerable());
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, _globalizer.GetResourceString("ServerSettings_ServerFilesSaveErrorTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        public void SaveServerFileWhitelisted()
        {
            try
            {
                var folder = Path.Combine(InstallDirectory, Config.Default.SavedFilesRelativePath);
                if (!Directory.Exists(folder))
                    Directory.CreateDirectory(folder);

                var file = Path.Combine(folder, Config.Default.ServerWhitelistFile);
                File.WriteAllLines(file, this.ServerFilesWhitelisted.ToEnumerable());
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, _globalizer.GetResourceString("ServerSettings_ServerFilesSaveErrorTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
        #endregion

        #region Static Profile Methods
        public static string GetProfileMapName(ServerProfile profile)
        {
            return GetProfileMapName(profile?.ServerMap);
        }

        public static string GetProfileMapName(string serverMap)
        {
            return ModUtils.GetMapName(serverMap);
        }

        public static string GetProfileSavePath(ServerProfile profile)
        {
            return GetProfileSavePath(profile?.InstallDirectory);
        }

        public static string GetProfileSavePath(string installDirectory)
        {
            return Path.Combine(installDirectory ?? string.Empty, Config.Default.SavedFilesRelativePath);
        }
        #endregion

        #endregion
    }
}