using Jellyfin.Plugin.Multilang.Data; using static Jellyfin.Plugin.Multilang.MultilangConstants; namespace Jellyfin.Plugin.Multilang.Rules; public static class UserRulesNormalizer { private static readonly string[] RequirementFieldOrder = [ "original_language", "spoken_languages", "audio_language", "origin_countries", "production_countries" ]; public static UserRulesDocument Normalize(UserRulesDocument rules, IEnumerable? languages = null) { var allowed = (languages ?? (rules.Categories ?? []).SelectMany(c => (c.FieldActionLists ?? []).Values) .Concat((rules.FallbackFieldActions ?? []).Values).SelectMany(actions => actions ?? []) .Where(action => action is not null && action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase)).Select(action => action[LanguagePrefix.Length..])) .ToHashSet(StringComparer.OrdinalIgnoreCase); rules.Categories = NormalizeCategories(rules.Categories, allowed); rules.FallbackFieldActions = NormalizeActionLists(rules.FallbackFieldActions, allowed); return rules; } private static UserCategoryRule[] NormalizeCategories(IEnumerable? categories, IReadOnlySet allowedLanguages) => (categories ?? []) .Select(category => new UserCategoryRule { Id = string.IsNullOrWhiteSpace(category.Id) ? Guid.NewGuid().ToString("N") : category.Id.Trim(), Label = string.IsNullOrWhiteSpace(category.Label) ? "Category" : category.Label.Trim(), Requirements = NormalizeRequirements(category.Requirements), MatchAllConditions = category.MatchAllConditions, Scopes = (category.Scopes ?? []) .Where(scope => scope is "M" or "S" or "C") .Distinct(StringComparer.OrdinalIgnoreCase) .DefaultIfEmpty("M") .ToArray(), FieldActionLists = NormalizeActionLists(category.FieldActionLists, allowedLanguages) }) .ToArray(); private static UserCategoryRequirement[] NormalizeRequirements(IEnumerable? requirements) => (requirements ?? []) .Select(requirement => { var fields = NormalizeRequirementFields(requirement.Fields); return new UserCategoryRequirement { Fields = fields, UseFieldOr = requirement.UseFieldOr, Relation = NormalizeRequirementRelation(requirement.Relation), UseOr = requirement.UseOr, Values = (requirement.Values ?? []) .Where(v => !string.IsNullOrWhiteSpace(v)) .Select(v => v.Trim()) .Distinct(StringComparer.OrdinalIgnoreCase) .ToArray() }; }) .Where(requirement => requirement.Fields.Length > 0 && requirement.Relation.Length > 0 && requirement.Values.Length > 0) .ToArray(); private static string[] NormalizeRequirementFields(IEnumerable? fields) { var requested = (fields ?? []) .Select(NormalizeRequirementField) .Where(field => field.Length > 0) .Distinct(StringComparer.OrdinalIgnoreCase) .ToHashSet(StringComparer.OrdinalIgnoreCase); var result = new List(); string? kind = null; foreach (var field in RequirementFieldOrder) { if (!requested.Contains(field)) continue; var currentKind = IsCountryRequirementField(field) ? "country" : "language"; kind ??= currentKind; if (currentKind == kind) result.Add(field); } return result.ToArray(); } private static string NormalizeRequirementField(string? field) { var normalized = (field ?? string.Empty).Trim().ToLowerInvariant(); return normalized is "original_language" or "spoken_languages" or "audio_language" or "origin_countries" or "production_countries" ? normalized : string.Empty; } private static bool IsCountryRequirementField(string field) => field.Equals("origin_countries", StringComparison.OrdinalIgnoreCase) || field.Equals("production_countries", StringComparison.OrdinalIgnoreCase); private static string NormalizeRequirementRelation(string? relation) { var normalized = (relation ?? string.Empty).Trim().ToLowerInvariant(); return normalized is "is" or "is_not" or "contains" or "not_contains" ? normalized : string.Empty; } private static Dictionary NormalizeActionLists( IReadOnlyDictionary? actions, IReadOnlySet allowedLanguages) { var result = DefaultActionLists(); foreach (var field in result.Keys.ToArray()) { var raw = actions is not null && actions.TryGetValue(field, out var configured) ? configured : [JellyfinAction]; result[field] = NormalizeActionList(field, raw, allowedLanguages); } return result; } private static string[] NormalizeActionList(string field, IEnumerable? raw, IReadOnlySet allowedLanguages) { var result = new List(); foreach (var action in raw ?? []) { var normalized = NormalizeActionToken(action, allowedLanguages); if (normalized.Length == 0) continue; if (result.Contains(normalized, StringComparer.OrdinalIgnoreCase)) continue; result.Add(normalized); } if (RequiresJellyfinFallback(field)) { if (!result.Contains(JellyfinAction, StringComparer.OrdinalIgnoreCase)) result.Add(JellyfinAction); } return result.ToArray(); } private static string NormalizeActionToken(string? raw, IReadOnlySet allowedLanguages) { var action = (raw ?? string.Empty).Trim(); if (action.Equals(JellyfinAction, StringComparison.OrdinalIgnoreCase)) return JellyfinAction; if (action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase)) return OriginalAction; var lang = action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase) ? action[LanguagePrefix.Length..].Trim() : string.Empty; var canonical = allowedLanguages.FirstOrDefault(l => l.Equals(lang, StringComparison.OrdinalIgnoreCase)); return string.IsNullOrWhiteSpace(canonical) ? string.Empty : LanguagePrefix + canonical; } }