ss14-wega/Content.Shared/Preferences/HumanoidCharacterProfile.cs

using System.Linq;
using System.Text.RegularExpressions;
using Content.Shared.CCVar;
using Content.Shared.Speech.Synthesis; // Corvax-Wega-Barks
using Content.Shared.Corvax.TTS;
using Content.Shared.GameTicking;
using Content.Shared.Humanoid;
using Content.Shared.Humanoid.Prototypes;
using Content.Shared.Preferences.Loadouts;
using Content.Shared.Roles;
using Content.Shared.Traits;
using Robust.Shared.Collections;
using Robust.Shared.Configuration;
using Robust.Shared.Enums;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;

namespace Content.Shared.Preferences
{
    /// <summary>
    /// Character profile. Looks immutable, but uses non-immutable semantics internally for serialization/code sanity purposes.
    /// </summary>
    [DataDefinition]
    [Serializable, NetSerializable]
    public sealed partial class HumanoidCharacterProfile : ICharacterProfile
    {
        private static readonly Regex RestrictedNameRegex = new("[^А-Яа-яёЁ0-9' -]"); // Corvax-Localization
        private static readonly Regex ICNameCaseRegex = new(@"^(?<word>\w)|\b(?<word>\w)(?=\w*$)");

        /// <summary>
        /// Job preferences for initial spawn.
        /// </summary>
        [DataField]
        private Dictionary<ProtoId<JobPrototype>, JobPriority> _jobPriorities = new()
        {
            {
                SharedGameTicker.FallbackOverflowJob, JobPriority.High
            }
        };

        /// <summary>
        /// Antags we have opted in to.
        /// </summary>
        [DataField]
        private HashSet<ProtoId<AntagPrototype>> _antagPreferences = new();

        /// <summary>
        /// Enabled traits.
        /// </summary>
        [DataField]
        private HashSet<ProtoId<TraitPrototype>> _traitPreferences = new();

        /// <summary>
        /// <see cref="_loadouts"/>
        /// </summary>
        public IReadOnlyDictionary<string, RoleLoadout> Loadouts => _loadouts;

        [DataField]
        private Dictionary<string, RoleLoadout> _loadouts = new();

        [DataField]
        public string Name { get; set; } = "John Doe";

        /// <summary>
        /// Detailed text that can appear for the character if <see cref="CCVars.FlavorText"/> is enabled.
        /// </summary>
        [DataField]
        public string FlavorText { get; set; } = string.Empty;

        // Corvax-Wega-Graphomancy-Extended-start
        [DataField]
        public string OOCFlavorText { get; set; } = string.Empty;

        [DataField]
        public string CharacterFlavorText { get; set; } = string.Empty;

        [DataField]
        public string GreenFlavorText { get; set; } = string.Empty;

        [DataField]
        public string YellowFlavorText { get; set; } = string.Empty;

        [DataField]
        public string RedFlavorText { get; set; } = string.Empty;

        [DataField]
        public string TagsFlavorText { get; set; } = string.Empty;

        [DataField]
        public string LinksFlavorText { get; set; } = string.Empty;

        [DataField]
        public string NSFWFlavorText { get; set; } = string.Empty;
        // Corvax-Wega-Graphomancy-Extended-end

        /// <summary>
        /// Associated <see cref="SpeciesPrototype"/> for this profile.
        /// </summary>
        [DataField]
        public ProtoId<SpeciesPrototype> Species { get; set; } = SharedHumanoidAppearanceSystem.DefaultSpecies;

        [DataField]
        public string Voice { get; set; } = SharedHumanoidAppearanceSystem.DefaultVoice;

        [DataField] // Corvax-Wega-Barks
        public string BarkVoice { get; set; } = SharedHumanoidAppearanceSystem.DefaultBarkVoice; // Corvax-Wega-Barks

        [DataField]
        public int Age { get; set; } = 18;

        [DataField]
        public Sex Sex { get; private set; } = Sex.Male;

        [DataField]
        public Gender Gender { get; private set; } = Gender.Male;

        // Corvax-Wega-start
        [DataField]
        public Status Status { get; private set; } = Status.No;

        [DataField]
        public float Height { get; set; } = 175.0f;
        // Corvax-Wega-end

        /// <summary>
        /// <see cref="Appearance"/>
        /// </summary>
        public ICharacterAppearance CharacterAppearance => Appearance;

        /// <summary>
        /// Stores markings, eye colors, etc for the profile.
        /// </summary>
        [DataField]
        public HumanoidCharacterAppearance Appearance { get; set; } = new();

        /// <summary>
        /// When spawning into a round what's the preferred spot to spawn.
        /// </summary>
        [DataField]
        public SpawnPriorityPreference SpawnPriority { get; private set; } = SpawnPriorityPreference.None;

        /// <summary>
        /// <see cref="_jobPriorities"/>
        /// </summary>
        public IReadOnlyDictionary<ProtoId<JobPrototype>, JobPriority> JobPriorities => _jobPriorities;

        /// <summary>
        /// <see cref="_antagPreferences"/>
        /// </summary>
        public IReadOnlySet<ProtoId<AntagPrototype>> AntagPreferences => _antagPreferences;

        /// <summary>
        /// <see cref="_traitPreferences"/>
        /// </summary>
        public IReadOnlySet<ProtoId<TraitPrototype>> TraitPreferences => _traitPreferences;

        /// <summary>
        /// If we're unable to get one of our preferred jobs do we spawn as a fallback job or do we stay in lobby.
        /// </summary>
        [DataField]
        public PreferenceUnavailableMode PreferenceUnavailable { get; private set; } =
            PreferenceUnavailableMode.SpawnAsOverflow;

        public HumanoidCharacterProfile(
            string name,
            string flavortext,
            // Corvax-Wega-Graphomancy-Extended-start
            string oocflavortext,
            string characterflavortext,
            string greenflavortext,
            string yellowflavortext,
            string redflavortext,
            string tagsflavortext,
            string linksflavortext,
            string nsfwflavortext,
            // Corvax-Wega-Graphomancy-Extended-end
            string species,
            string barkvoice, // Corvax-Wega-Barks
            string voice, // Corvax-TTS
            int age,
            Sex sex,
            Gender gender,
            Status status, // Corvax-Wega
            float height, // Corvax-Wega-Height
            HumanoidCharacterAppearance appearance,
            SpawnPriorityPreference spawnPriority,
            Dictionary<ProtoId<JobPrototype>, JobPriority> jobPriorities,
            PreferenceUnavailableMode preferenceUnavailable,
            HashSet<ProtoId<AntagPrototype>> antagPreferences,
            HashSet<ProtoId<TraitPrototype>> traitPreferences,
            Dictionary<string, RoleLoadout> loadouts)
        {
            Name = name;
            FlavorText = flavortext;
            // Corvax-Wega-Graphomancy-Extended-start
            OOCFlavorText = oocflavortext;
            CharacterFlavorText = characterflavortext;
            GreenFlavorText = greenflavortext;
            YellowFlavorText = yellowflavortext;
            RedFlavorText = redflavortext;
            TagsFlavorText = tagsflavortext;
            LinksFlavorText = linksflavortext;
            NSFWFlavorText = nsfwflavortext;
            // Corvax-Wega-Graphomancy-Extended-end
            Species = species;
            BarkVoice = barkvoice; // Corvax-Wega-Barks
            Voice = voice; // Corvax-TTS
            Age = age;
            Sex = sex;
            Gender = gender;
            Status = status; // Corvax-Wega
            Height = height; // Corvax-Wega-Height
            Appearance = appearance;
            SpawnPriority = spawnPriority;
            _jobPriorities = jobPriorities;
            PreferenceUnavailable = preferenceUnavailable;
            _antagPreferences = antagPreferences;
            _traitPreferences = traitPreferences;
            _loadouts = loadouts;

            var hasHighPrority = false;
            foreach (var (key, value) in _jobPriorities)
            {
                if (value == JobPriority.Never)
                    _jobPriorities.Remove(key);
                else if (value != JobPriority.High)
                    continue;

                if (hasHighPrority)
                    _jobPriorities[key] = JobPriority.Medium;

                hasHighPrority = true;
            }
        }

        /// <summary>Copy constructor</summary>
        public HumanoidCharacterProfile(HumanoidCharacterProfile other)
            : this(other.Name,
                other.FlavorText,
                // Corvax-Wega-Graphomancy-Extended-start
                other.OOCFlavorText,
                other.CharacterFlavorText,
                other.GreenFlavorText,
                other.YellowFlavorText,
                other.RedFlavorText,
                other.TagsFlavorText,
                other.LinksFlavorText,
                other.NSFWFlavorText,
                // Corvax-Wega-Graphomancy-Extended-end
                other.Species,
                other.BarkVoice, // Corvax-Wega-Barks
                other.Voice,
                other.Age,
                other.Sex,
                other.Gender,
                other.Status, // Corvax-Wega
                other.Height, // Corvax-Wega-Height
                other.Appearance.Clone(),
                other.SpawnPriority,
                new Dictionary<ProtoId<JobPrototype>, JobPriority>(other.JobPriorities),
                other.PreferenceUnavailable,
                new HashSet<ProtoId<AntagPrototype>>(other.AntagPreferences),
                new HashSet<ProtoId<TraitPrototype>>(other.TraitPreferences),
                new Dictionary<string, RoleLoadout>(other.Loadouts))
        {
        }

        /// <summary>
        ///     Get the default humanoid character profile, using internal constant values.
        ///     Defaults to <see cref="SharedHumanoidAppearanceSystem.DefaultSpecies"/> for the species.
        /// </summary>
        /// <returns></returns>
        public HumanoidCharacterProfile()
        {
        }

        /// <summary>
        ///     Return a default character profile, based on species.
        /// </summary>
        /// <param name="species">The species to use in this default profile. The default species is <see cref="SharedHumanoidAppearanceSystem.DefaultSpecies"/>.</param>
        /// <returns>Humanoid character profile with default settings.</returns>
        public static HumanoidCharacterProfile DefaultWithSpecies(string? species = null)
        {
            species ??= SharedHumanoidAppearanceSystem.DefaultSpecies;

            return new()
            {
                Species = species,
                Appearance = HumanoidCharacterAppearance.DefaultWithSpecies(species),
            };
        }

        // TODO: This should eventually not be a visual change only.
        public static HumanoidCharacterProfile Random(HashSet<string>? ignoredSpecies = null)
        {
            var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
            var random = IoCManager.Resolve<IRobustRandom>();

            var species = random.Pick(prototypeManager
                .EnumeratePrototypes<SpeciesPrototype>()
                .Where(x => ignoredSpecies == null ? x.RoundStart : x.RoundStart && !ignoredSpecies.Contains(x.ID))
                .ToArray()
            ).ID;

            return RandomWithSpecies(species);
        }

        public static HumanoidCharacterProfile RandomWithSpecies(string? species = null)
        {
            species ??= SharedHumanoidAppearanceSystem.DefaultSpecies;

            var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
            var random = IoCManager.Resolve<IRobustRandom>();

            var sex = Sex.Unsexed;
            var age = 18;
            var height = 175.0f; // Corvax-Wega-Height
            if (prototypeManager.TryIndex<SpeciesPrototype>(species, out var speciesPrototype))
            {
                sex = random.Pick(speciesPrototype.Sexes);
                age = random.Next(speciesPrototype.MinAge, speciesPrototype.OldAge); // people don't look and keep making 119 year old characters with zero rp, cap it at middle aged
                height = random.NextFloat(speciesPrototype.MinHeight, speciesPrototype.MaxHeight); // Corvax-Wega-Height
            }

            // Corvax-Wega-Barks-start
            var barkvoiceId = random.Pick(prototypeManager
                .EnumeratePrototypes<BarkPrototype>()
                .ToArray()
            ).ID;
            // Corvax-Wega-Barks-end

            // Corvax-TTS-Start
            var voiceId = random.Pick(prototypeManager
                .EnumeratePrototypes<TTSVoicePrototype>()
                .Where(o => CanHaveVoice(o, sex)).ToArray()
            ).ID;
            // Corvax-TTS-End

            var gender = Gender.Epicene;

            var status = Status.No; // Corvax-Wega

            switch (sex)
            {
                case Sex.Male:
                    gender = Gender.Male;
                    break;
                case Sex.Female:
                    gender = Gender.Female;
                    break;
            }

            var name = GetName(species, gender);

            return new HumanoidCharacterProfile()
            {
                Name = name,
                Sex = sex,
                Age = age,
                Gender = gender,
                Species = species,
                BarkVoice = barkvoiceId, // Corvax-Wega-Barks
                Voice = voiceId, // Corvax-TTS
                Status = status, // Corvax-Wega
                Height = height, // Corvax-Wega-Height
                Appearance = HumanoidCharacterAppearance.Random(species, sex),
            };
        }

        public HumanoidCharacterProfile WithName(string name)
        {
            return new(this) { Name = name };
        }

        public HumanoidCharacterProfile WithFlavorText(string flavorText)
        {
            return new(this) { FlavorText = flavorText };
        }

        // Corvax-Wega-Graphomancy-Extended-start
        public HumanoidCharacterProfile WithOOCFlavorText(string oocFlavorText)
        {
            return new(this) { OOCFlavorText = oocFlavorText };
        }

        public HumanoidCharacterProfile WithCharacterText(string characterFlavorText)
        {
            return new(this) { CharacterFlavorText = characterFlavorText };
        }

        public HumanoidCharacterProfile WithGreenPreferencesText(string greenFlavorText)
        {
            return new(this) { GreenFlavorText = greenFlavorText };
        }

        public HumanoidCharacterProfile WithYellowPreferencesText(string yellowFlavorText)
        {
            return new(this) { YellowFlavorText = yellowFlavorText };
        }

        public HumanoidCharacterProfile WithRedPreferencesText(string redFlavorText)
        {
            return new(this) { RedFlavorText = redFlavorText };
        }

        public HumanoidCharacterProfile WithTagsText(string tagsFlavorText)
        {
            return new(this) { TagsFlavorText = tagsFlavorText };
        }

        public HumanoidCharacterProfile WithLinksText(string linksFlavorText)
        {
            return new(this) { LinksFlavorText = linksFlavorText };
        }

        public HumanoidCharacterProfile WithNSFWPreferencesText(string nsfwFlavorText)
        {
            return new(this) { NSFWFlavorText = nsfwFlavorText };
        }
        // Corvax-Wega-Graphomancy-Extended-end

        public HumanoidCharacterProfile WithAge(int age)
        {
            return new(this) { Age = age };
        }

        public HumanoidCharacterProfile WithSex(Sex sex)
        {
            return new(this) { Sex = sex };
        }

        public HumanoidCharacterProfile WithGender(Gender gender)
        {
            return new(this) { Gender = gender };
        }

        public HumanoidCharacterProfile WithSpecies(string species)
        {
            return new(this) { Species = species };
        }

        // Corvax-Wega-start
        public HumanoidCharacterProfile WithStatus(Status status)
        {
            return new(this) { Status = status };
        }

        public HumanoidCharacterProfile WithBarkVoice(string barkvoice)
        {
            return new(this) { BarkVoice = barkvoice };
        }

        public HumanoidCharacterProfile WithHeight(float height)
        {
            return new(this) { Height = height };
        }
        // Corvax-Wega-end

        // Corvax-TTS-Start
        public HumanoidCharacterProfile WithVoice(string voice)
        {
            return new(this) { Voice = voice };
        }
        // Corvax-TTS-End

        public HumanoidCharacterProfile WithCharacterAppearance(HumanoidCharacterAppearance appearance)
        {
            return new(this) { Appearance = appearance };
        }

        public HumanoidCharacterProfile WithSpawnPriorityPreference(SpawnPriorityPreference spawnPriority)
        {
            return new(this) { SpawnPriority = spawnPriority };
        }

        public HumanoidCharacterProfile WithJobPriorities(IEnumerable<KeyValuePair<ProtoId<JobPrototype>, JobPriority>> jobPriorities)
        {
            var dictionary = new Dictionary<ProtoId<JobPrototype>, JobPriority>(jobPriorities);
            var hasHighPrority = false;

            foreach (var (key, value) in dictionary)
            {
                if (value == JobPriority.Never)
                    dictionary.Remove(key);
                else if (value != JobPriority.High)
                    continue;

                if (hasHighPrority)
                    dictionary[key] = JobPriority.Medium;

                hasHighPrority = true;
            }

            return new(this)
            {
                _jobPriorities = dictionary
            };
        }

        public HumanoidCharacterProfile WithJobPriority(ProtoId<JobPrototype> jobId, JobPriority priority)
        {
            var dictionary = new Dictionary<ProtoId<JobPrototype>, JobPriority>(_jobPriorities);
            if (priority == JobPriority.Never)
            {
                dictionary.Remove(jobId);
            }
            else if (priority == JobPriority.High)
            {
                // There can only ever be one high priority job.
                foreach (var (job, value) in dictionary)
                {
                    if (value == JobPriority.High)
                        dictionary[job] = JobPriority.Medium;
                }

                dictionary[jobId] = priority;
            }
            else
            {
                dictionary[jobId] = priority;
            }

            return new(this)
            {
                _jobPriorities = dictionary,
            };
        }

        public HumanoidCharacterProfile WithPreferenceUnavailable(PreferenceUnavailableMode mode)
        {
            return new(this) { PreferenceUnavailable = mode };
        }

        public HumanoidCharacterProfile WithAntagPreferences(IEnumerable<ProtoId<AntagPrototype>> antagPreferences)
        {
            return new(this)
            {
                _antagPreferences = new (antagPreferences),
            };
        }

        public HumanoidCharacterProfile WithAntagPreference(ProtoId<AntagPrototype> antagId, bool pref)
        {
            var list = new HashSet<ProtoId<AntagPrototype>>(_antagPreferences);
            if (pref)
            {
                list.Add(antagId);
            }
            else
            {
                list.Remove(antagId);
            }

            return new(this)
            {
                _antagPreferences = list,
            };
        }

        public HumanoidCharacterProfile WithTraitPreference(ProtoId<TraitPrototype> traitId, IPrototypeManager protoManager)
        {
            // null category is assumed to be default.
            if (!protoManager.TryIndex(traitId, out var traitProto))
                return new(this);

            var category = traitProto.Category;

            // Category not found so dump it.
            TraitCategoryPrototype? traitCategory = null;

            if (category != null && !protoManager.Resolve(category, out traitCategory))
                return new(this);

            var list = new HashSet<ProtoId<TraitPrototype>>(_traitPreferences) { traitId };

            if (traitCategory == null || traitCategory.MaxTraitPoints < 0)
            {
                return new(this)
                {
                    _traitPreferences = list,
                };
            }

            var count = 0;
            foreach (var trait in list)
            {
                // If trait not found or another category don't count its points.
                if (!protoManager.TryIndex<TraitPrototype>(trait, out var otherProto) ||
                    otherProto.Category != traitCategory)
                {
                    continue;
                }

                count += otherProto.Cost;
            }

            if (count > traitCategory.MaxTraitPoints && traitProto.Cost != 0)
            {
                return new(this);
            }

            return new(this)
            {
                _traitPreferences = list,
            };
        }

        public HumanoidCharacterProfile WithoutTraitPreference(ProtoId<TraitPrototype> traitId, IPrototypeManager protoManager)
        {
            var list = new HashSet<ProtoId<TraitPrototype>>(_traitPreferences);
            list.Remove(traitId);

            return new(this)
            {
                _traitPreferences = list,
            };
        }

        public string Summary =>
            Loc.GetString(
                "humanoid-character-profile-summary",
                ("name", Name),
                ("gender", Gender.ToString().ToLowerInvariant()),
                ("age", Age)
            );

        public bool MemberwiseEquals(ICharacterProfile maybeOther)
        {
            if (maybeOther is not HumanoidCharacterProfile other) return false;
            if (Name != other.Name) return false;
            if (Age != other.Age) return false;
            if (Sex != other.Sex) return false;
            if (Gender != other.Gender) return false;
            if (Status != other.Status) return false; // Corvax-Wega
            if (Height != other.Height) return false; // Corvax-Wega-Height
            if (Species != other.Species) return false;
            if (PreferenceUnavailable != other.PreferenceUnavailable) return false;
            if (SpawnPriority != other.SpawnPriority) return false;
            if (!_jobPriorities.SequenceEqual(other._jobPriorities)) return false;
            if (!_antagPreferences.SequenceEqual(other._antagPreferences)) return false;
            if (!_traitPreferences.SequenceEqual(other._traitPreferences)) return false;
            if (!Loadouts.SequenceEqual(other.Loadouts)) return false;
            if (FlavorText != other.FlavorText) return false;
            // Corvax-Wega-Graphomancy-Extended-start
            if (OOCFlavorText != other.OOCFlavorText) return false;
            if (CharacterFlavorText != other.CharacterFlavorText) return false;
            if (GreenFlavorText != other.GreenFlavorText) return false;
            if (YellowFlavorText != other.YellowFlavorText) return false;
            if (RedFlavorText != other.RedFlavorText) return false;
            if (TagsFlavorText != other.TagsFlavorText) return false;
            if (LinksFlavorText != other.LinksFlavorText) return false;
            if (NSFWFlavorText != other.NSFWFlavorText) return false;
            // Corvax-Wega-Graphomancy-Extended-end
            return Appearance.MemberwiseEquals(other.Appearance);
        }

        public void EnsureValid(ICommonSession session, IDependencyCollection collection, string[] sponsorPrototypes)
        {
            var configManager = collection.Resolve<IConfigurationManager>();
            var prototypeManager = collection.Resolve<IPrototypeManager>();

            if (!prototypeManager.TryIndex(Species, out var speciesPrototype) || speciesPrototype.RoundStart == false)
            {
                Species = SharedHumanoidAppearanceSystem.DefaultSpecies;
                speciesPrototype = prototypeManager.Index(Species);
            }

            // Corvax-Sponsors-Start: Reset to human if player not sponsor
            if (speciesPrototype.SponsorOnly && !sponsorPrototypes.Contains(Species.Id))
            {
                Species = SharedHumanoidAppearanceSystem.DefaultSpecies;
                speciesPrototype = prototypeManager.Index(Species);
            }
            // Corvax-Sponsors-End

            var sex = Sex switch
            {
                Sex.Male => Sex.Male,
                Sex.Female => Sex.Female,
                Sex.Unsexed => Sex.Unsexed,
                _ => Sex.Male // Invalid enum values.
            };

            // ensure the species can be that sex and their age fits the founds
            if (!speciesPrototype.Sexes.Contains(sex))
                sex = speciesPrototype.Sexes[0];

            var age = Math.Clamp(Age, speciesPrototype.MinAge, speciesPrototype.MaxAge);
            var height = Math.Clamp(Height, speciesPrototype.MinHeight, speciesPrototype.MaxHeight); // Corvax-Wega-Height

            var gender = Gender switch
            {
                Gender.Epicene => Gender.Epicene,
                Gender.Female => Gender.Female,
                Gender.Male => Gender.Male,
                Gender.Neuter => Gender.Neuter,
                _ => Gender.Epicene // Invalid enum values.
            };

            // Corvax-Wega-start
            var status = Status switch
            {
                Status.No => Status.No,
                Status.Semi => Status.Semi,
                Status.Full => Status.Full,
                Status.Absolute => Status.Absolute,
                _ => Status.No
            };
            // Corvax-Wega-end

            string name;
            var maxNameLength = configManager.GetCVar(CCVars.MaxNameLength);
            if (string.IsNullOrEmpty(Name))
            {
                name = GetName(Species, gender);
            }
            else if (Name.Length > maxNameLength)
            {
                name = Name[..maxNameLength];
            }
            else
            {
                name = Name;
            }

            name = name.Trim();

            if (configManager.GetCVar(CCVars.RestrictedNames))
            {
                name = RestrictedNameRegex.Replace(name, string.Empty);
            }

            if (configManager.GetCVar(CCVars.ICNameCase))
            {
                // This regex replaces the first character of the first and last words of the name with their uppercase version
                name = ICNameCaseRegex.Replace(name, m => m.Groups["word"].Value.ToUpper());
            }

            if (string.IsNullOrEmpty(name))
            {
                name = GetName(Species, gender);
            }

            string flavortext;
            var maxFlavorTextLength = configManager.GetCVar(CCVars.MaxFlavorTextLength);
            if (FlavorText.Length > maxFlavorTextLength)
            {
                flavortext = FormattedMessage.RemoveMarkupOrThrow(FlavorText)[..maxFlavorTextLength];
            }
            else
            {
                flavortext = FormattedMessage.RemoveMarkupOrThrow(FlavorText);
            }

            // Corvax-Wega-Graphomancy-Extended-star
            string oocflavortext;
            var oocMaxFlavorTextLength = configManager.GetCVar(WegaCVars.OOCMaxFlavorTextLength);
            if (OOCFlavorText.Length > oocMaxFlavorTextLength)
            {
                oocflavortext = FormattedMessage.RemoveMarkupOrThrow(OOCFlavorText)[..oocMaxFlavorTextLength];
            }
            else
            {
                oocflavortext = FormattedMessage.RemoveMarkupOrThrow(OOCFlavorText);
            }

            string characterDescription;
            var maxCharacterDescriptionLength = configManager.GetCVar(WegaCVars.CharacterDescriptionLength);
            if (CharacterFlavorText.Length > maxCharacterDescriptionLength)
            {
                characterDescription = FormattedMessage.RemoveMarkupOrThrow(CharacterFlavorText)[..maxCharacterDescriptionLength];
            }
            else
            {
                characterDescription = FormattedMessage.RemoveMarkupOrThrow(CharacterFlavorText);
            }

            string greenPreferences;
            var maxGreenPreferencesLength = configManager.GetCVar(WegaCVars.GreenPreferencesLength);
            if (GreenFlavorText.Length > maxGreenPreferencesLength)
            {
                greenPreferences = FormattedMessage.RemoveMarkupOrThrow(GreenFlavorText)[..maxGreenPreferencesLength];
            }
            else
            {
                greenPreferences = FormattedMessage.RemoveMarkupOrThrow(GreenFlavorText);
            }

            string yellowPreferences;
            var maxYellowPreferencesLength = configManager.GetCVar(WegaCVars.YellowPreferencesLength);
            if (YellowFlavorText.Length > maxYellowPreferencesLength)
            {
                yellowPreferences = FormattedMessage.RemoveMarkupOrThrow(YellowFlavorText)[..maxYellowPreferencesLength];
            }
            else
            {
                yellowPreferences = FormattedMessage.RemoveMarkupOrThrow(YellowFlavorText);
            }

            string redPreferences;
            var maxRedPreferencesLength = configManager.GetCVar(WegaCVars.RedPreferencesLength);
            if (RedFlavorText.Length > maxRedPreferencesLength)
            {
                redPreferences = FormattedMessage.RemoveMarkupOrThrow(RedFlavorText)[..maxRedPreferencesLength];
            }
            else
            {
                redPreferences = FormattedMessage.RemoveMarkupOrThrow(RedFlavorText);
            }

            string tags;
            var maxTagsLength = configManager.GetCVar(WegaCVars.TagsLength);
            if (TagsFlavorText.Length > maxTagsLength)
            {
                tags = FormattedMessage.RemoveMarkupOrThrow(TagsFlavorText)[..maxTagsLength];
            }
            else
            {
                tags = FormattedMessage.RemoveMarkupOrThrow(TagsFlavorText);
            }

            tags = FormatTags(tags);

            string links;
            var maxLinksLength = configManager.GetCVar(WegaCVars.LinksLength);
            if (LinksFlavorText.Length > maxLinksLength)
            {
                links = FormattedMessage.RemoveMarkupOrThrow(LinksFlavorText)[..maxLinksLength];
            }
            else
            {
                links = FormattedMessage.RemoveMarkupOrThrow(LinksFlavorText);
            }

            string nsfwPreferences;
            var maxNSFWPreferencesLength = configManager.GetCVar(WegaCVars.NSFWPreferencesLength);
            if (NSFWFlavorText.Length > maxNSFWPreferencesLength)
            {
                nsfwPreferences = FormattedMessage.RemoveMarkupOrThrow(NSFWFlavorText)[..maxNSFWPreferencesLength];
            }
            else
            {
                nsfwPreferences = FormattedMessage.RemoveMarkupOrThrow(NSFWFlavorText);
            }
            // Corvax-Wega-Graphomancy-Extended-end

            var appearance = HumanoidCharacterAppearance.EnsureValid(Appearance, Species, Sex, sponsorPrototypes);

            var prefsUnavailableMode = PreferenceUnavailable switch
            {
                PreferenceUnavailableMode.StayInLobby => PreferenceUnavailableMode.StayInLobby,
                PreferenceUnavailableMode.SpawnAsOverflow => PreferenceUnavailableMode.SpawnAsOverflow,
                _ => PreferenceUnavailableMode.StayInLobby // Invalid enum values.
            };

            var spawnPriority = SpawnPriority switch
            {
                SpawnPriorityPreference.None => SpawnPriorityPreference.None,
                SpawnPriorityPreference.Arrivals => SpawnPriorityPreference.Arrivals,
                SpawnPriorityPreference.Cryosleep => SpawnPriorityPreference.Cryosleep,
                _ => SpawnPriorityPreference.None // Invalid enum values.
            };

            var priorities = new Dictionary<ProtoId<JobPrototype>, JobPriority>(JobPriorities
                .Where(p => prototypeManager.TryIndex<JobPrototype>(p.Key, out var job) && job.SetPreference && p.Value switch
                {
                    JobPriority.Never => false, // Drop never since that's assumed default.
                    JobPriority.Low => true,
                    JobPriority.Medium => true,
                    JobPriority.High => true,
                    _ => false
                }));

            var hasHighPrio = false;
            foreach (var (key, value) in priorities)
            {
                if (value != JobPriority.High)
                    continue;

                if (hasHighPrio)
                    priorities[key] = JobPriority.Medium;
                hasHighPrio = true;
            }

            var antags = AntagPreferences
                .Where(id => prototypeManager.TryIndex(id, out var antag) && antag.SetPreference)
                .ToList();

            var traits = TraitPreferences
                         .Where(prototypeManager.HasIndex)
                         .ToList();

            Name = name;
            FlavorText = flavortext;
            // Corvax-Wega-Graphomancy-Extended-start
            OOCFlavorText = oocflavortext;
            CharacterFlavorText = characterDescription;
            GreenFlavorText = greenPreferences;
            YellowFlavorText = yellowPreferences;
            RedFlavorText = redPreferences;
            TagsFlavorText = tags;
            LinksFlavorText = links;
            NSFWFlavorText = nsfwPreferences;
            // Corvax-Wega-Graphomancy-Extended-end
            Age = age;
            Sex = sex;
            Gender = gender;
            Status = status; // Corvax-Wega
            Height = height; // Corvax-Wega-Height
            Appearance = appearance;
            SpawnPriority = spawnPriority;

            _jobPriorities.Clear();

            foreach (var (job, priority) in priorities)
            {
                _jobPriorities.Add(job, priority);
            }

            PreferenceUnavailable = prefsUnavailableMode;

            _antagPreferences.Clear();
            _antagPreferences.UnionWith(antags);

            _traitPreferences.Clear();
            _traitPreferences.UnionWith(GetValidTraits(traits, prototypeManager));

            // Corvax-Wega-Barks-start
            prototypeManager.TryIndex<BarkPrototype>(BarkVoice, out var barkvoice);
            if (barkvoice is null)
                BarkVoice = SharedHumanoidAppearanceSystem.DefaultBarkVoice;
            // Corvax-Wega-Barks-end

            // Corvax-TTS-Start
            prototypeManager.TryIndex<TTSVoicePrototype>(Voice, out var voice);
            if (voice is null || !CanHaveVoice(voice, Sex))
                Voice = SharedHumanoidAppearanceSystem.DefaultSexVoice[sex];
            // Corvax-TTS-End

            // Checks prototypes exist for all loadouts and dump / set to default if not.
            var toRemove = new ValueList<string>();

            foreach (var (roleName, loadouts) in _loadouts)
            {
                if (!prototypeManager.HasIndex<RoleLoadoutPrototype>(roleName))
                {
                    toRemove.Add(roleName);
                    continue;
                }

                // This happens after we verify the prototype exists
                // These values are set equal in the database and we need to make sure they're equal here too!
                loadouts.Role = roleName;
                loadouts.EnsureValid(this, session, collection);
            }

            foreach (var value in toRemove)
            {
                _loadouts.Remove(value);
            }
        }

        /// <summary>
        /// Takes in an IEnumerable of traits and returns a List of the valid traits.
        /// </summary>
        public List<ProtoId<TraitPrototype>> GetValidTraits(IEnumerable<ProtoId<TraitPrototype>> traits, IPrototypeManager protoManager)
        {
            // Track points count for each group.
            var groups = new Dictionary<string, int>();
            var result = new List<ProtoId<TraitPrototype>>();

            foreach (var trait in traits)
            {
                if (!protoManager.TryIndex(trait, out var traitProto))
                    continue;

                // Always valid.
                if (traitProto.Category == null)
                {
                    result.Add(trait);
                    continue;
                }

                // No category so dump it.
                if (!protoManager.Resolve(traitProto.Category, out var category))
                    continue;

                var existing = groups.GetOrNew(category.ID);
                existing += traitProto.Cost;

                // Too expensive.
                if (existing > category.MaxTraitPoints)
                    continue;

                groups[category.ID] = existing;
                result.Add(trait);
            }

            return result;
        }

        // Corvax-TTS-Start
        // SHOULD BE NOT PUBLIC, BUT....
        public static bool CanHaveVoice(TTSVoicePrototype voice, Sex sex)
        {
            return voice.RoundStart && sex == Sex.Unsexed || (voice.Sex == sex || voice.Sex == Sex.Unsexed);
        }
        // Corvax-TTS-End

        public ICharacterProfile Validated(ICommonSession session, IDependencyCollection collection, string[] sponsorPrototypes)
        {
            var profile = new HumanoidCharacterProfile(this);
            profile.EnsureValid(session, collection, sponsorPrototypes);
            return profile;
        }

        // sorry this is kind of weird and duplicated,
        /// working inside these non entity systems is a bit wack
        public static string GetName(string species, Gender gender)
        {
            var namingSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<NamingSystem>();
            return namingSystem.GetName(species, gender);
        }
        public bool Equals(HumanoidCharacterProfile? other)
        {
            if (other is null)
                return false;

            return ReferenceEquals(this, other) || MemberwiseEquals(other);
        }

        public override bool Equals(object? obj)
        {
            return obj is HumanoidCharacterProfile other && Equals(other);
        }

        public override int GetHashCode()
        {
            var hashCode = new HashCode();
            hashCode.Add(_jobPriorities);
            hashCode.Add(_antagPreferences);
            hashCode.Add(_traitPreferences);
            hashCode.Add(_loadouts);
            hashCode.Add(Name);
            hashCode.Add(FlavorText);
            // Corvax-Wega-Graphomancy-Extended-start
            hashCode.Add(OOCFlavorText);
            hashCode.Add(CharacterFlavorText);
            hashCode.Add(GreenFlavorText);
            hashCode.Add(YellowFlavorText);
            hashCode.Add(RedFlavorText);
            hashCode.Add(TagsFlavorText);
            hashCode.Add(LinksFlavorText);
            hashCode.Add(NSFWFlavorText);
            // Corvax-Wega-Graphomancy-Extended-end
            hashCode.Add(Species);
            hashCode.Add(Age);
            hashCode.Add(Height); // Corvax-Wega-Height
            hashCode.Add((int)Sex);
            hashCode.Add((int)Gender);
            hashCode.Add(Appearance);
            hashCode.Add((int)SpawnPriority);
            hashCode.Add((int)PreferenceUnavailable);
            return hashCode.ToHashCode();
        }

        public void SetLoadout(RoleLoadout loadout)
        {
            _loadouts[loadout.Role.Id] = loadout;
        }

        public HumanoidCharacterProfile WithLoadout(RoleLoadout loadout)
        {
            // Deep copies so we don't modify the DB profile.
            var copied = new Dictionary<string, RoleLoadout>();

            foreach (var proto in _loadouts)
            {
                if (proto.Key == loadout.Role)
                    continue;

                copied[proto.Key] = proto.Value.Clone();
            }

            copied[loadout.Role] = loadout.Clone();
            var profile = Clone();
            profile._loadouts = copied;
            return profile;
        }

        public RoleLoadout GetLoadoutOrDefault(string id, ICommonSession? session, ProtoId<SpeciesPrototype>? species, IEntityManager entManager, IPrototypeManager protoManager)
        {
            if (!_loadouts.TryGetValue(id, out var loadout))
            {
                loadout = new RoleLoadout(id);
                loadout.SetDefault(this, session, protoManager, force: true);
            }

            loadout.SetDefault(this, session, protoManager);
            return loadout;
        }

        // Corvax-Wega-Graphomancy-Extended-start
        private string FormatTags(string inputTags)
        {
            if (string.IsNullOrWhiteSpace(inputTags))
                return string.Empty;

            var rawTags = inputTags.Split(new[] { ',', ' ', '\n', '\r', '\t', ';' }, StringSplitOptions.RemoveEmptyEntries);
            var formattedTags = new List<string>();

            foreach (var rawTag in rawTags)
            {
                var tag = rawTag.Trim();
                if (string.IsNullOrEmpty(tag))
                    continue;

                if (!tag.StartsWith("#"))
                {
                    tag = "#" + tag;
                }

                if (tag.Length > 1)
                {
                    formattedTags.Add(tag);
                }
            }

            return string.Join(", ", formattedTags);
        }
        // Corvax-Wega-Graphomancy-Extended-end

        public HumanoidCharacterProfile Clone()
        {
            return new HumanoidCharacterProfile(this);
        }
    }
}