HumanoidProfileEditor.xaml.cs

using System.IO;
using System.Linq;
using System.Numerics;
using Content.Client._WL.Records; // WL-Records
using Content.Client._WL.Skills.Ui; // WL-Skills
using Content.Client.Electrocution;
using Content.Client.Guidebook;
using Content.Client.Humanoid;
using Content.Client.Lobby.UI.Loadouts;
using Content.Client.Lobby.UI.Roles;
using Content.Client.Message;
using Content.Client.Players.PlayTimeTracking;
using Content.Client.Stylesheets;
using Content.Client.Sprite;
using Content.Client.UserInterface.Systems.Guidebook;
using Content.Shared._WL.Skills; // WL-Skills
using Content.Shared.CCVar;
using Content.Shared.Clothing;
using Content.Shared.Corvax.CCCVars;
using Content.Shared.GameTicking;
using Content.Shared.Guidebook;
using Content.Shared.Humanoid;
using Content.Shared.Humanoid.Markings;
using Content.Shared.Humanoid.Prototypes;
using Content.Shared.Preferences;
using Content.Shared.Preferences.Loadouts;
using Content.Shared.Roles;
using Content.Shared.Traits;
using Robust.Client.AutoGenerated;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Player;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.XAML;
using Robust.Client.Utility;
using Robust.Shared.Configuration;
using Robust.Shared.ContentPack;
using Robust.Shared.Enums;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
using Direction = Robust.Shared.Maths.Direction;
using static Content.Client.Corvax.SponsorOnlyHelpers; // Corvax-Sponsors
using Content.Client.Corvax.TTS;
using Content.Client.Lathe.UI; // Corvax-TTS

namespace Content.Client.Lobby.UI
{
    public sealed partial class SubnameSelector : Control
    {
        public readonly JobPrototype Job;

        public Action<int, string, bool>? SubnameChanged;

        private readonly List<string> _subnames;

        public readonly OptionButton? Options;

        // WL-changes start
        public SubnameSelector(JobPrototype job, Gender gender)
        {
            Job = job;

            var subnames = new List<string>()
            {
                job.LocalizedName
            };
            subnames.AddRange(job.GetSubnames(gender).Order());

            _subnames = subnames;

            if (_subnames.Count > 1)
            {
                Options = new() { HorizontalAlignment = HAlignment.Left };

                var indexer = 0;
                foreach (var subname in subnames)
                {
                    Options.AddItem(subname, indexer);
                    indexer += 1;
                }

                Options.OnItemSelected += (args) =>
                {
                    SelectItem(args.Id, false);
                };

                AddChild(Options);
            }
            else AddChild(new Label() { Text = _subnames.First() });
        }
        // WL-changes End

        public void SelectItem(int index, bool silent)
        {
            if (Options == null)
                return;

            Options.SelectId(index);

            SubnameChanged?.Invoke(index, _subnames[index], silent);
        }

        public void SelectItem(string subname, bool silent)
        {
            var index = _subnames.IndexOf(subname);

            SelectItem(index, silent);
        }
    }


    [GenerateTypedNameReferences]
    public sealed partial class HumanoidProfileEditor : BoxContainer
    {
        private readonly IClientPreferencesManager _preferencesManager;
        private readonly IConfigurationManager _cfgManager;
        private readonly IEntityManager _entManager;
        private readonly IFileDialogManager _dialogManager;
        private readonly IPlayerManager _playerManager;
        private readonly IPrototypeManager _prototypeManager;
        private readonly IResourceManager _resManager;
        private readonly MarkingManager _markingManager;
        private readonly JobRequirementsManager _requirements;
        private readonly LobbyUIController _controller;

        private readonly SpriteSystem _sprite;

        // CCvar.
        private int _maxNameLength;
        private bool _allowFlavorText;

        private FlavorText.FlavorText? _flavorText;
        private TextEdit? _flavorTextEdit;

        // One at a time.
        private LoadoutWindow? _loadoutWindow;
        private SkillsWindow? _skillsWindow; // WL-Skills

        private TTSTab? _ttsTab; // Corvax-TTS

        private bool _exporting;
        private bool _imaging;

        /// <summary>
        /// If we're attempting to save.
        /// </summary>
        public event Action? Save;

        /// <summary>
        /// Entity used for the profile editor preview
        /// </summary>
        public EntityUid PreviewDummy;

        /// <summary>
        /// Temporary override of their selected job, used to preview roles.
        /// </summary>
        public JobPrototype? JobOverride;

        /// <summary>
        /// The character slot for the current profile.
        /// </summary>
        public int? CharacterSlot;

        /// <summary>
        /// The work in progress profile being edited.
        /// </summary>
        public HumanoidCharacterProfile? Profile;

        private List<SpeciesPrototype> _species = new();

        private List<(string, SubnameSelector, RequirementsSelector)> _jobPriorities = new(); //WL-changes

        private readonly Dictionary<string, BoxContainer> _jobCategories;

        private Direction _previewRotation = Direction.North;

        private ColorSelectorSliders _rgbSkinColorSelector;

        private bool _isDirty;

        private MarkingSet _markingSet = new(); // storing this here feels iffy but a few things need it this high up

        private Marking? _underwearMarking; // WL-Underwear
        private Marking? _undershirtMarking; // WL-Underwear
        private Marking? _socksMarking; // WL-Underwear

        public event Action<HumanoidCharacterProfile, int>? OnProfileChanged;

        private LineEdit _heightEdit => CHeightEdit; // WL-Height

        private TextEdit _oocTextEdit = null!; // WL-OOCText

        private RecordsTab? _recordsTab; // WL-Records
        private TextEdit? _medicalRecordEdit; // WL-Records
        private TextEdit? _securityRecordEdit; // WL-Records
        private TextEdit? _employmentRecordEdit; // WL-Records

        private LineEdit? _generalRecordNameEdit;
        private LineEdit? _generalRecordAgeEdit;
        private LineEdit? _generalRecordCountryEdit;

        private OptionButton? _confederationButton; // WL-Recordss

        private List<string> _confederations = new List<string>() {
            "Конфедерация Орионских Государств", "СоцКон", "Межвидовой Альянс", "Священная Империя Эдема" };

        private SingleMarkingPicker _underwearPicker => CUnderwearPicker; // WL-Underwear
        private SingleMarkingPicker _undershirtPicker => CUndershirtPicker; // WL-Underwear
        private SingleMarkingPicker _socksPicker => CSocksPicker; // WL-Underwear


        [ValidatePrototypeId<GuideEntryPrototype>]
        private static readonly ProtoId<GuideEntryPrototype> DefaultSpeciesGuidebook = "Species";

        public event Action<List<ProtoId<GuideEntryPrototype>>>? OnOpenGuidebook;

        private ISawmill _sawmill;

        public HumanoidProfileEditor(
            IClientPreferencesManager preferencesManager,
            IConfigurationManager configurationManager,
            IEntityManager entManager,
            IFileDialogManager dialogManager,
            ILogManager logManager,
            IPlayerManager playerManager,
            IPrototypeManager prototypeManager,
            IResourceManager resManager,
            JobRequirementsManager requirements,
            MarkingManager markings)
        {
            RobustXamlLoader.Load(this);
            _sawmill = logManager.GetSawmill("profile.editor");
            _cfgManager = configurationManager;
            _entManager = entManager;
            _dialogManager = dialogManager;
            _playerManager = playerManager;
            _prototypeManager = prototypeManager;
            _markingManager = markings;
            _preferencesManager = preferencesManager;
            _resManager = resManager;
            _requirements = requirements;
            _controller = UserInterfaceManager.GetUIController<LobbyUIController>();
            _sprite = _entManager.System<SpriteSystem>();

            _maxNameLength = _cfgManager.GetCVar(CCVars.MaxNameLength);
            _allowFlavorText = _cfgManager.GetCVar(CCVars.FlavorText);

            ImportButton.OnPressed += args =>
            {
                ImportProfile();
            };

            ExportButton.OnPressed += args =>
            {
                ExportProfile();
            };

            ExportImageButton.OnPressed += args =>
            {
                ExportImage();
            };

            OpenImagesButton.OnPressed += args =>
            {
                _resManager.UserData.OpenOsWindow(ContentSpriteSystem.Exports);
            };

            ResetButton.OnPressed += args =>
            {
                SetProfile((HumanoidCharacterProfile?) _preferencesManager.Preferences?.SelectedCharacter, _preferencesManager.Preferences?.SelectedCharacterIndex);
            };

            SaveButton.OnPressed += args =>
            {
                if (_flavorTextEdit != null && _oocTextEdit != null)
                {
                    Profile = Profile?
                        .WithFlavorText(Rope.Collapse(_flavorTextEdit.TextRope).Trim())
                        .WithOocText(Rope.Collapse(_oocTextEdit.TextRope).Trim()); //WL-Changes
                }
                RefreshSkills(); // WL-Skills
                Save?.Invoke();
            };

            #region Left

            #region Name

            NameEdit.OnTextChanged += args => { SetName(args.Text); };
            NameEdit.IsValid = args => args.Length <= _maxNameLength;
            NameRandomize.OnPressed += args => RandomizeName();
            RandomizeEverythingButton.OnPressed += args => { RandomizeEverything(); };
            //WarningLabel.SetMarkup($"[color=red]{Loc.GetString("humanoid-profile-editor-naming-rules-warning")}[/color]"); //WL-HRP: ׸-�� ��� ���� ��������, ������, ��� ��� ������ � ���-���

            #endregion Name

            #region Appearance

            TabContainer.SetTabTitle(0, Loc.GetString("humanoid-profile-editor-appearance-tab"));

            #region Sex

            SexButton.OnItemSelected += args =>
            {
                SexButton.SelectId(args.Id);
                SetSex((Sex) args.Id);
            };

            #endregion Sex

            #region Age

            AgeEdit.OnTextChanged += args =>
            {
                if (!int.TryParse(args.Text, out var newAge))
                    return;

                SetAge(newAge);
            };

            #endregion Age

            // WL-Height-Start
            #region Height

            _heightEdit.OnTextChanged += args =>
            {
                if (!int.TryParse(args.Text, out var newHeight))
                    return;

                SetCharHeight(newHeight);
            };

            #endregion Height
            // WL-Height-End

            #region Gender

            PronounsButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-male-text"), (int) Gender.Male);
            PronounsButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-female-text"), (int) Gender.Female);
            PronounsButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-epicene-text"), (int) Gender.Epicene);
            PronounsButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-neuter-text"), (int) Gender.Neuter);

            PronounsButton.OnItemSelected += args =>
            {
                PronounsButton.SelectId(args.Id);
                SetGender((Gender) args.Id);
            };

            #endregion Gender

            RefreshSpecies();

            SpeciesButton.OnItemSelected += args =>
            {
                SpeciesButton.SelectId(args.Id);
                SetSpecies(_species[args.Id].ID);
                UpdateHairPickers();
                OnSkinColorOnValueChanged();
            };

            #region Skin

            Skin.OnValueChanged += _ =>
            {
                OnSkinColorOnValueChanged();
            };

            RgbSkinColorContainer.AddChild(_rgbSkinColorSelector = new ColorSelectorSliders());
            _rgbSkinColorSelector.SelectorType = ColorSelectorSliders.ColorSelectorType.Hsv; // defaults color selector to HSV
            _rgbSkinColorSelector.OnColorChanged += _ =>
            {
                OnSkinColorOnValueChanged();
            };

            #endregion

            #region Hair

            HairStylePicker.OnMarkingSelect += newStyle =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithHairStyleName(newStyle.id));
                ReloadPreview();
            };

            HairStylePicker.OnColorChanged += newColor =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithHairColor(newColor.marking.MarkingColors[0]));
                UpdateCMarkingsHair();
                ReloadPreview();
            };

            FacialHairPicker.OnMarkingSelect += newStyle =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithFacialHairStyleName(newStyle.id));
                ReloadPreview();
            };

            FacialHairPicker.OnColorChanged += newColor =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithFacialHairColor(newColor.marking.MarkingColors[0]));
                UpdateCMarkingsFacialHair();
                ReloadPreview();
            };

            HairStylePicker.OnSlotRemove += _ =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithHairStyleName(HairStyles.DefaultHairStyle)
                );
                UpdateHairPickers();
                UpdateCMarkingsHair();
                ReloadPreview();
            };

            FacialHairPicker.OnSlotRemove += _ =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithFacialHairStyleName(HairStyles.DefaultFacialHairStyle)
                );
                UpdateHairPickers();
                UpdateCMarkingsFacialHair();
                ReloadPreview();
            };

            HairStylePicker.OnSlotAdd += delegate ()
            {
                if (Profile is null)
                    return;

                var hair = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.Hair, Profile.Species).Keys
                    .FirstOrDefault();

                if (string.IsNullOrEmpty(hair))
                    return;

                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithHairStyleName(hair)
                );

                UpdateHairPickers();
                UpdateCMarkingsHair();
                ReloadPreview();
            };

            FacialHairPicker.OnSlotAdd += delegate ()
            {
                if (Profile is null)
                    return;

                var hair = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.FacialHair, Profile.Species).Keys
                    .FirstOrDefault();

                if (string.IsNullOrEmpty(hair))
                    return;

                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithFacialHairStyleName(hair)
                );

                UpdateHairPickers();
                UpdateCMarkingsFacialHair();
                ReloadPreview();
            };

            #endregion Hair

            // WL-Underwear-Start
            #region Underwear

            _underwearPicker.OnMarkingSelect += m =>
            {
                if (Profile is null)
                    return;

                if (!_markingManager.Markings.TryGetValue(m.id, out var marking))
                    return;

                if (_underwearMarking != null)
                    Profile.Appearance.Markings.Remove(_underwearMarking);

                _underwearMarking = marking.AsMarking();
                Profile.Appearance.Markings.Add(_underwearMarking);

                SetDirty();
            };
            _underwearPicker.OnColorChanged += m =>
            {
                if (Profile is null)
                    return;

                var idx = Profile.Appearance.Markings.IndexOf(m.marking);
                if (idx > -1)
                    Profile.Appearance.Markings[idx] = m.marking;

                SetDirty();
            };
            _underwearPicker.OnSlotAdd += () =>
            {
                if (Profile is null)
                    return;

                var defaultMarkingId = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.UndergarmentBottom, Profile.Species).Keys
                    .FirstOrDefault();

                if (string.IsNullOrEmpty(defaultMarkingId))
                    return;

                if (!_markingManager.Markings.TryGetValue(defaultMarkingId, out var defaultMarking))
                    return;

                _underwearMarking = defaultMarking.AsMarking();
                Profile.Appearance.Markings.Add(_underwearMarking);

                UpdateUnderwearPicker();
                SetDirty();
            };
            _underwearPicker.OnSlotRemove += _ =>
            {
                if (Profile is null)
                    return;

                if (_underwearMarking != null)
                    Profile.Appearance.Markings.Remove(_underwearMarking);
                _underwearMarking = null;

                UpdateUnderwearPicker();
                SetDirty();
            };

            #endregion

            #region Undershirt

            _undershirtPicker.OnMarkingSelect += m =>
            {
                if (Profile is null)
                    return;

                if (!_markingManager.Markings.TryGetValue(m.id, out var marking))
                    return;

                if (_undershirtMarking != null)
                    Profile.Appearance.Markings.Remove(_undershirtMarking);

                _undershirtMarking = marking.AsMarking();
                Profile.Appearance.Markings.Add(_undershirtMarking);

                SetDirty();
            };
            _undershirtPicker.OnColorChanged += m =>
            {
                if (Profile is null)
                    return;

                var idx = Profile.Appearance.Markings.IndexOf(m.marking);
                if (idx > -1)
                    Profile.Appearance.Markings[idx] = m.marking;

                SetDirty();
            };
            _undershirtPicker.OnSlotAdd += () =>
            {
                if (Profile is null)
                    return;

                var defaultMarkingId = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.UndergarmentTop, Profile.Species).Keys
                    .FirstOrDefault();

                if (string.IsNullOrEmpty(defaultMarkingId))
                    return;

                if (!_markingManager.Markings.TryGetValue(defaultMarkingId, out var defaultMarking))
                    return;

                _undershirtMarking = defaultMarking.AsMarking();
                Profile.Appearance.Markings.Add(_undershirtMarking);

                UpdateUndershirtPicker();
                SetDirty();
            };
            _undershirtPicker.OnSlotRemove += _ =>
            {
                if (Profile is null)
                    return;

                if (_undershirtMarking != null)
                    Profile.Appearance.Markings.Remove(_undershirtMarking);
                _undershirtMarking = null;

                UpdateUndershirtPicker();
                SetDirty();
            };

            #endregion

            #region Socks

            _socksPicker.OnMarkingSelect += m =>
            {
                if (Profile is null)
                    return;

                if (!_markingManager.Markings.TryGetValue(m.id, out var marking))
                    return;

                if (_socksMarking != null)
                    Profile.Appearance.Markings.Remove(_socksMarking);

                _socksMarking = marking.AsMarking();
                Profile.Appearance.Markings.Add(_socksMarking);

                SetDirty();
            };
            _socksPicker.OnColorChanged += m =>
            {
                if (Profile is null)
                    return;

                var idx = Profile.Appearance.Markings.IndexOf(m.marking);
                if (idx > -1)
                    Profile.Appearance.Markings[idx] = m.marking;

                SetDirty();
            };
            _socksPicker.OnSlotAdd += () =>
            {
                if (Profile is null)
                    return;

                var defaultMarkingId = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.Socks, Profile.Species).Keys
                    .FirstOrDefault();

                if (string.IsNullOrEmpty(defaultMarkingId))
                    return;

                if (!_markingManager.Markings.TryGetValue(defaultMarkingId, out var defaultMarking))
                    return;

                _socksMarking = defaultMarking.AsMarking();
                Profile.Appearance.Markings.Add(_socksMarking);

                UpdateSocksPicker();
                SetDirty();
            };
            _socksPicker.OnSlotRemove += _ =>
            {
                if (Profile is null)
                    return;

                if (_socksMarking != null)
                    Profile.Appearance.Markings.Remove(_socksMarking);
                _socksMarking = null;

                UpdateSocksPicker();
                SetDirty();
            };

            #endregion
            // WL-Underwear-End

            #region SpawnPriority

            foreach (var value in Enum.GetValues<SpawnPriorityPreference>())
            {
                SpawnPriorityButton.AddItem(Loc.GetString($"humanoid-profile-editor-preference-spawn-priority-{value.ToString().ToLower()}"), (int) value);
            }

            SpawnPriorityButton.OnItemSelected += args =>
            {
                SpawnPriorityButton.SelectId(args.Id);
                SetSpawnPriority((SpawnPriorityPreference) args.Id);
            };

            #endregion SpawnPriority

            #region Eyes

            EyeColorPicker.OnEyeColorPicked += newColor =>
            {
                if (Profile is null)
                    return;
                Profile = Profile.WithCharacterAppearance(
                    Profile.Appearance.WithEyeColor(newColor));
                Markings.CurrentEyeColor = Profile.Appearance.EyeColor;
                ReloadProfilePreview();
            };

            #endregion Eyes

            #endregion Appearance

            #region Jobs

            TabContainer.SetTabTitle(1, Loc.GetString("humanoid-profile-editor-jobs-tab"));

            PreferenceUnavailableButton.AddItem(
                Loc.GetString("humanoid-profile-editor-preference-unavailable-stay-in-lobby-button"),
                (int) PreferenceUnavailableMode.StayInLobby);
            PreferenceUnavailableButton.AddItem(
                Loc.GetString("humanoid-profile-editor-preference-unavailable-spawn-as-overflow-button",
                              ("overflowJob", Loc.GetString(SharedGameTicker.FallbackOverflowJobName))),
                (int) PreferenceUnavailableMode.SpawnAsOverflow);

            PreferenceUnavailableButton.OnItemSelected += args =>
            {
                PreferenceUnavailableButton.SelectId(args.Id);
                Profile = Profile?.WithPreferenceUnavailable((PreferenceUnavailableMode) args.Id);
                SetDirty();
            };

            _jobCategories = new Dictionary<string, BoxContainer>();

            RefreshAntags();
            RefreshJobs();

            #endregion Jobs

            TabContainer.SetTabTitle(2, Loc.GetString("humanoid-profile-editor-antags-tab"));

            RefreshTraits();

            TabContainer.SetTabTitle(3, Loc.GetString("humanoid-profile-editor-traits-tab")); // Corvax-TTS-Edit

            #region Markings

            TabContainer.SetTabTitle(4, Loc.GetString("humanoid-profile-editor-markings-tab"));

            Markings.OnMarkingAdded += OnMarkingChange;
            Markings.OnMarkingRemoved += OnMarkingChange;
            Markings.OnMarkingColorChange += OnMarkingChange;
            Markings.OnMarkingRankChange += OnMarkingChange;

            #endregion Markings

            RefreshFlavorText();

            RefreshRecords(); // WL-Records

            //_confederationButton.OnItemSelected += args =>
            //{

            //};

            RefreshVoiceTab(); // Corvax-TTS

            #region Dummy

            SpriteRotateLeft.OnPressed += _ =>
            {
                _previewRotation = _previewRotation.TurnCw();
                SetPreviewRotation(_previewRotation);
            };
            SpriteRotateRight.OnPressed += _ =>
            {
                _previewRotation = _previewRotation.TurnCcw();
                SetPreviewRotation(_previewRotation);
            };

            #endregion Dummy

            #endregion Left

            ShowClothes.OnToggled += args =>
            {
                ReloadPreview();
            };

            SpeciesInfoButton.OnPressed += OnSpeciesInfoButtonPressed;

            UpdateSpeciesGuidebookIcon();
            IsDirty = false;
        }

        /// <summary>
        /// Refreshes the flavor text editor status.
        /// </summary>
        public void RefreshFlavorText()
        {
            if (_allowFlavorText)
            {
                if (_flavorText != null)
                    return;

                _flavorText = new FlavorText.FlavorText();
                TabContainer.AddChild(_flavorText);
                TabContainer.SetTabTitle(TabContainer.ChildCount - 1, Loc.GetString("humanoid-profile-editor-flavortext-tab"));
                _flavorTextEdit = _flavorText.CFlavorTextInput;

                _flavorText.OnFlavorTextChanged += OnFlavorTextChange;

                _oocTextEdit = _flavorText.COocTextInput; // WL-OOCText

                _flavorText.OnOocTextChanged += OnOocTextChange; // WL-OOCText
            }
            else
            {
                if (_flavorText == null)
                    return;

                TabContainer.RemoveChild(_flavorText);
                _flavorText.OnFlavorTextChanged -= OnFlavorTextChange;
                _flavorText.Dispose();
                _flavorTextEdit?.Dispose();
                _flavorTextEdit = null;
                _flavorText = null;
            }
        }

        // WL-Records-Start
        public void RefreshRecords()
        {
            if (_recordsTab != null)
                return;

            _recordsTab = new RecordsTab();
            TabContainer.AddChild(_recordsTab);
            TabContainer.SetTabTitle(TabContainer.ChildCount - 1, Loc.GetString("humanoid-profile-editor-records-tab"));

            _medicalRecordEdit = _recordsTab.MedicalRecordInput;
            _securityRecordEdit = _recordsTab.SecurityRecordInput;
            _employmentRecordEdit = _recordsTab.EmploymentRecordInput;

            _generalRecordNameEdit = _recordsTab.NameEdit;
            _generalRecordAgeEdit = _recordsTab.AgeEdit;
            _generalRecordCountryEdit = _recordsTab.CountryEdit;

            _confederationButton = _recordsTab.ConfederationButton;

            _recordsTab.OnMedicalRecordChanged += OnMedicalRecordChange;
            _recordsTab.OnSecurityRecordChanged += OnSecurityRecordChange;
            _recordsTab.OnEmploymentRecordChanged += OnEmploymentRecordChange;

            _recordsTab.OnGeneralRecordNameChanged += OnGeneralRecordNameChanged;
            _recordsTab.OnGeneralRecordAgeChanged += OnGeneralRecordDateOfBirthChanged;
            _recordsTab.OnGeneralRecordCountryChanged += OnGeneralRecordCountryChanged;

            _recordsTab.OnGeneralRecordConfederationChanged += SetConfederation;

            _confederations.Sort((a, b) => string.Compare(a, b, StringComparison.CurrentCultureIgnoreCase));

            for (var i = 0; i < _confederations.Count; i++)
            {
                var name = _confederations[i];


                _recordsTab.ConfederationButton.AddItem(name, i);
            }
        }

        private void OnMedicalRecordChange(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithMedicalRecord(content);
            SetDirty();
        }

        private void OnSecurityRecordChange(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithSecurityRecord(content);
            SetDirty();
        }

        private void OnEmploymentRecordChange(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithEmploymentRecord(content);
            SetDirty();
        }

        private void OnGeneralRecordNameChanged(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithFullName(content);
            SetDirty();
        }
        private void OnGeneralRecordDateOfBirthChanged(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithDateOfBirth(content);
            SetDirty();
        }
        private void OnGeneralRecordCountryChanged(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithCountry(content);
            SetDirty();
        }
        private void SetConfederation(OptionButton.ItemSelectedEventArgs args)
        {
            if (_confederationButton is null)
                return;

            if (Profile is null)
                return;

            _confederationButton.SelectId(args.Id);
            Profile = Profile.WithConfederation(_confederations[args.Id]);
            SetDirty();
        }

        // WL-Records-End
        // Corvax-TTS-Start
        #region Voice

        private void RefreshVoiceTab()
        {
            if (!_cfgManager.GetCVar(CCCVars.TTSEnabled))
                return;

            _ttsTab = new TTSTab();
            var children = new List<Control>();
            foreach (var child in TabContainer.Children)
                children.Add(child);

            TabContainer.RemoveAllChildren();

            for (int i = 0; i < children.Count; i++)
            {
                if (i == 1) // Set the tab to the 2nd place.
                {
                    TabContainer.AddChild(_ttsTab);
                }
                TabContainer.AddChild(children[i]);
            }

            TabContainer.SetTabTitle(1, Loc.GetString("humanoid-profile-editor-voice-tab"));

            _ttsTab.OnVoiceSelected += voiceId =>
            {
                SetVoice(voiceId);
                _ttsTab.SetSelectedVoice(voiceId);
            };

            _ttsTab.OnPreviewRequested += voiceId =>
            {
                _entManager.System<TTSSystem>().RequestPreviewTTS(voiceId, _ttsTab.PreviewTextEdit.Text);
            };
        }

        private void UpdateTTSVoicesControls()
        {
            if (Profile is null || _ttsTab is null)
                return;

            _ttsTab.UpdateControls(Profile, Profile.Sex);
            _ttsTab.SetSelectedVoice(Profile.Voice);
        }

        #endregion
        // Corvax-TTS-End

        /// <summary>
        /// Refreshes traits selector
        /// </summary>
        public void RefreshTraits()
        {
            TraitsList.RemoveAllChildren();

            var traits = _prototypeManager.EnumeratePrototypes<TraitPrototype>().OrderBy(t => Loc.GetString(t.Name)).ToList();
            // TabContainer.SetTabTitle(3, Loc.GetString("humanoid-profile-editor-traits-tab")); // Corvax-TTS-Edit

            if (traits.Count < 1)
            {
                TraitsList.AddChild(new Label
                {
                    Text = Loc.GetString("humanoid-profile-editor-no-traits"),
                    FontColorOverride = Color.Gray,
                });
                return;
            }

            // Setup model
            Dictionary<string, List<string>> traitGroups = new();
            List<string> defaultTraits = new();
            traitGroups.Add(TraitCategoryPrototype.Default, defaultTraits);

            foreach (var trait in traits)
            {
                if (trait.Category == null)
                {
                    defaultTraits.Add(trait.ID);
                    continue;
                }

                if (!_prototypeManager.HasIndex(trait.Category))
                    continue;

                var group = traitGroups.GetOrNew(trait.Category);
                group.Add(trait.ID);
            }

            // Create UI view from model
            foreach (var (categoryId, categoryTraits) in traitGroups)
            {
                TraitCategoryPrototype? category = null;

                if (categoryId != TraitCategoryPrototype.Default)
                {
                    category = _prototypeManager.Index<TraitCategoryPrototype>(categoryId);
                    // Label
                    TraitsList.AddChild(new Label
                    {
                        Text = Loc.GetString(category.Name),
                        Margin = new Thickness(0, 10, 0, 0),
                        StyleClasses = { StyleClass.LabelHeading },
                    });
                }

                List<TraitPreferenceSelector?> selectors = new();
                var selectionCount = 0;

                foreach (var traitProto in categoryTraits)
                {
                    var trait = _prototypeManager.Index<TraitPrototype>(traitProto);
                    var selector = new TraitPreferenceSelector(trait);

                    selector.Preference = Profile?.TraitPreferences.Contains(trait.ID) == true;
                    if (selector.Preference)
                        selectionCount += trait.Cost;

                    selector.PreferenceChanged += preference =>
                    {
                        if (preference)
                        {
                            Profile = Profile?.WithTraitPreference(trait.ID, _prototypeManager);
                        }
                        else
                        {
                            Profile = Profile?.WithoutTraitPreference(trait.ID, _prototypeManager);
                        }

                        SetDirty();
                        RefreshTraits(); // If too many traits are selected, they will be reset to the real value.
                    };
                    selectors.Add(selector);
                }

                // Selection counter
                if (category is { MaxTraitPoints: >= 0 })
                {
                    TraitsList.AddChild(new Label
                    {
                        Text = Loc.GetString("humanoid-profile-editor-trait-count-hint", ("current", selectionCount), ("max", category.MaxTraitPoints)),
                        FontColorOverride = Color.Gray
                    });
                }

                foreach (var selector in selectors)
                {
                    if (selector == null)
                        continue;

                    if (category is { MaxTraitPoints: >= 0 } &&
                        selector.Cost + selectionCount > category.MaxTraitPoints)
                    {
                        selector.Checkbox.Label.FontColorOverride = Color.Red;
                    }

                    TraitsList.AddChild(selector);
                }
            }
        }

        /// <summary>
        /// Refreshes the species selector.
        /// </summary>
        public void RefreshSpecies()
        {
            SpeciesButton.Clear();
            _species.Clear();

            _species.AddRange(_prototypeManager.EnumeratePrototypes<SpeciesPrototype>().Where(o => o.RoundStart));
            _species.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.CurrentCultureIgnoreCase));
            var speciesIds = _species.Select(o => o.ID).ToList();

            for (var i = 0; i < _species.Count; i++)
            {
                var name = Loc.GetString(_species[i].Name);

                if (_species[i].SponsorOnly) // Corvax-Sponsors
                    name += GetSponsorOnlySuffix();

                SpeciesButton.AddItem(name, i);

                if (Profile?.Species.Equals(_species[i].ID) == true)
                {
                    SpeciesButton.SelectId(i);
                }
            }

            // If our species isn't available then reset it to default.
            if (Profile != null)
            {
                if (!speciesIds.Contains(Profile.Species))
                {
                    SetSpecies(SharedHumanoidAppearanceSystem.DefaultSpecies);
                }
            }
        }

        public void RefreshAntags()
        {
            AntagList.RemoveAllChildren();
            var items = new[]
            {
                ("humanoid-profile-editor-antag-preference-yes-button", 0),
                ("humanoid-profile-editor-antag-preference-no-button", 1)
            };

            foreach (var antag in _prototypeManager.EnumeratePrototypes<AntagPrototype>().OrderBy(a => Loc.GetString(a.Name)))
            {
                if (!antag.SetPreference)
                    continue;

                var antagContainer = new BoxContainer()
                {
                    Orientation = LayoutOrientation.Horizontal,
                };

                var selector = new RequirementsSelector()
                {
                    Margin = new Thickness(3f, 3f, 3f, 0f),
                };
                selector.OnOpenGuidebook += OnOpenGuidebook;

                var title = Loc.GetString(antag.Name);
                var description = Loc.GetString(antag.Objective);

                selector.Setup(items, new Label() { Text = title }, 250, description, guides: antag.Guides); //WL-Changes

                selector.Select(Profile?.AntagPreferences.Contains(antag.ID) == true ? 0 : 1);

                if (!_requirements.IsAllowed(
                        antag,
                        (HumanoidCharacterProfile?)_preferencesManager.Preferences?.SelectedCharacter,
                        out var reasons))
                {
                    selector.LockRequirements(JobRequirements.JoinReasons(reasons)); // WL-Changes
                    Profile = Profile?.WithAntagPreference(antag.ID, false);
                    SetDirty();
                }
                else
                {
                    selector.UnlockRequirements();
                }

                selector.OnSelected += preference =>
                {
                    Profile = Profile?.WithAntagPreference(antag.ID, preference == 0);
                    SetDirty();
                };

                antagContainer.AddChild(selector);

                antagContainer.AddChild(new Button()
                {
                    Disabled = true,
                    Text = Loc.GetString("loadout-window"),
                    HorizontalAlignment = HAlignment.Right,
                    Margin = new Thickness(3f, 0f, 0f, 0f),
                });

                AntagList.AddChild(antagContainer);
            }
        }

        private void SetDirty()
        {
            // If it equals default then reset the button.
            if (Profile == null || _preferencesManager.Preferences?.SelectedCharacter.MemberwiseEquals(Profile) == true)
            {
                IsDirty = false;
                return;
            }

            // TODO: Check if profile matches default.
            IsDirty = true;
        }

        /// <summary>
        /// Refresh all loadouts.
        /// </summary>
        public void RefreshLoadouts()
        {
            _loadoutWindow?.Dispose();
        }

        // WL-Skills-start
        public void RefreshSkills()
        {
            _skillsWindow?.Dispose();

            if (Profile == null)
                return;

            var skillsSystem = _entManager.System<SharedSkillsSystem>();
            foreach (var (jobId, skills) in Profile.Skills.ToList())
            {
                if (!_prototypeManager.TryIndex<JobPrototype>(jobId, out var jobProto))
                    continue;

                var currentSkills = skills.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
                var defaultSkills = jobProto.DefaultSkills.ToDictionary(
                    kvp => (byte)kvp.Key,
                    kvp => kvp.Value
                );

                var bonusPoints = jobProto.BonusSkillPoints;
                var racialBonus = CalculateRacialBonus(Profile.Species.Id, Profile.Age);
                var totalPoints = bonusPoints + racialBonus;

                var spentPoints = CalculateSpentPoints(skillsSystem, currentSkills, defaultSkills);

                if (spentPoints > totalPoints)
                {
                    foreach (var (skillKey, defaultValue) in defaultSkills)
                    {
                        Profile = Profile.WithSkill(jobId, skillKey, defaultValue);
                    }

                    var skillsToReset = currentSkills.Keys.Except(defaultSkills.Keys).ToList();
                    foreach (var skillKey in skillsToReset)
                    {
                        Profile = Profile.WithSkill(jobId, skillKey, 1);
                    }

                    SetDirty();
                }
            }
        }

        private int CalculateSpentPoints(SharedSkillsSystem skillsSystem, Dictionary<byte, int> currentSkills, Dictionary<byte, int> defaultSkills)
        {
            var spentPoints = 0;
            foreach (var (skillKey, currentLevel) in currentSkills)
            {
                if (!Enum.IsDefined(typeof(SkillType), (SkillType)skillKey))
                    continue;

                var skillType = (SkillType)skillKey;
                var defaultLevel = defaultSkills.GetValueOrDefault(skillKey, 1);

                if (currentLevel > defaultLevel)
                {
                    var currentCost = skillsSystem.GetSkillTotalCost(skillType, currentLevel);
                    var defaultCost = skillsSystem.GetSkillTotalCost(skillType, defaultLevel);
                    spentPoints += currentCost - defaultCost;
                }
            }

            return spentPoints;
        }
        // WL-Skills-end

        /// <summary>
        /// Reloads the entire dummy entity for preview.
        /// </summary>
        /// <remarks>
        /// This is expensive so not recommended to run if you have a slider.
        /// </remarks>
        private void ReloadPreview()
        {
            _entManager.DeleteEntity(PreviewDummy);
            PreviewDummy = EntityUid.Invalid;

            if (Profile == null || !_prototypeManager.HasIndex(Profile.Species))
                return;

            PreviewDummy = _controller.LoadProfileEntity(Profile, JobOverride, ShowClothes.Pressed);
            SpriteView.SetEntity(PreviewDummy);
            _entManager.System<MetaDataSystem>().SetEntityName(PreviewDummy, Profile.Name);

            // Check and set the dirty flag to enable the save/reset buttons as appropriate.
            SetDirty();
        }

        /// <summary>
        /// Resets the profile to the defaults.
        /// </summary>
        public void ResetToDefault()
        {
            SetProfile(
                (HumanoidCharacterProfile?) _preferencesManager.Preferences?.SelectedCharacter,
                _preferencesManager.Preferences?.SelectedCharacterIndex);
        }

        /// <summary>
        /// Sets the editor to the specified profile with the specified slot.
        /// </summary>
        public void SetProfile(HumanoidCharacterProfile? profile, int? slot)
        {
            Profile = profile?.Clone();
            CharacterSlot = slot;
            IsDirty = false;
            JobOverride = null;

            UpdateNameEdit();
            UpdateFlavorTextEdit();
            UpdateSexControls();
            UpdateGenderControls();
            UpdateSkinColor();
            UpdateSpawnPriorityControls();
            UpdateJobSubnameControls(); // WL-subnames: Pupchansky
            UpdateHeightEdit(); // WL-height
            UpdateOocTextEdit(); // WL-OocText
            UpdateRecordsEdit(); // WL-Records
            UpdateAgeEdit();
            UpdateEyePickers();
            UpdateSaveButton();
            UpdateMarkings();
            UpdateTTSVoicesControls(); // Corvax-TTS
            UpdateHairPickers();
            UpdateCMarkingsHair();
            UpdateCMarkingsFacialHair();

            RefreshAntags();
            RefreshJobs();
            RefreshLoadouts();
            RefreshSkills(); // WL-Skills
            RefreshSpecies();
            RefreshTraits();
            RefreshFlavorText();
            ReloadPreview();

            if (Profile != null)
            {
                PreferenceUnavailableButton.SelectId((int) Profile.PreferenceUnavailable);
            }
        }


        /// <summary>
        /// A slim reload that only updates the entity itself and not any of the job entities, etc.
        /// </summary>
        private void ReloadProfilePreview()
        {
            if (Profile == null || !_entManager.EntityExists(PreviewDummy))
                return;

            _entManager.System<HumanoidAppearanceSystem>().LoadProfile(PreviewDummy, Profile);

            // Check and set the dirty flag to enable the save/reset buttons as appropriate.
            SetDirty();
        }

        private void OnSpeciesInfoButtonPressed(BaseButton.ButtonEventArgs args)
        {
            // TODO GUIDEBOOK
            // make the species guide book a field on the species prototype.
            // I.e., do what jobs/antags do.

            var guidebookController = UserInterfaceManager.GetUIController<GuidebookUIController>();
            var species = Profile?.Species ?? SharedHumanoidAppearanceSystem.DefaultSpecies;
            var page = DefaultSpeciesGuidebook;
            if (_prototypeManager.HasIndex<GuideEntryPrototype>(species))
                page = new ProtoId<GuideEntryPrototype>(species.Id); // Gross. See above todo comment.

            if (_prototypeManager.Resolve(DefaultSpeciesGuidebook, out var guideRoot))
            {
                var dict = new Dictionary<ProtoId<GuideEntryPrototype>, GuideEntry>();
                dict.Add(DefaultSpeciesGuidebook, guideRoot);
                //TODO: Don't close the guidebook if its already open, just go to the correct page

                guidebookController.OpenGuidebook(dict, includeChildren:true, selected: page);
            }
        }

        /// <summary>
        /// Refreshes all job selectors.
        /// </summary>
        public void RefreshJobs()
        {
            JobList.DisposeAllChildren();
            JobList.RemoveAllChildren();
            _jobCategories.Clear();
            _jobPriorities.Clear();
            var firstCategory = true;

            // Get all displayed departments
            var departments = new List<DepartmentPrototype>();
            foreach (var department in _prototypeManager.EnumeratePrototypes<DepartmentPrototype>())
            {
                if (department.EditorHidden)
                    continue;

                departments.Add(department);
            }

            departments.Sort(DepartmentUIComparer.Instance);

            var items = new[]
            {
                ("humanoid-profile-editor-job-priority-never-button", (int) JobPriority.Never),
                ("humanoid-profile-editor-job-priority-low-button", (int) JobPriority.Low),
                ("humanoid-profile-editor-job-priority-medium-button", (int) JobPriority.Medium),
                ("humanoid-profile-editor-job-priority-high-button", (int) JobPriority.High),
            };

            foreach (var department in departments)
            {
                var departmentName = Loc.GetString(department.Name);

                if (!_jobCategories.TryGetValue(department.ID, out var category))
                {
                    category = new BoxContainer
                    {
                        Orientation = LayoutOrientation.Vertical,
                        Name = department.ID,
                        ToolTip = Loc.GetString("humanoid-profile-editor-jobs-amount-in-department-tooltip",
                            ("departmentName", departmentName))
                    };

                    if (firstCategory)
                    {
                        firstCategory = false;
                    }
                    else
                    {
                        category.AddChild(new Control
                        {
                            MinSize = new Vector2(0, 23),
                        });
                    }

                    category.AddChild(new PanelContainer
                    {
                        PanelOverride = new StyleBoxFlat { BackgroundColor = Color.FromHex("#464966") }, //WL-Changes
                        Children =
                        {
                            new Label
                            {
                                Text = Loc.GetString("humanoid-profile-editor-department-jobs-label",
                                    ("departmentName", departmentName)),
                                Margin = new Thickness(5f, 0, 0, 0)
                            }
                        }
                    });

                    _jobCategories[department.ID] = category;
                    JobList.AddChild(category);
                }

                var jobs = department.Roles.Select(jobId => _prototypeManager.Index(jobId))
                    .Where(job => job.SetPreference)
                    .ToArray();

                Array.Sort(jobs, JobUIComparer.Instance);

                foreach (var job in jobs)
                {
                    var jobContainer = new BoxContainer()
                    {
                        Orientation = LayoutOrientation.Horizontal,
                    };

                    var selector = new RequirementsSelector()
                    {
                        Margin = new Thickness(3f, 3f, 3f, 0f),
                    };
                    selector.OnOpenGuidebook += OnOpenGuidebook;

                    var icon = new TextureRect
                    {
                        TextureScale = new Vector2(2, 2),
                        VerticalAlignment = VAlignment.Center
                    };
                    var jobIcon = _prototypeManager.Index(job.Icon);
                    icon.Texture = _sprite.Frame0(jobIcon.Icon);

                    if (!_requirements.IsAllowed(job, (HumanoidCharacterProfile?)_preferencesManager.Preferences?.SelectedCharacter, out var reasons))
                    {
                        selector.LockRequirements(JobRequirements.JoinReasons(reasons)); // WL-Changes
                    }
                    else
                    {
                        selector.UnlockRequirements();
                    }

                    selector.OnSelected += selectedPrio =>
                    {
                        var selectedJobPrio = (JobPriority)selectedPrio;
                        Profile = Profile?.WithJobPriority(job.ID, selectedJobPrio);

                        foreach (var (jobId, _, other) in _jobPriorities)  //WL-Changes
                        {
                            // Sync other selectors with the same job in case of multiple department jobs
                            if (jobId == job.ID)
                            {
                                other.Select(selectedPrio);
                                continue;
                            }

                            if (selectedJobPrio != JobPriority.High || (JobPriority)other.Selected != JobPriority.High)
                                continue;

                            // Lower any other high priorities to medium.
                            other.Select((int)JobPriority.Medium);
                            Profile = Profile?.WithJobPriority(jobId, JobPriority.Medium);
                        }

                        // TODO: Only reload on high change (either to or from).
                        ReloadPreview();

                        UpdateJobPriorities();
                        SetDirty();
                    };


                    var gender = Profile?.Gender ?? Gender.Male; //WL-Changes
                    var subnameSelector = new SubnameSelector(job, gender); //WL-Changes

                    //WL-Changes-start
                    subnameSelector.SubnameChanged += (id, subname, isSilent) =>
                    {
                        Profile = Profile?.WithJobSubname(job.ID, subname);

                        if (!isSilent)
                        {
                            SetDirty();
                        }
                    };

                    if (Profile?.JobSubnames.TryGetValue(job.ID, out var subname) == true)
                    {
                        if (job.GetSubnames(gender).Contains(subname))
                            subnameSelector.SelectItem(subname, true);
                        else subnameSelector.SelectItem(job.LocalizedName, true);
                    }

                    selector.Setup(items, subnameSelector, 200, job.LocalizedDescription, icon, job.Guides);



                    if (Profile is not null)
                    {
                        var loadoutWindowBtn = new Button()
                        {
                            Text = Loc.GetString("loadout-window"),
                            HorizontalAlignment = HAlignment.Right,
                            VerticalAlignment = VAlignment.Center,
                            Margin = new Thickness(3f, 3f, 0f, 0f),
                        };

                        // WL-Skills-start
                        var skillsWindowBtn = new Button()
                        {
                            Text = Loc.GetString("skill-window"),
                            HorizontalAlignment = HAlignment.Right,
                            VerticalAlignment = VAlignment.Center,
                            Margin = new Thickness(3f, 3f, 0f, 0f),
                            ToolTip = Loc.GetString("skill-window-tooltip")
                        };
                        // WL-Skills-end

                        var collection = IoCManager.Instance!;
                        var protoManager = collection.Resolve<IPrototypeManager>();

                        // If no loadout found then disabled button
                        if (!protoManager.TryIndex<RoleLoadoutPrototype>(LoadoutSystem.GetJobPrototype(job.ID), out var roleLoadoutProto))
                        {
                            loadoutWindowBtn.Disabled = true;
                        }
                        // else
                        else
                        {
                            loadoutWindowBtn.OnPressed += args =>
                            {
                                RoleLoadout? loadout = null;

                                // Clone so we don't modify the underlying loadout.
                                Profile?.Loadouts.TryGetValue(LoadoutSystem.GetJobPrototype(job.ID), out loadout);
                                loadout = loadout?.Clone();

                                if (loadout == null)
                                {
                                    loadout = new RoleLoadout(roleLoadoutProto.ID);
                                    loadout.SetDefault(Profile, _playerManager.LocalSession, _prototypeManager);
                                }

                                OpenLoadout(job, loadout, roleLoadoutProto);
                            };
                        }

                        // WL-Skills-start
                        skillsWindowBtn.OnPressed += args =>
                        {
                            OpenSkills(job);
                        };
                        // WL-Skills-end

                        _jobPriorities.Add((job.ID, subnameSelector, selector));
                        jobContainer.AddChild(selector);

                        // WL-Skills-Edit-start
                        var buttonsContainer = new BoxContainer
                        {
                            Orientation = LayoutOrientation.Horizontal,
                            HorizontalAlignment = HAlignment.Right
                        };
                        buttonsContainer.AddChild(loadoutWindowBtn);
                        buttonsContainer.AddChild(skillsWindowBtn);

                        jobContainer.AddChild(buttonsContainer);
                        category.AddChild(jobContainer);
                        // WL-Skills-Edit-end
                    }
                    //WL-Changes-end
                }
            }

            UpdateJobPriorities();
        }

        private void OpenLoadout(JobPrototype? jobProto, RoleLoadout roleLoadout, RoleLoadoutPrototype roleLoadoutProto)
        {
            _loadoutWindow?.Dispose();
            _loadoutWindow = null;
            var collection = IoCManager.Instance;

            if (collection == null || _playerManager.LocalSession == null || Profile == null)
                return;

            JobOverride = jobProto;
            var session = _playerManager.LocalSession;

            _loadoutWindow = new LoadoutWindow(Profile, roleLoadout, roleLoadoutProto, _playerManager.LocalSession, collection)
            {
                Title = Loc.GetString("loadout-window-title-loadout", ("job", $"{jobProto?.LocalizedName}")),
            };

            // Refresh the buttons etc.
            _loadoutWindow.RefreshLoadouts(roleLoadout, session, collection);
            _loadoutWindow.OpenCenteredLeft();

            _loadoutWindow.OnNameChanged += name =>
            {
                roleLoadout.EntityName = name;
                Profile = Profile.WithLoadout(roleLoadout);
                SetDirty();
            };

            _loadoutWindow.OnLoadoutPressed += (loadoutGroup, loadoutProto) =>
            {
                roleLoadout.AddLoadout(loadoutGroup, loadoutProto, _prototypeManager);
                _loadoutWindow.RefreshLoadouts(roleLoadout, session, collection);
                Profile = Profile?.WithLoadout(roleLoadout);
                ReloadPreview();
            };

            _loadoutWindow.OnLoadoutUnpressed += (loadoutGroup, loadoutProto) =>
            {
                roleLoadout.RemoveLoadout(loadoutGroup, loadoutProto, _prototypeManager);
                _loadoutWindow.RefreshLoadouts(roleLoadout, session, collection);
                Profile = Profile?.WithLoadout(roleLoadout);
                ReloadPreview();
            };

            JobOverride = jobProto;
            ReloadPreview();

            _loadoutWindow.OnClose += () =>
            {
                JobOverride = null;
                ReloadPreview();
            };

            if (Profile is null)
                return;

            UpdateJobPriorities();
        }

        // WL-Skills-start
        private void OpenSkills(JobPrototype? jobProto)
        {
            _skillsWindow?.Dispose();
            _skillsWindow = null;

            if (jobProto == null || Profile == null)
                return;

            JobOverride = jobProto;

            var currentSkills = Profile.Skills.GetValueOrDefault(jobProto.ID, new Dictionary<byte, int>());
            var defaultSkills = jobProto.DefaultSkills.ToDictionary(
                kvp => (byte)kvp.Key,
                kvp => kvp.Value
            );

            var bonusPoints = jobProto.BonusSkillPoints;
            var racialBonus = CalculateRacialBonus(Profile.Species, Profile.Age);
            var totalPoints = bonusPoints + racialBonus;

            _skillsWindow = new SkillsWindow(jobProto.ID, currentSkills, defaultSkills, totalPoints);
            _skillsWindow.OnSkillChanged += (jobId, skillKey, newLevel) =>
            {
                Profile = Profile.WithSkill(jobId, skillKey, newLevel);
                SetDirty();
            };

            _skillsWindow.OnClose += () =>
            {
                JobOverride = null;
                ReloadPreview();
            };

            _skillsWindow.OpenCenteredLeft();
            JobOverride = jobProto;
            ReloadPreview();
        }

        private int CalculateRacialBonus(string species, int age)
        {
            var bonus = 0;
            foreach (var racialBonusProto in _prototypeManager.EnumeratePrototypes<RacialSkillBonusPrototype>())
            {
                if (racialBonusProto.Species != species)
                    continue;

                bonus = racialBonusProto.GetBonusForAge(age);
                break;
            }

            return bonus;
        }
        // WL-Skills-end

        private void OnFlavorTextChange(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithFlavorText(content);
            SetDirty();
        }

        // WL-OOCText-Start
        private void OnOocTextChange(string content)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithOocText(content);
            SetDirty();
        }
        // WL-OOCText-End

        private void OnMarkingChange(MarkingSet markings)
        {
            if (Profile is null)
                return;

            Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithMarkings(markings.GetForwardEnumerator().ToList()));
            ReloadProfilePreview();
        }

        private void OnSkinColorOnValueChanged()
        {
            if (Profile is null) return;

            var skin = _prototypeManager.Index<SpeciesPrototype>(Profile.Species).SkinColoration;
            var strategy = _prototypeManager.Index(skin).Strategy;

            switch (strategy.InputType)
            {
                case SkinColorationStrategyInput.Unary:
                {
                    if (!Skin.Visible)
                    {
                        Skin.Visible = true;
                        RgbSkinColorContainer.Visible = false;
                    }

                    var color = strategy.FromUnary(Skin.Value);

                    Markings.CurrentSkinColor = color;
                    Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));

                    break;
                }
                case SkinColorationStrategyInput.Color:
                {
                    if (!RgbSkinColorContainer.Visible)
                    {
                        Skin.Visible = false;
                        RgbSkinColorContainer.Visible = true;
                    }

                    var color = strategy.ClosestSkinColor(_rgbSkinColorSelector.Color);

                    Markings.CurrentSkinColor = color;
                    Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));

                    break;
                }
            }

            ReloadProfilePreview();
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (!disposing)
                return;

            _loadoutWindow?.Dispose();
            _loadoutWindow = null;
            _skillsWindow?.Dispose(); // WL-Skills
            _skillsWindow = null; // WL-Skills
        }

        protected override void EnteredTree()
        {
            base.EnteredTree();
            ReloadPreview();
        }

        protected override void ExitedTree()
        {
            base.ExitedTree();
            _entManager.DeleteEntity(PreviewDummy);
            PreviewDummy = EntityUid.Invalid;
        }

        private void SetAge(int newAge)
        {
            Profile = Profile?.WithAge(newAge);
            ReloadPreview();
            RefreshSkills(); // WL-Skills
        }

        // WL-Height-Start
        private void SetCharHeight(int newHeight)
        {
            Profile = Profile?.WithHeight(newHeight);
            IsDirty = true;
        }
        // WL-Height-End

        private void SetSex(Sex newSex)
        {
            Profile = Profile?.WithSex(newSex);
            // for convenience, default to most common gender when new sex is selected
            switch (newSex)
            {
                case Sex.Male:
                    Profile = Profile?.WithGender(Gender.Male);
                    break;
                case Sex.Female:
                    Profile = Profile?.WithGender(Gender.Female);
                    break;
                default:
                    Profile = Profile?.WithGender(Gender.Epicene);
                    break;
            }

            UpdateGenderControls();
            UpdateTTSVoicesControls(); // Corvax-TTS
            Markings.SetSex(newSex);
            ReloadPreview();
        }

        private void SetGender(Gender newGender)
        {
            Profile = Profile?.WithGender(newGender);
            ReloadPreview();
        }

        // Corvax-TTS-Start
        private void SetVoice(string newVoice)
        {
            Profile = Profile?.WithVoice(newVoice);
            IsDirty = true;
        }
        // Corvax-TTS-End

        private void SetSpecies(string newSpecies)
        {
            Profile = Profile?.WithSpecies(newSpecies);
            OnSkinColorOnValueChanged(); // Species may have special color prefs, make sure to update it.
            Markings.SetSpecies(newSpecies); // Repopulate the markings tab as well.
            // In case there's job restrictions for the species
            RefreshJobs();
            // In case there's species restrictions for loadouts
            RefreshLoadouts();
            RefreshSkills(); // WL-Skills
            UpdateSexControls(); // update sex for new species
            UpdateSpeciesGuidebookIcon();
            ReloadPreview();
        }

        private void SetName(string newName)
        {
            Profile = Profile?.WithName(newName);
            SetDirty();

            if (!IsDirty)
                return;

            _entManager.System<MetaDataSystem>().SetEntityName(PreviewDummy, newName);
        }

        private void SetSpawnPriority(SpawnPriorityPreference newSpawnPriority)
        {
            Profile = Profile?.WithSpawnPriorityPreference(newSpawnPriority);
            SetDirty();
        }

        public bool IsDirty
        {
            get => _isDirty;
            set
            {
                if (_isDirty == value)
                    return;

                _isDirty = value;
                UpdateSaveButton();
            }
        }

        private void UpdateNameEdit()
        {
            NameEdit.Text = Profile?.Name ?? "";
        }

        private void UpdateFlavorTextEdit()
        {
            if (_flavorTextEdit != null)
            {
                _flavorTextEdit.TextRope = new Rope.Leaf(Profile?.FlavorText ?? "");
            }
        }

        // WL-OOCText-Start
        private void UpdateOocTextEdit()
        {
            if(_oocTextEdit != null)
            {
                _oocTextEdit.TextRope = new Rope.Leaf(Profile?.OocText ?? "");
            }
        }
        // WL-OOCText-End

        // WL-Records-Start
        private void UpdateRecordsEdit()
        {
            if (_medicalRecordEdit != null)
                _medicalRecordEdit.TextRope = new Rope.Leaf(Profile?.MedicalRecord ?? "");

            if (_securityRecordEdit != null)
                _securityRecordEdit.TextRope = new Rope.Leaf(Profile?.SecurityRecord ?? "");

            if (_employmentRecordEdit != null)
                _employmentRecordEdit.TextRope = new Rope.Leaf(Profile?.EmploymentRecord ?? "");

            if (_generalRecordNameEdit != null)
                _generalRecordNameEdit.Text = Profile?.FullName ?? "";

            if (_generalRecordAgeEdit != null)
                _generalRecordAgeEdit.Text = Profile?.DateOfBirth ?? "";

            if (_generalRecordCountryEdit != null)
                _generalRecordCountryEdit.Text = Profile?.Country ?? "";

            if (_confederationButton != null)
                for (var i = 0; i < _confederations.Count; i++)
                {

                    if (Profile?.Confederation.Equals(_confederations[i]) == true)
                    {
                        _confederationButton.SelectId(i);
                    }
                }
        }
        // WL-Records-End

        private void UpdateAgeEdit()
        {
            AgeEdit.Text = Profile?.Age.ToString() ?? "";
        }

        /// <summary>
        /// Updates selected job priorities to the profile's.
        /// </summary>
        private void UpdateJobPriorities()
        {
            foreach (var (jobId, _, prioritySelector) in _jobPriorities) //WL-Changes
            {
                var priority = Profile?.JobPriorities.GetValueOrDefault(jobId, JobPriority.Never) ?? JobPriority.Never;
                prioritySelector.Select((int) priority);
            }
        }

        // WL-Height-Start
        private void UpdateHeightEdit()
        {
            _heightEdit.Text = Profile?.Height.ToString() ?? "";
        }
        // WL-Height-End

        private void UpdateSexControls()
        {
            if (Profile == null)
                return;

            SexButton.Clear();

            var sexes = new List<Sex>();

            // add species sex options, default to just none if we are in bizzaro world and have no species
            if (_prototypeManager.Resolve<SpeciesPrototype>(Profile.Species, out var speciesProto))
            {
                foreach (var sex in speciesProto.Sexes)
                {
                    sexes.Add(sex);
                }
            }
            else
            {
                sexes.Add(Sex.Unsexed);
            }

            // add button for each sex
            foreach (var sex in sexes)
            {
                SexButton.AddItem(Loc.GetString($"humanoid-profile-editor-sex-{sex.ToString().ToLower()}-text"), (int) sex);
            }

            if (sexes.Contains(Profile.Sex))
                SexButton.SelectId((int) Profile.Sex);
            else
                SexButton.SelectId((int) sexes[0]);
        }

        private void UpdateSkinColor()
        {
            if (Profile == null)
                return;

            var skin = _prototypeManager.Index<SpeciesPrototype>(Profile.Species).SkinColoration;
            var strategy = _prototypeManager.Index(skin).Strategy;

            switch (strategy.InputType)
            {
                case SkinColorationStrategyInput.Unary:
                {
                    if (!Skin.Visible)
                    {
                        Skin.Visible = true;
                        RgbSkinColorContainer.Visible = false;
                    }

                    Skin.Value = strategy.ToUnary(Profile.Appearance.SkinColor);

                    break;
                }
                case SkinColorationStrategyInput.Color:
                {
                    if (!RgbSkinColorContainer.Visible)
                    {
                        Skin.Visible = false;
                        RgbSkinColorContainer.Visible = true;
                    }

                    _rgbSkinColorSelector.Color = strategy.ClosestSkinColor(Profile.Appearance.SkinColor);

                    break;
                }
            }
        }

        public void UpdateSpeciesGuidebookIcon()
        {
            SpeciesInfoButton.StyleClasses.Clear();

            var species = Profile?.Species;
            if (species is null)
                return;

            if (!_prototypeManager.Resolve<SpeciesPrototype>(species, out var speciesProto))
                return;

            // Don't display the info button if no guide entry is found
            if (!_prototypeManager.HasIndex<GuideEntryPrototype>(species))
                return;

            const string style = "SpeciesInfoDefault";
            SpeciesInfoButton.StyleIdentifier = style;
        }

        private void UpdateMarkings()
        {
            if (Profile == null)
            {
                return;
            }

            Markings.SetData(Profile.Appearance.Markings, Profile.Species,
                Profile.Sex, Profile.Appearance.SkinColor, Profile.Appearance.EyeColor
            );
        }

        private void UpdateGenderControls()
        {
            if (Profile == null)
            {
                return;
            }

            PronounsButton.SelectId((int) Profile.Gender);
        }

        private void UpdateSpawnPriorityControls()
        {
            if (Profile == null)
            {
                return;
            }

            SpawnPriorityButton.SelectId((int) Profile.SpawnPriority);
        }

        private void UpdateJobSubnameControls()
        {
            if (Profile == null)
                return;

            foreach (var jobSelector in _jobPriorities)
            {
                var jobId = jobSelector.Item1; //WL-Changes
                if (!Profile.JobSubnames.TryGetValue(jobId, out var subname))
                    continue;

                jobSelector.Item2.SelectItem(subname, true); //WL-Changes
            }
        }

        private void UpdateHairPickers()
        {
            if (Profile == null)
            {
                return;
            }
            var hairMarking = Profile.Appearance.HairStyleId == HairStyles.DefaultHairStyle
                ? new List<Marking>()
                : new() { new(Profile.Appearance.HairStyleId, new List<Color>() { Profile.Appearance.HairColor }) };

            var facialHairMarking = Profile.Appearance.FacialHairStyleId == HairStyles.DefaultFacialHairStyle
                ? new List<Marking>()
                : new() { new(Profile.Appearance.FacialHairStyleId, new List<Color>() { Profile.Appearance.FacialHairColor }) };

            HairStylePicker.UpdateData(
                hairMarking,
                Profile.Species,
                1);
            FacialHairPicker.UpdateData(
                facialHairMarking,
                Profile.Species,
                1);
        }

        // WL-Underwear-Start
        private void UpdateUnderwearPicker()
        {
            if (Profile == null)
                return;

            _underwearMarking = Profile.Appearance.Markings.FirstOrDefault(m =>
                _markingManager.Markings.TryGetValue(m.MarkingId, out var marking) &&
                marking.MarkingCategory == MarkingCategories.UndergarmentBottom);

            var markings = new List<Marking>();
            if (_underwearMarking != null)
                markings.Add(_underwearMarking);

            _underwearPicker.UpdateData(
                markings,
                Profile.Species,
                1);
        }

        private void UpdateUndershirtPicker()
        {
            if (Profile == null)
                return;

            _undershirtMarking = Profile.Appearance.Markings.FirstOrDefault(m =>
                _markingManager.Markings.TryGetValue(m.MarkingId, out var marking) &&
                marking.MarkingCategory == MarkingCategories.UndergarmentTop);

            var markings = new List<Marking>();
            if (_undershirtMarking != null)
                markings.Add(_undershirtMarking);

            _undershirtPicker.UpdateData(
                markings,
                Profile.Species,
                1);
        }

        private void UpdateSocksPicker()
        {
            if (Profile == null)
                return;

            _socksMarking = Profile.Appearance.Markings.FirstOrDefault(m =>
                _markingManager.Markings.TryGetValue(m.MarkingId, out var marking) &&
                marking.MarkingCategory == MarkingCategories.Socks);

            var markings = new List<Marking>();
            if (_socksMarking != null)
                markings.Add(_socksMarking);

            _socksPicker.UpdateData(
                markings,
                Profile.Species,
                1);
        }
        // WL-Underwear-End

        private void UpdateCMarkingsHair()
        {
            if (Profile == null)
            {
                return;
            }

            // hair color
            Color? hairColor = null;
            if ( Profile.Appearance.HairStyleId != HairStyles.DefaultHairStyle &&
                _markingManager.Markings.TryGetValue(Profile.Appearance.HairStyleId, out var hairProto)
            )
            {
                if (_markingManager.CanBeApplied(Profile.Species, Profile.Sex, hairProto, _prototypeManager))
                {
                    if (_markingManager.MustMatchSkin(Profile.Species, HumanoidVisualLayers.Hair, out var _, _prototypeManager))
                    {
                        hairColor = Profile.Appearance.SkinColor;
                    }
                    else
                    {
                        hairColor = Profile.Appearance.HairColor;
                    }
                }
            }
            if (hairColor != null)
            {
                Markings.HairMarking = new (Profile.Appearance.HairStyleId, new List<Color>() { hairColor.Value });
            }
            else
            {
                Markings.HairMarking = null;
            }
        }

        private void UpdateCMarkingsFacialHair()
        {
            if (Profile == null)
            {
                return;
            }

            // facial hair color
            Color? facialHairColor = null;
            if ( Profile.Appearance.FacialHairStyleId != HairStyles.DefaultFacialHairStyle &&
                _markingManager.Markings.TryGetValue(Profile.Appearance.FacialHairStyleId, out var facialHairProto))
            {
                if (_markingManager.CanBeApplied(Profile.Species, Profile.Sex, facialHairProto, _prototypeManager))
                {
                    if (_markingManager.MustMatchSkin(Profile.Species, HumanoidVisualLayers.Hair, out var _, _prototypeManager))
                    {
                        facialHairColor = Profile.Appearance.SkinColor;
                    }
                    else
                    {
                        facialHairColor = Profile.Appearance.FacialHairColor;
                    }
                }
            }
            if (facialHairColor != null)
            {
                Markings.FacialHairMarking = new (Profile.Appearance.FacialHairStyleId, new List<Color>() { facialHairColor.Value });
            }
            else
            {
                Markings.FacialHairMarking = null;
            }
        }

        private void UpdateEyePickers()
        {
            if (Profile == null)
            {
                return;
            }

            Markings.CurrentEyeColor = Profile.Appearance.EyeColor;
            EyeColorPicker.SetData(Profile.Appearance.EyeColor);
        }

        private void UpdateSaveButton()
        {
            SaveButton.Disabled = Profile is null || !IsDirty;
            ResetButton.Disabled = Profile is null || !IsDirty;
        }

        private void SetPreviewRotation(Direction direction)
        {
            SpriteView.OverrideDirection = (Direction) ((int) direction % 4 * 2);
        }

        private void RandomizeEverything()
        {
            Profile = HumanoidCharacterProfile.Random();
            SetProfile(Profile, CharacterSlot);
            SetDirty();
        }

        private void RandomizeName()
        {
            if (Profile == null) return;
            var name = HumanoidCharacterProfile.GetName(Profile.Species, Profile.Gender);
            SetName(name);
            UpdateNameEdit();
        }

        private async void ExportImage()
        {
            if (_imaging)
                return;

            var dir = SpriteView.OverrideDirection ?? Direction.South;

            // I tried disabling the button but it looks sorta goofy as it only takes a frame or two to save
            _imaging = true;
            await _entManager.System<ContentSpriteSystem>().Export(PreviewDummy, dir, includeId: false);
            _imaging = false;
        }

        private async void ImportProfile()
        {
            if (_exporting || CharacterSlot == null || Profile == null)
                return;

            StartExport();
            await using var file = await _dialogManager.OpenFile(new FileDialogFilters(new FileDialogFilters.Group("yml")), FileAccess.Read);

            if (file == null)
            {
                EndExport();
                return;
            }

            try
            {
                var profile = _entManager.System<HumanoidAppearanceSystem>().FromStream(file, _playerManager.LocalSession!);
                var oldProfile = Profile;
                SetProfile(profile, CharacterSlot);

                IsDirty = !profile.MemberwiseEquals(oldProfile);
            }
            catch (Exception exc)
            {
                _sawmill.Error($"Error when importing profile\n{exc.StackTrace}");
            }
            finally
            {
                EndExport();
            }
        }

        private async void ExportProfile()
        {
            if (Profile == null || _exporting)
                return;

            StartExport();
            var file = await _dialogManager.SaveFile(new FileDialogFilters(new FileDialogFilters.Group("yml")));

            if (file == null)
            {
                EndExport();
                return;
            }

            try
            {
                var dataNode = _entManager.System<HumanoidAppearanceSystem>().ToDataNode(Profile);
                await using var writer = new StreamWriter(file.Value.fileStream);
                dataNode.Write(writer);
            }
            catch (Exception exc)
            {
                _sawmill.Error($"Error when exporting profile\n{exc.StackTrace}");
            }
            finally
            {
                EndExport();
                await file.Value.fileStream.DisposeAsync();
            }
        }

        private void StartExport()
        {
            _exporting = true;
            ImportButton.Disabled = true;
            ExportButton.Disabled = true;
        }

        private void EndExport()
        {
            _exporting = false;
            ImportButton.Disabled = false;
            ExportButton.Disabled = false;
        }
    }
}