v0.7.3 (#74)

* Add newzbay categories; add title lookup API

* Update dependencies

Dockerfile.arm64

@@ -0,0 +1,11 @@
+FROM --platform=linux/arm64 mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
+WORKDIR /app
+
+COPY . ./
+RUN dotnet restore
+RUN dotnet publish -c Release -o out
+
+FROM --platform=linux/arm64 mcr.microsoft.com/dotnet/aspnet:8.0
+WORKDIR /app
+COPY --from=build-env /app/out .
+ENTRYPOINT ["dotnet", "UmlautAdaptarr.dll"]

README.md

@@ -1,58 +1,92 @@
 # UmlautAdaptarr
 
-## English description coming soon
+ A tool to work around Sonarr, Radarr, Lidarr and Readarrs problems with foreign languages.
 
-## Erste Testversion
-Wer möchte kann den UmlautAdaptarr jetzt gerne testen! Über Feedback würde ich mich sehr freuen!
+## Detailed English description coming soon
 
-Es sollte mit allen *arrs funktionieren, hat aber nur bei Sonarr, Readarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
+## Beschreibung
 
-Momentan ist docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. 
-
-[Link zum Docker Image](https://hub.docker.com/r/pcjones/umlautadaptarr)
-
-Zusätzlich müsst ihr in Sonarr oder Prowlarr einen neuen Indexer hinzufügen (für jeden Indexer, bei dem UmlautAdapdarr greifen soll).
-
-Am Beispiel von sceneNZBs:
-
-![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/07c7ca45-e0e5-4a82-af63-365bb23c55c9)
-
-Also alles wie immer, nur dass ihr als API-URL nicht direkt z.B. `https://scenenzbs.com` eingebt, sondern 
-`http://localhost:5005/_/scenenzbs.com`
-
-Den API-Key müsst ihr natürlich auch ganz normal setzen.
-
-## Was macht UmlautAdaptarr überhaupt?
 UmlautAdaptarr löst mehrere Probleme:
-- Releases mit Umlauten werden grundsätzlich nicht korrekt von den *Arrs importiert
-- Releases mit Umlauten werden oft nicht korrekt gefunden (*Arrs suchen nach "o" statt "ö" & es fehlt häufig die korrekte Zuordnung zur Serie/zum Film beim Indexer)
+- Releases mit Umlauten werden grundsätzlich nicht korrekt von den *arrs importiert
+- Releases mit Umlauten werden oft nicht korrekt gefunden (*arrs suchen nach "o" statt "ö" & es fehlt häufig die korrekte Zuordnung zur Serie/zum Film beim Indexer)
 - Sonarr & Radarr erwarten immer den englischen Titel von https://thetvdb.com/ bzw. https://www.themoviedb.org/. Das führt bei deutschen Produktionen oder deutschen Übersetzungen oft zu Problemen - falls die *arrs schon mal etwas mit der Meldung `Found matching series/movie via grab history, but release was matched to series by ID. Automatic import is not possible/` nicht importiert haben, dann war das der Grund.
+- Releases mit schlechtem Naming (z.B. von der Group TvR die kein "GERMAN" in den Releasename tun) werden korrigiert, so dass Sonarr&Radarr diese korrekt erkennen (optional)
+- Zusätzlich werden einige andere Fehler behoben, die häufig dazu führen, dass Titel nicht erfolgreich gefunden, geladen oder importiert werden.
 
-# Wie macht UmlautAdaptarr das?
+## Wie macht UmlautAdaptarr das?
 UmlautAdaptarr tut so, als wäre es ein Indexer. In Wahrheit schaltet sich UmlautAdaptarr aber nur zwischen die *arrs und den echten Indexer und kann somit die Suchen sowie die Ergebnisse abfangen und bearbeiten.
 Am Ende werden die gefundenen Releases immer so umbenannt, dass die Arrs sie einwandfrei erkennen.
-Einige Beispiele findet ihr unter Features.
+Einige Beispiele finden sich [weiter unten](https://github.com/PCJones/UmlautAdaptarr?tab=readme-ov-file#beispiel-funktionalit%C3%A4t).
 
 
 ## Features
 
 | Feature                                                           | Status        |
 |-------------------------------------------------------------------|---------------|
-| Prowlarr & NZB Hydra Support                                                    | ✓|
-| Sonarr Support                                         | ✓             |
-| Lidarr Support                                                    | ✓|
-| Readarr Support                                                   | ✓       |
-| Releases mit deutschem Titel werden erkannt   | ✓             |
-| Releases mit TVDB-Alias Titel werden erkannt  | ✓             |
-| Korrekte Suche und Erkennung von Titel mit Umlauten                            | ✓             |
-| Anfragen-Caching für 5 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
-| Usenet (newznab) Support                                          |✓|
-| Torrent (torznab) Support                                         |✓|
-| Radarr Support                                                    | Geplant       |
-| Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
+| Prowlarr & NZB Hydra Support                                      |✓              |
+| Sonarr Support                                                    |✓              |
+| Lidarr Support                                                    |✓              |
+| Readarr Support                                                   |✓              |
+| Releases mit deutschem Titel werden erkannt                       |✓              |
+| Releases mit TVDB-Alias Titel werden erkannt                      |✓              |
+| Korrekte Suche und Erkennung von Titel mit Umlauten               |✓              |
+| Anfragen-Caching für 12 Minuten zur Reduzierung der API-Zugriff   |✓              |
+| Usenet (newznab) Support                                          |✓              |
+| Torrent (torznab) Support                                         |✓              |
+| Support von mehreren *arr-Instanzen des gleichen Typs (z.B. 2x Sonarr)|✓          |             
+| Releases mit mit schlechtem Naming werden korrekt umbenannt (optional) | in Arbeit|
+| Radarr Support                                                    | in Arbeit     |
+| Webinterface                                                      | Geplant       |
 | Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
 | Wünsche?                                                          | Vorschläge?   |
 
+
+## Installation
+- [Docker](https://hub.docker.com/r/pcjones/umlautadaptarr)
+- Unraid: nach `umlautadaptarr` suchen
+- [Proxmox LXC (unofficial)](https://community-scripts.github.io/ProxmoxVE/scripts?id=umlautadaptarr) - appsettings.json muss nach Installation konfiguriert werden
+- [Seedbox/Binary](https://github.com/PCJones/UmlautAdaptarr/blob/master/run_on_seedbox.sh)
+
+Nicht benötigte Umgebungsvariablen, z.B. falls Readarr oder Lidarr nicht genutzt werden, können entfernt werden.
+
+### Konfiguration in Prowlarr (**empfohlen**)
+Das ist die **empfohlene** Methode um den UmlautAdaptarr einzurichten. Sie hat den Vorteil, dass es, sofern man mehrere Indexer nutzt, keinen Geschwindigkeitsverlust bei der Suche geben sollte.
+
+1) Setze die benötigten [Docker Umgebungsvariablen](https://hub.docker.com/r/pcjones/umlautadaptarr) in deiner docker-compose Datei bzw. in deinem docker run Befehl
+2) In Prowlarr: Settings>Indexers bzw. Einstellungen>Indexer öffnen
+3) Lege einen neuen HTTP-Proxy an:
+
+![Image](https://github.com/PCJones/UmlautAdaptarr/assets/377223/b97418d8-d972-4e3c-9d2f-3a830a5ac0a3)
+
+- Name: UmlautAdaptarr HTTP Proxy (Beispiel)
+- Port: `5006` (Port beachten!) 
+- Tag: `umlautadaptarr`
+- Host: Je nachdem, wie deine Docker-Konfiguration ist, kann es sein, dass du entweder `umlautadaptarr` oder `localhost`, oder ggf. die IP des Host setzen musst. Probiere es sonst einfach aus, indem du auf Test klickst.
+- Die Username- und Passwort-Felder können leergelassen werden.
+4) Gehe zur Indexer-Übersichtsseite
+5) Für alle Indexer/Tracker, die den UmlautAdaptarr nutzen sollen:
+
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/3daea3f1-7c7b-4982-84e2-ea6a42d90fba)
+
+  - Füge den `umlautadaptarr` Tag hinzu
+  - **Wichtig:** Ändere die URL von `https` zu `http`. (Dies ist erforderlich, damit der UmlautAdaptarr die Anfragen **lokal** abfangen kann. **Ausgehende** Anfragen an den Indexer verwenden natürlich weiterhin https).
+6) Klicke danach auf `Test All Indexers` bzw `Alle Indexer Testen`. Falls du irgendwo noch `https` statt `http` stehen hast, sollte in den UmlautAdaptarr logs eine Warnung auftauchen. Mindestens solltest du aber noch ein zweites Mal alle Indexer durchgehen und überprüfen, ob überall `http` eingestellt ist - Indexer, bei denen noch `https` steht, werden nämlich einwandfrei funktionieren - allerdings ohne, dass der UmlautAdaptarr bei diesen wirken kann.
+
+### Konfiguration in Sonarr/Radarr oder Prowlarr ohne Proxy
+Falls du kein Prowlarr nutzt oder nur 1-3 Indexer nutzt, kannst du diese alternative Konfigurationsmöglichkeit nutzen.
+
+1) Setze die benötigten [Docker Umgebungsvariablen](https://hub.docker.com/r/pcjones/umlautadaptarr) in deiner docker-compose Datei bzw. in deinem docker run Befehl
+2) Bearbeite alle Indexer, bei denen der UmlautAdaptarr greifen soll, wie folgt:
+
+Am Beispiel von sceneNZBs:
+
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/07c7ca45-e0e5-4a82-af63-365bb23c55c9)
+
+Also alles wie immer, nur dass als API-URL nicht direkt z.B. `https://scenenzbs.com` gesetzt wird, sondern 
+`http://localhost:5005/_/scenenzbs.com`
+
+Der API-Key muss natürlich auch ganz normal gesetzt werden.
+
 ## Beispiel-Funktionalität
 In den Klammern am Ende des Releasenamens (Bild 2 & 4) steht zu Anschauungszwecken der deutsche Titel der vorher nicht gefunden bzw. akzeptiert wurde. Das bleibt natürlich nicht so ;)
 
@@ -66,7 +100,7 @@ In den Klammern am Ende des Releasenamens (Bild 2 & 4) steht zu Anschauungszweck
 **Vorher:** Es werden nur Releases mit dem englischen Titel der Serie gefunden
 ![Vorherige Suche, englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/ed7ca0fa-ac36-4584-87ac-b29f32dd9ace)
 
-**Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
+**Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D
 ![Jetzige Suche, deutsche und englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/1c2dbe1a-5943-4fc4-91ef-29708082900e)
 
 
@@ -87,11 +121,13 @@ Sonarr erwartet immer den Englischen Namen, der hier natürlich nicht gegeben is
 ## Kontakt & Support
 - Öffne gerne ein Issue auf GitHub falls du Unterstützung benötigst.
 - [Telegram](https://t.me/pc_jones)
-- Discord: pcjones1 - oder komm in den UsenetDE Discord Server: [https://discord.gg/pZrrMcJMQM](https://discord.gg/pZrrMcJMQM)
+- [UsenetDE Discord Server](https://discord.gg/src6zcH4rr) -> #umlautadaptarr
 
 ## Spenden
 Über eine Spende freue ich mich natürlich immer :D
-PayPal: https://paypal.me/pcjones1
+
+<a href="https://www.buymeacoffee.com/pcjones" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="60px" width="217px" ></a>
+<a href="https://coindrop.to/pcjones" target="_blank"><img src="https://coindrop.to/embed-button.png" style="border-radius: 10px; height: 57px !important;width: 229px !important;" alt="Coindrop.to me"></img></a>
 
 Für andere Spendenmöglichkeiten gerne auf Discord oder Telegram melden - danke!
 
@@ -99,3 +135,7 @@ Für andere Spendenmöglichkeiten gerne auf Discord oder Telegram melden - danke
 - TV Metadata source: https://thetvdb.com
 - Movie Metadata source: https://themoviedb.org
 - Licenses: TODO
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=pcjones/umlautadaptarr&type=Date)](https://star-history.com/#pcjones/umlautadaptarr&Date)

UmlautAdaptarr/Controllers/CapsController.cs

@@ -1,19 +1,30 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
 using System.Text;
 using System.Xml.Linq;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Controllers
 {
-    public class CapsController(ProxyRequestService proxyRequestService) : ControllerBase
+    public class CapsController(ProxyRequestService proxyRequestService, IOptions<GlobalOptions> options, ILogger<CapsController> logger) : ControllerBase
     {
         private readonly ProxyRequestService _proxyRequestService = proxyRequestService;
+        private readonly GlobalOptions _options = options.Value;
+        private readonly ILogger<CapsController> _logger = logger;
+
 
         [HttpGet]
-        public async Task<IActionResult> Caps([FromRoute] string options, [FromRoute] string domain, [FromQuery] string? apikey)
+        public async Task<IActionResult> Caps([FromRoute] string apiKey, [FromRoute] string domain, [FromQuery] string? apikey)
         {
-            if (!UrlUtilities.IsValidDomain(domain))
+            if (!string.IsNullOrEmpty(apikey) && !apiKey.Equals(apiKey))
+            {
+                _logger.LogWarning("Invalid or missing API key for request.");
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
+            if (!domain.StartsWith("localhost") && !UrlUtilities.IsValidDomain(domain))
             {
                 return NotFound($"{domain} is not a valid URL.");
             }

UmlautAdaptarr/Controllers/SearchController.cs

@@ -1,29 +1,36 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
 using System.Text;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Controllers
 {
-    public abstract class SearchControllerBase(ProxyRequestService proxyRequestService, TitleMatchingService titleMatchingService) : ControllerBase
+    public abstract class SearchControllerBase(ProxyRequestService proxyRequestService, TitleMatchingService titleMatchingService, IOptions<GlobalOptions> options, ILogger<SearchControllerBase> logger) : ControllerBase
     {
         // TODO evaluate if this should be set to true by default
         private readonly bool TODO_FORCE_TEXT_SEARCH_ORIGINAL_TITLE = true;
         private readonly bool TODO_FORCE_TEXT_SEARCH_GERMAN_TITLE = false;
-        protected async Task<IActionResult> BaseSearch(string options,
+        protected async Task<IActionResult> BaseSearch(string apiKey,
                                                        string domain,
                                                        IDictionary<string, string> queryParameters,
                                                        SearchItem? searchItem = null)
         {
             try
             {
+                if (!AssureApiKey(apiKey))
+                {
+                    return Unauthorized("Unauthorized: Invalid or missing API key.");
+                }
+
                 if (!UrlUtilities.IsValidDomain(domain))
                 {
                     return NotFound($"{domain} is not a valid URL.");
                 }
 
-                var initialSearchResult = await PerformSingleSearchRequest(domain, queryParameters) as ContentResult;
+                ContentResult? initialSearchResult = await PerformSingleSearchRequest(domain, queryParameters) as ContentResult;
                 if (initialSearchResult == null)
                 {
                     return null;
@@ -110,7 +117,15 @@ namespace UmlautAdaptarr.Controllers
 
         private string ProcessContent(string content, SearchItem? searchItem)
         {
-            return titleMatchingService.RenameTitlesInContent(content, searchItem);
+            try
+            {
+                return titleMatchingService.RenameTitlesInContent(content, searchItem);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error at ProcessContent: {ex.Message}{Environment.NewLine}Content:{Environment.NewLine}{content}");
+            }
+            return null;
         }
 
         public async Task<AggregatedSearchResult> AggregateSearchResults(
@@ -150,29 +165,50 @@ namespace UmlautAdaptarr.Controllers
 
             return aggregatedResult;
         }
+
+        internal bool AssureApiKey(string apiKey)
+        {
+            if (!string.IsNullOrEmpty(options.Value.ApiKey) && !apiKey.Equals(options.Value.ApiKey))
+            {
+                logger.LogWarning("Invalid or missing API key for request.");
+                return false;
+            }
+            return true;
+        }
     }
 
     public class SearchController(ProxyRequestService proxyRequestService,
                                   TitleMatchingService titleMatchingService,
-                                  SearchItemLookupService searchItemLookupService) : SearchControllerBase(proxyRequestService, titleMatchingService)
+                                  SearchItemLookupService searchItemLookupService,
+                                  IOptions<GlobalOptions> options,
+                                  ILogger<SearchControllerBase> logger) : SearchControllerBase(proxyRequestService, titleMatchingService, options, logger)
     {
         public readonly string[] LIDARR_CATEGORY_IDS = ["3000", "3010", "3020", "3040", "3050"];
         public readonly string[] READARR_CATEGORY_IDS = ["3030", "3130", "7000", "7010", "7020", "7030", "7100", "7110", "7120", "7130"];
 
         [HttpGet]
-        public async Task<IActionResult> MovieSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> MovieSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+            return await BaseSearch(apiKey, domain, queryParameters);
         }
 
         [HttpGet]
-        public async Task<IActionResult> GenericSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> GenericSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
 
-        var queryParameters = HttpContext.Request.Query.ToDictionary(
+            var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
 
@@ -198,21 +234,31 @@ namespace UmlautAdaptarr.Controllers
                 }
             }
 
-            return await BaseSearch(options, domain, queryParameters, searchItem);
+            return await BaseSearch(apiKey, domain, queryParameters, searchItem);
         }
 
         [HttpGet]
-        public async Task<IActionResult> BookSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> BookSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+            return await BaseSearch(apiKey, domain, queryParameters);
         }
 
         [HttpGet]
-        public async Task<IActionResult> TVSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> TVSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+               return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
@@ -229,16 +275,21 @@ namespace UmlautAdaptarr.Controllers
                 searchItem = await searchItemLookupService.GetOrFetchSearchItemByTitle(mediaType, title);
             }
 
-            return await BaseSearch(options, domain, queryParameters, searchItem);
+            return await BaseSearch(apiKey, domain, queryParameters, searchItem);
         }
 
         [HttpGet]
-        public async Task<IActionResult> MusicSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> MusicSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+            return await BaseSearch(apiKey, domain, queryParameters);
         }
     }
 }

UmlautAdaptarr/Controllers/TitleLookupController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Services;
+
+namespace UmlautAdaptarr.Controllers
+{
+	[ApiController]
+	[Route("titlelookup/")]
+	public class TitleLookupController(CacheService cacheService, IOptions<GlobalOptions> options) : ControllerBase
+	{
+		GlobalOptions _options = options.Value;
+		[HttpGet]
+		public IActionResult GetOriginalTitle([FromQuery] string changedTitle)
+		{
+			if (!_options.EnableChangedTitleCache)
+			{
+				return StatusCode(501, "Set SETTINGS__EnableChangedTitleCache to true to use this endpoint.");
+			}
+
+			if (string.IsNullOrWhiteSpace(changedTitle))
+				return BadRequest("changedTitle is required.");
+
+			var originalTitle = cacheService.GetOriginalTitleFromRenamed(changedTitle);
+
+			return originalTitle != null
+				? Ok(new { changedTitle, originalTitle })
+				: NotFound($"Original title not found for '{changedTitle}'.");
+		}
+	}
+
+}

UmlautAdaptarr/Interfaces/IArrApplication.cs

@@ -0,0 +1,10 @@
+using UmlautAdaptarr.Models;
+
+namespace UmlautAdaptarr.Interfaces;
+
+public interface IArrApplication
+{
+    Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
+    Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
+    Task<SearchItem?> FetchItemByTitleAsync(string title);
+}

UmlautAdaptarr/Models/IpInfo.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace UmlautAdaptarr.Utilities;
+
+public class IpInfo
+{
+    [JsonPropertyName("ip")]
+    public string? Ip { get; set; }
+
+    [JsonPropertyName("hostname")]
+    public string? Hostname { get; set; }
+
+    [JsonPropertyName("city")]
+    public string? City { get; set; }
+
+    [JsonPropertyName("region")]
+    public string? Region { get; set; }
+
+    [JsonPropertyName("country")]
+    public string? Country { get; set; }
+
+    [JsonPropertyName("loc")]
+    public string? Loc { get; set; }
+
+    [JsonPropertyName("org")]
+    public string? Org { get; set; }
+
+    [JsonPropertyName("postal")]
+    public string? Postal { get; set; }
+
+    [JsonPropertyName("timezone")]
+    public string? Timezone { get; set; }
+}

UmlautAdaptarr/Models/SearchItem.cs

@@ -108,6 +108,20 @@ namespace UmlautAdaptarr.Models
 
             }
 
+            // if a german title ends with "Germany" (e.g. Good Luck Guys Germany) also add a search string that replaces Germany with GERMAN
+            // (e.g. Good Luck Guys GERMAN). This is because reality shows often have different formats in different countries with the same
+            // name. // also add a matching title without GERMAN
+            if (germanTitle?.EndsWith("germany", StringComparison.OrdinalIgnoreCase) ?? false)
+            {
+                TitleSearchVariations = [.. TitleSearchVariations,
+                    ..
+                    GenerateVariations(
+                        (germanTitle[..^7] + "GERMAN").RemoveExtraWhitespaces(),
+                    mediaType)];
+
+                allTitleVariations.AddRange(GenerateVariations(germanTitle[..^8].Trim(), mediaType));
+            }
+
             // If title contains ":" also match for "-"
             if (germanTitle?.Contains(':') ?? false)
             {
@@ -152,7 +166,7 @@ namespace UmlautAdaptarr.Models
             }
         }
 
-        private IEnumerable<string> GenerateVariations(string? title, string mediaType)
+        private static IEnumerable<string> GenerateVariations(string? title, string mediaType)
         {
             if (title == null)
             {

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/GlobalInstanceOptions.cs

@@ -1,15 +1,17 @@
-namespace UmlautAdaptarr.Options.ArrOptions
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions
 {
-    /// <summary>
-    /// Base Options for ARR applications
-    /// </summary>
-    public class ArrApplicationBaseOptions
+    public class GlobalInstanceOptions
     {
         /// <summary>
         /// Indicates whether the Arr application is enabled.
         /// </summary>
         public bool Enabled { get; set; }
 
+        /// <summary>
+        /// Name of the Instance
+        /// </summary>
+        public string Name { get; set; }
+
         /// <summary>
         /// The host of the ARR application.
         /// </summary>
@@ -20,4 +22,4 @@
         /// </summary>
         public string ApiKey { get; set; }
     }
-}
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/LidarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class LidarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/ReadarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class ReadarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/SonarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class SonarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/LidarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Lidarr Options
-    /// </summary>
-    public class LidarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Readarr Options
-    /// </summary>
-    public class ReadarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Sonarr Options
-    /// </summary>
-    public class SonarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/GlobalOptions.cs

@@ -14,5 +14,25 @@
         /// The User-Agent string used in HTTP requests.
         /// </summary>
         public string UserAgent { get; set; }
-    }
+
+        /// <summary>
+        /// The duration in minutes to cache the indexer requests.
+        /// </summary>  
+        public int IndexerRequestsCacheDurationInMinutes { get; set; } = 12;
+
+        /// <summary>
+        /// API key for requests to the UmlautAdaptarr. Optional.
+        /// </summary>
+        public string? ApiKey { get; set; } = null;
+
+        /// <summary>
+        /// Proxy port for the internal UmlautAdaptarr proxy.
+        /// </summary>
+        public int ProxyPort { get; set; } = 5006;
+
+		/// <summary>
+		/// Enable or disable the cache for changed titles.
+		/// </summary>
+		public bool EnableChangedTitleCache { get; set; } = false;
+	}
 }

UmlautAdaptarr/Options/Proxy.cs

@@ -1,27 +0,0 @@
-namespace UmlautAdaptarr.Options;
-
-/// <summary>
-///     Represents options for proxy configuration.
-/// </summary>
-public class Proxy
-{
-    /// <summary>
-    ///     Gets or sets a value indicating whether to use a proxy.
-    /// </summary>
-    public bool Enabled { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the address of the proxy.
-    /// </summary>
-    public string? Address { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the username for proxy authentication.
-    /// </summary>
-    public string? Username { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the password for proxy authentication.
-    /// </summary>
-    public string? Password { get; set; }
-}

UmlautAdaptarr/Options/ProxyOptions.cs

@@ -1,32 +0,0 @@
-namespace UmlautAdaptarr.Options;
-
-/// <summary>
-///     Represents options for proxy configuration.
-/// </summary>
-public class ProxyOptions
-{
-    /// <summary>
-    ///     Gets or sets a value indicating whether to use a proxy.
-    /// </summary>
-    public bool Enabled { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the address of the proxy.
-    /// </summary>
-    public string? Address { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the username for proxy authentication.
-    /// </summary>
-    public string? Username { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the password for proxy authentication.
-    /// </summary>
-    public string? Password { get; set; }
-
-    /// <summary>
-    ///     Bypass Local Ip Addresses , Proxy will ignore local Ip Addresses
-    /// </summary>
-    public bool BypassOnLocal { get; set; }
-}

UmlautAdaptarr/Program.cs

@@ -1,31 +1,37 @@
 using System.Net;
-using UmlautAdaptarr.Options;
+using Serilog;
+using Serilog.Filters;
 using UmlautAdaptarr.Routing;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Services.Factory;
 using UmlautAdaptarr.Utilities;
 
 internal class Program
 {
     private static void Main(string[] args)
+    {
+        MainAsync(args).Wait();
+    }
+
+    private static async Task MainAsync(string[] args)
     {
         // TODO:
         // add option to sort by nzb age
-
-    
-       var builder = WebApplication.CreateBuilder(args);
-
+        var builder = WebApplication.CreateBuilder(args);
         var configuration = builder.Configuration;
+        ConfigureLogger(configuration);
+
+        builder.Services.AddSerilog();
 
         // Add services to the container.
         builder.Services.AddHttpClient("HttpClient").ConfigurePrimaryHttpMessageHandler(() =>
         {
             var handler = new HttpClientHandler
             {
-                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.Brotli
+                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate |
+                                         DecompressionMethods.Brotli
             };
 
-            var proxyOptions = configuration.GetSection("Proxy").Get<ProxyOptions>();
-            handler.ConfigureProxy(proxyOptions);
             return handler;
         });
 
@@ -35,66 +41,82 @@ internal class Program
             //options.SizeLimit = 20000;
         });
 
-
-        // TODO workaround to not log api keys
-        builder.Logging.AddFilter((category, level) =>
-        {
-            // Prevent logging of HTTP request and response if the category is HttpClient
-            if (category.Contains("System.Net.Http.HttpClient") || category.Contains("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
-            {
-                return false;
-            }
-            return true;
-        });
-
+        builder.Services.AllowResolvingKeyedServicesAsDictionary();
         builder.Services.AddControllers();
-        builder.Services.AddHostedService<ArrSyncBackgroundService>();
         builder.AddTitleLookupService();
         builder.Services.AddSingleton<SearchItemLookupService>();
         builder.Services.AddSingleton<TitleMatchingService>();
-        builder.AddSonarrSupport();
-        builder.AddLidarrSupport();
-        builder.AddReadarrSupport();
+        await builder.AddSonarrSupport();
+        await builder.AddLidarrSupport();
+        await builder.AddReadarrSupport();
         builder.Services.AddSingleton<CacheService>();
         builder.Services.AddSingleton<ProxyRequestService>();
+        builder.Services.AddSingleton<ArrApplicationFactory>();
+        builder.Services.AddHostedService<ArrSyncBackgroundService>();
         builder.Services.AddSingleton<IHostedService, HttpProxyService>();
 
         var app = builder.Build();
 
+        Helper.ShowLogo();
+
+        if (app.Configuration.GetValue<bool>("IpLeakTest:Enabled"))
+        {
+            await Helper.ShowInformation();
+        }
+
         GlobalStaticLogger.Initialize(app.Services.GetService<ILoggerFactory>()!);
         app.UseHttpsRedirection();
         app.UseAuthorization();
 
-        app.MapControllerRoute(name: "caps",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Caps", action = "Caps" },
-                constraints: new { t = new TRouteConstraint("caps") });
+        app.MapControllerRoute("caps",
+            "{apiKey}/{*domain}",
+            new { controller = "Caps", action = "Caps" },
+            new { t = new TRouteConstraint("caps") });
 
-        app.MapControllerRoute(name: "movie-search",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "MovieSearch" },
-                constraints: new { t = new TRouteConstraint("movie") });
+        app.MapControllerRoute("movie-search",
+            "{apiKey}/{*domain}",
+            new { controller = "Search", action = "MovieSearch" },
+            new { t = new TRouteConstraint("movie") });
 
-        app.MapControllerRoute(name: "tv-search",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "TVSearch" },
-                constraints: new { t = new TRouteConstraint("tvsearch") });
+        app.MapControllerRoute("tv-search",
+            "{apiKey}/{*domain}",
+            new { controller = "Search", action = "TVSearch" },
+            new { t = new TRouteConstraint("tvsearch") });
 
-        app.MapControllerRoute(name: "music-search",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "MusicSearch" },
-                constraints: new { t = new TRouteConstraint("music") });
+        app.MapControllerRoute("music-search",
+            "{apiKey}/{*domain}",
+            new { controller = "Search", action = "MusicSearch" },
+            new { t = new TRouteConstraint("music") });
 
-        app.MapControllerRoute(name: "book-search",
-               pattern: "{options}/{*domain}",
-               defaults: new { controller = "Search", action = "BookSearch" },
-               constraints: new { t = new TRouteConstraint("book") });
-
-        app.MapControllerRoute(name: "generic-search",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "GenericSearch" },
-                constraints: new { t = new TRouteConstraint("search") });
+        app.MapControllerRoute("book-search",
+            "{apiKey}/{*domain}",
+            new { controller = "Search", action = "BookSearch" },
+            new { t = new TRouteConstraint("book") });
 
+        app.MapControllerRoute("generic-search",
+            "{apiKey}/{*domain}",
+            new { controller = "Search", action = "GenericSearch" },
+            new { t = new TRouteConstraint("search") });
         app.Run();
     }
-}
+
+    private static void ConfigureLogger(ConfigurationManager configuration)
+    {
+        Log.Logger = new LoggerConfiguration()
+            .ReadFrom.Configuration(configuration)
+            .WriteTo.Console(outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
+
+#if RELEASE
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Mvc"))
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Routing"))
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Diagnostics"))
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Hosting"))
+#endif
+
+            // TODO workaround to not log api keys
+            .Filter.ByExcluding(Matching.FromSource("System.Net.Http.HttpClient"))
+            .Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
+            //.Enrich.With(new ApiKeyMaskingEnricher("appsettings.json")) // TODO - Not working currently
+            .CreateLogger();
+    }
+}

UmlautAdaptarr/Providers/ArrClientBase.cs

@@ -1,13 +1,14 @@
-using Microsoft.Extensions.Caching.Memory;
+using UmlautAdaptarr.Interfaces;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Services;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public abstract class ArrClientBase : IArrApplication
 {
-    public abstract class ArrClientBase()
-    {
-        public abstract Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
-        public abstract Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
-        public abstract Task<SearchItem?> FetchItemByTitleAsync(string title);
-    }
-}
+#pragma warning disable CS8618 // Ein Non-Nullable-Feld muss beim Beenden des Konstruktors einen Wert ungleich NULL enthalten. Erwägen Sie die Deklaration als Nullable.
+    public string InstanceName;
+#pragma warning restore CS8618 // Ein Non-Nullable-Feld muss beim Beenden des Konstruktors einen Wert ungleich NULL enthalten. Erwägen Sie die Deklaration als Nullable.
+    public abstract Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
+    public abstract Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
+    public abstract Task<SearchItem?> FetchItemByTitleAsync(string title);
+}

UmlautAdaptarr/Providers/ArrClientFactory.cs

@@ -1,17 +0,0 @@
-namespace UmlautAdaptarr.Providers
-{
-    public static class ArrClientFactory
-    {
-        // TODO, still uses old IConfiguration
-        // TODO not used yet
-        public static IEnumerable<TClient> CreateClients<TClient>(
-            Func<string, TClient> constructor, IConfiguration configuration, string configKey) where TClient : ArrClientBase
-        {
-            var hosts = configuration.GetValue<string>(configKey)?.Split(',') ?? throw new ArgumentException($"{configKey} environment variable must be set if the app is enabled");
-            foreach (var host in hosts)
-            {
-                yield return constructor(host.Trim());
-            }
-        }
-    }
-}

UmlautAdaptarr/Providers/LidarrClient.cs

@@ -1,149 +1,168 @@
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class LidarrClient : ArrClientBase
 {
-    public class LidarrClient(
+    private readonly IMemoryCache _cache;
+    private readonly CacheService _cacheService;
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<LidarrClient> _logger;
+    private readonly string _mediaType = "audio";
+
+    public LidarrClient([ServiceKey] string instanceName,
         IHttpClientFactory clientFactory,
         CacheService cacheService,
-        IMemoryCache cache,
-        ILogger<LidarrClient> logger, IOptions<LidarrInstanceOptions> options) : ArrClientBase()
+        IMemoryCache cache, IOptionsMonitor<LidarrInstanceOptions> options,
+        ILogger<LidarrClient> logger)
     {
-        public LidarrInstanceOptions LidarrOptions { get; } = options.Value;
-        private readonly string _mediaType = "audio";
-
-        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
-        {
-            var httpClient = clientFactory.CreateClient();
-            var items = new List<SearchItem>();
-
-            try
-            {
-                var lidarrArtistsUrl = $"{LidarrOptions.Host}/api/v1/artist?apikey={LidarrOptions.ApiKey}";
-                logger.LogInformation($"Fetching all artists from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
-                var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
-                var artists = JsonConvert.DeserializeObject<List<dynamic>>(artistsApiResponse);
-
-                if (artists == null)
-                {
-                    logger.LogError($"Lidarr artists API request resulted in null");
-                    return items;
-                }
-                logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr.");
-                foreach (var artist in artists)
-                {
-                    var artistId = (int)artist.id;
-
-                    var lidarrAlbumUrl = $"{LidarrOptions.Host}/api/v1/album?artistId={artistId}&apikey={LidarrOptions.ApiKey}";
-
-                    // TODO add caching here
-                    // Disable cache for now as it can result in problems when adding new albums that aren't displayed on the artists page initially
-                    //if (cache.TryGetValue(lidarrAlbumUrl, out List<dynamic>? albums))
-                    //{
-                    //    logger.LogInformation($"Using cached albums for {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
-                    //}
-                    //else
-                    //{
-                    logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
-                    var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
-                    var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
-                    //}
-
-                    if (albums == null)
-                    {
-                        logger.LogWarning($"Lidarr album API request for artistId {artistId} resulted in null");
-                        continue;
-                    }
-
-                    logger.LogInformation($"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr.");
-
-                    // Cache albums for 3 minutes
-                    cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
-
-                    foreach (var album in albums)
-                    {
-                        var artistName = (string)album.artist.artistName;
-                        var albumTitle = (string)album.title;
-
-                        var expectedTitle = $"{artistName} {albumTitle}";
-
-                        string[]? aliases = null;
-
-                        // Abuse externalId to set the search string Lidarr uses
-                        var externalId = expectedTitle.GetLidarrTitleForExternalId();
-
-                        var searchItem = new SearchItem
-                        (
-                            arrId: artistId,
-                            externalId: externalId,
-                            title: albumTitle,
-                            expectedTitle: albumTitle,
-                            germanTitle: null,
-                            aliases: aliases,
-                            mediaType: _mediaType,
-                            expectedAuthor: artistName
-                        );
-
-                        items.Add(searchItem);
-                    }
-                }
-
-                logger.LogInformation($"Finished fetching all items from Lidarr");
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all artists from Lidarr: {ex.Message}");
-            }
-
-            return items;
-        }
-
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
-        {
-            try
-            {
-                // For now we have to fetch all items every time
-                // TODO if possible look at the author in search query and only update for author
-                var searchItems = await FetchAllItemsAsync();
-                foreach (var searchItem in searchItems ?? [])
-                {
-                    try
-                    {
-                        cacheService.CacheSearchItem(searchItem);
-                    }
-                    catch (Exception ex)
-                    {
-                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
-            }
-
-            return null;
-        }
-
-        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
-        {
-            try
-            {
-                // this should never be called at the moment
-                throw new NotImplementedException();
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
-            }
-
-            return null;
-        }
+        _clientFactory = clientFactory;
+        _cacheService = cacheService;
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init Lidarr ({InstanceName})");
     }
-}
+
+    public LidarrInstanceOptions Options { get; init; }
+
+
+    public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    {
+        var httpClient = _clientFactory.CreateClient();
+        var items = new List<SearchItem>();
+
+        try
+        {
+            var lidarrArtistsUrl = $"{Options.Host}/api/v1/artist?apikey={Options.ApiKey}";
+            _logger.LogInformation(
+                $"Fetching all artists from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
+            var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
+            var artists = JsonConvert.DeserializeObject<List<dynamic>>(artistsApiResponse);
+
+            if (artists == null)
+            {
+                _logger.LogError($"Lidarr ({InstanceName}) artists API request resulted in null");
+                return items;
+            }
+
+            _logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr ({InstanceName}).");
+            foreach (var artist in artists)
+            {
+                var artistId = (int)artist.id;
+
+                var lidarrAlbumUrl = $"{Options.Host}/api/v1/album?artistId={artistId}&apikey={Options.ApiKey}";
+
+                // TODO add caching here
+                // Disable cache for now as it can result in problems when adding new albums that aren't displayed on the artists page initially
+                //if (cache.TryGetValue(lidarrAlbumUrl, out List<dynamic>? albums))
+                //{
+                //    logger.LogInformation($"Using cached albums for {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
+                //}
+                //else
+                //{
+                _logger.LogInformation(
+                    $"Fetching all albums from artistId {artistId} from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
+                var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
+                var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
+                //}
+
+                if (albums == null)
+                {
+                    _logger.LogWarning(
+                        $"Lidarr ({InstanceName}) album API request for artistId {artistId} resulted in null");
+                    continue;
+                }
+
+                _logger.LogInformation(
+                    $"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr ({InstanceName}).");
+
+                // Cache albums for 3 minutes
+                _cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
+
+                foreach (var album in albums)
+                {
+                    var artistName = (string)album.artist.artistName;
+                    var albumTitle = (string)album.title;
+
+                    var expectedTitle = $"{artistName} {albumTitle}";
+
+                    string[]? aliases = null;
+
+                    // Abuse externalId to set the search string Lidarr uses
+                    var externalId = expectedTitle.GetLidarrTitleForExternalId();
+
+                    var searchItem = new SearchItem
+                    (
+                        artistId,
+                        externalId,
+                        albumTitle,
+                        albumTitle,
+                        null,
+                        aliases: aliases,
+                        mediaType: _mediaType,
+                        expectedAuthor: artistName
+                    );
+
+                    items.Add(searchItem);
+                }
+            }
+
+            _logger.LogInformation($"Finished fetching all items from Lidarr ({InstanceName})");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching all artists from Lidarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return items;
+    }
+
+    public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    {
+        try
+        {
+            // For now we have to fetch all items every time
+            // TODO if possible look at the author in search query and only update for author
+            var searchItems = await FetchAllItemsAsync();
+            foreach (var searchItem in searchItems ?? [])
+                try
+                {
+                    _cacheService.CacheSearchItem(searchItem);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex,
+                        $"An error occurred while caching search item with ID {searchItem.ArrId} in Lidarr ({InstanceName}).");
+                }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
+    }
+
+    public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+    {
+        try
+        {
+            // this should never be called at the moment
+            throw new NotImplementedException();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}): {ex.Message}");
+        }
+
+        return null;
+    }
+}

UmlautAdaptarr/Providers/ReadarrClient.cs

@@ -1,174 +1,186 @@
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class ReadarrClient : ArrClientBase
 {
-    public class ReadarrClient(
-        IHttpClientFactory clientFactory,
+    private readonly IMemoryCache _cache;
+    private readonly CacheService _cacheService;
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<ReadarrClient> _logger;
+    private readonly string _mediaType = "book";
+
+    public ReadarrClient([ServiceKey] string instanceName, IHttpClientFactory clientFactory,
         CacheService cacheService,
         IMemoryCache cache,
-        IOptions<ReadarrInstanceOptions> options,
-        ILogger<ReadarrClient> logger) : ArrClientBase()
+        IOptionsMonitor<ReadarrInstanceOptions> options,
+        ILogger<ReadarrClient> logger)
     {
-
-        public ReadarrInstanceOptions ReadarrOptions { get; } = options.Value;
-        private readonly string _mediaType = "book";
-
-        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
-        {
-            var httpClient = clientFactory.CreateClient();
-            var items = new List<SearchItem>();
-
-            try
-            {
-                var readarrAuthorUrl = $"{ReadarrOptions.Host}/api/v1/author?apikey={ReadarrOptions.ApiKey}";
-                logger.LogInformation($"Fetching all authors from Readarr: {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
-                var authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
-                var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
-
-                if (authors == null)
-                {
-                    logger.LogError($"Readarr authors API request resulted in null");
-                    return items;
-                }
-                logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr.");
-                foreach (var author in authors)
-                {
-                    var authorId = (int)author.id;
-
-                    var readarrBookUrl = $"{ReadarrOptions.Host}/api/v1/book?authorId={authorId}&apikey={ReadarrOptions.ApiKey}";
-
-                    // TODO add caching here
-                    logger.LogInformation($"Fetching all books from authorId {authorId} from Readarr: {UrlUtilities.RedactApiKey(readarrBookUrl)}");
-                    var bookApiResponse = await httpClient.GetStringAsync(readarrBookUrl);
-                    var books = JsonConvert.DeserializeObject<List<dynamic>>(bookApiResponse);
-
-                    if (books == null)
-                    {
-                        logger.LogWarning($"Readarr book API request for authorId {authorId} resulted in null");
-                        continue;
-                    }
-
-                    logger.LogInformation($"Successfully fetched {books.Count} books for authorId {authorId} from Readarr.");
-
-                    // Cache books for 3 minutes
-                    cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
-
-                    foreach (var book in books)
-                    {
-                        var authorName = (string)author.authorName;
-                        var bookTitle = GetSearchBookTitle((string)book.title, authorName);
-
-                        var expectedTitle = $"{bookTitle} {authorName}";
-
-                        string[]? aliases = null;
-
-                        // Abuse externalId to set the search string Readarr uses
-                        // TODO use own method or rename
-                        var externalId = expectedTitle.GetReadarrTitleForExternalId();
-
-                        var searchItem = new SearchItem
-                        (
-                            arrId: authorId,
-                            externalId: externalId,
-                            title: bookTitle,
-                            expectedTitle: bookTitle,
-                            germanTitle: null,
-                            aliases: aliases,
-                            mediaType: _mediaType,
-                            expectedAuthor: authorName
-                        );
-
-                        items.Add(searchItem);
-                    }
-                }
-
-                logger.LogInformation($"Finished fetching all items from Readarr");
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all authors from Readarr: {ex.Message}");
-            }
-
-            return items;
-        }
-
-        // Logic based on https://github.com/Readarr/Readarr/blob/develop/src/NzbDrone.Core/Parser/Parser.cs#L541
-        public static string GetSearchBookTitle(string bookTitle, string authorName)
-        {
-            // Remove author prefix from title if present, e.g., "Tom Clancy: Ghost Protocol"
-            if (!string.IsNullOrEmpty(authorName) && bookTitle.StartsWith($"{authorName}:"))
-            {
-                bookTitle = bookTitle[(authorName.Length + 1)..].Trim();
-            }
-
-            // Remove subtitles or additional info enclosed in parentheses or following a colon, if any
-            int firstParenthesisIndex = bookTitle.IndexOf('(');
-            int firstColonIndex = bookTitle.IndexOf(':');
-
-            if (firstParenthesisIndex > -1)
-            {
-                int endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
-                if (endParenthesisIndex > -1 && bookTitle.Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1).Contains(' '))
-                {
-                    bookTitle = bookTitle[..firstParenthesisIndex].Trim();
-                }
-            }
-            else if (firstColonIndex > -1)
-            {
-                bookTitle = bookTitle[..firstColonIndex].Trim();
-            }
-
-            return bookTitle;
-        }
-
-
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
-        {
-            try
-            {
-                // For now we have to fetch all items every time
-                // TODO if possible look at the author in search query and only update for author
-                var searchItems = await FetchAllItemsAsync();
-                foreach (var searchItem in searchItems ?? [])
-                {
-                    try
-                    {
-                        cacheService.CacheSearchItem(searchItem);
-                    }
-                    catch (Exception ex)
-                    {
-                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
-            }
-
-            return null;
-        }
-
-        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
-        {
-            try
-            {
-                // this should never be called at the moment
-                throw new NotImplementedException();
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
-            }
-
-            return null;
-        }
+        _clientFactory = clientFactory;
+        _cacheService = cacheService;
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init ReadarrClient ({InstanceName})");
     }
-}
+
+    public ReadarrInstanceOptions Options { get; init; }
+
+    public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    {
+        var httpClient = _clientFactory.CreateClient();
+        var items = new List<SearchItem>();
+
+        try
+        {
+            var readarrAuthorUrl = $"{Options.Host}/api/v1/author?apikey={Options.ApiKey}";
+            _logger.LogInformation(
+                $"Fetching all authors from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
+            var authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
+            var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
+
+            if (authors == null)
+            {
+                _logger.LogError($"Readarr ({InstanceName}) authors API request resulted in null");
+                return items;
+            }
+
+            _logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr ({InstanceName}).");
+            foreach (var author in authors)
+            {
+                var authorId = (int)author.id;
+
+                var readarrBookUrl = $"{Options.Host}/api/v1/book?authorId={authorId}&apikey={Options.ApiKey}";
+
+                // TODO add caching here
+                _logger.LogInformation(
+                    $"Fetching all books from authorId {authorId} from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrBookUrl)}");
+                var bookApiResponse = await httpClient.GetStringAsync(readarrBookUrl);
+                var books = JsonConvert.DeserializeObject<List<dynamic>>(bookApiResponse);
+
+                if (books == null)
+                {
+                    _logger.LogWarning(
+                        $"Readarr ({InstanceName}) book API request for authorId {authorId} resulted in null");
+                    continue;
+                }
+
+                _logger.LogInformation(
+                    $"Successfully fetched {books.Count} books for authorId {authorId} from Readarr ({InstanceName}) .");
+
+                // Cache books for 3 minutes
+                _cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
+
+                foreach (var book in books)
+                {
+                    var authorName = (string)author.authorName;
+                    var bookTitle = GetSearchBookTitle((string)book.title, authorName);
+
+                    var expectedTitle = $"{bookTitle} {authorName}";
+
+                    string[]? aliases = null;
+
+                    // Abuse externalId to set the search string Readarr uses
+                    // TODO use own method or rename
+                    var externalId = expectedTitle.GetReadarrTitleForExternalId();
+
+                    var searchItem = new SearchItem
+                    (
+                        authorId,
+                        externalId,
+                        bookTitle,
+                        bookTitle,
+                        null,
+                        aliases: aliases,
+                        mediaType: _mediaType,
+                        expectedAuthor: authorName
+                    );
+
+                    items.Add(searchItem);
+                }
+            }
+
+            _logger.LogInformation($"Finished fetching all items from Readarr ({InstanceName})");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching all authors from Readarr ({InstanceName}): {ex.Message}");
+        }
+
+        return items;
+    }
+
+    // Logic based on https://github.com/Readarr/Readarr/blob/develop/src/NzbDrone.Core/Parser/Parser.cs#L541
+    public static string GetSearchBookTitle(string bookTitle, string authorName)
+    {
+        // Remove author prefix from title if present, e.g., "Tom Clancy: Ghost Protocol"
+        if (!string.IsNullOrEmpty(authorName) && bookTitle.StartsWith($"{authorName}:"))
+            bookTitle = bookTitle[(authorName.Length + 1)..].Trim();
+
+        // Remove subtitles or additional info enclosed in parentheses or following a colon, if any
+        var firstParenthesisIndex = bookTitle.IndexOf('(');
+        var firstColonIndex = bookTitle.IndexOf(':');
+
+        if (firstParenthesisIndex > -1)
+        {
+            var endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
+            if (endParenthesisIndex > -1 && bookTitle
+                    .Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1)
+                    .Contains(' ')) bookTitle = bookTitle[..firstParenthesisIndex].Trim();
+        }
+        else if (firstColonIndex > -1)
+        {
+            bookTitle = bookTitle[..firstColonIndex].Trim();
+        }
+
+        return bookTitle;
+    }
+
+
+    public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    {
+        try
+        {
+            // For now we have to fetch all items every time
+            // TODO if possible look at the author in search query and only update for author
+            var searchItems = await FetchAllItemsAsync();
+            foreach (var searchItem in searchItems ?? [])
+                try
+                {
+                    _cacheService.CacheSearchItem(searchItem);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
+                }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
+    }
+
+    public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+    {
+        try
+        {
+            // this should never be called at the moment
+            throw new NotImplementedException();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
+    }
+}

UmlautAdaptarr/Providers/SonarrClient.cs

@@ -1,171 +1,215 @@
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class SonarrClient : ArrClientBase
 {
-    public class SonarrClient(
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<SonarrClient> _logger;
+
+    private readonly string _mediaType = "tv";
+    private readonly TitleApiService _titleService;
+
+
+    public SonarrClient([ServiceKey] string instanceName,
         IHttpClientFactory clientFactory,
         TitleApiService titleService,
-        IOptions<SonarrInstanceOptions> options,
-        ILogger<SonarrClient> logger) : ArrClientBase()
+        IOptionsMonitor<SonarrInstanceOptions> options,
+        ILogger<SonarrClient> logger)
     {
-        public SonarrInstanceOptions SonarrOptions { get; } = options.Value;
-        private readonly string _mediaType = "tv";
+        _clientFactory = clientFactory;
+        _titleService = titleService;
+        _logger = logger;
 
-        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init SonarrClient ({InstanceName})");
+    }
+
+    public SonarrInstanceOptions Options { get; init; }
+
+    public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    {
+        var httpClient = _clientFactory.CreateClient();
+        var items = new List<SearchItem>();
+
+        try
         {
-            var httpClient = clientFactory.CreateClient();
-            var items = new List<SearchItem>();
+            var sonarrUrl = $"{Options.Host}/api/v3/series?includeSeasonImages=false&apikey={Options.ApiKey}";
+            _logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
+            var response = await httpClient.GetStringAsync(sonarrUrl);
+            var shows = JsonConvert.DeserializeObject<List<dynamic>>(response);
 
-            try
+            if (shows != null)
             {
-                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
-                logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
-                var response = await httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<List<dynamic>>(response);
-
-                if (shows != null)
+                _logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr ({InstanceName}).");
+                // Bulk request (germanTitle, aliases) for all shows
+                var tvdbIds = new List<string>();
+                foreach (var show in shows)
                 {
-                    logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr.");
-                    foreach (var show in shows)
+                    if ((string)show.tvdbId is not string tvdbId)
                     {
-                        var tvdbId = (string)show.tvdbId;
-                        if (tvdbId == null)
-                        {
-                            logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
-                            continue;
-                        }
-
-                        (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
-                        var searchItem = new SearchItem
-                        (
-                            arrId: (int)show.id,
-                            externalId: tvdbId,
-                            title: (string)show.title,
-                            expectedTitle: (string)show.title,
-                            germanTitle: germanTitle,
-                            aliases: aliases,
-                            mediaType: _mediaType
-                        );
-
-                        items.Add(searchItem);
+                        continue;
                     }
+                    tvdbIds.Add(tvdbId);
                 }
 
-                logger.LogInformation($"Finished fetching all items from Sonarr");
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all shows from Sonarr: {ex.Message}");
-            }
+                var bulkTitleData = await _titleService.FetchGermanTitlesAndAliasesByExternalIdBulkAsync(tvdbIds);
+                string? germanTitle;
+                string[]? aliases;
 
-            return items;
-        }
-
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
-        {
-            var httpClient = clientFactory.CreateClient();
-
-            try
-            {
-                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
-                logger.LogInformation($"Fetching item by external ID from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
-                var response = await httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<dynamic>(response);
-                var show = shows?[0];
-
-                if (show != null)
+                foreach (var show in shows)
                 {
                     var tvdbId = (string)show.tvdbId;
                     if (tvdbId == null)
                     {
-                        logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
-                        return null;
+                        _logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
+                        continue;
+                    }
+
+                    if (bulkTitleData.TryGetValue(tvdbId, out var titleData))
+                    {
+                        (germanTitle, aliases) = titleData;
+                    }
+                    else
+                    {
+                        (germanTitle, aliases) =
+                            await _titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
                     }
-                    (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
                     
                     var searchItem = new SearchItem
                     (
-                        arrId: (int)show.id,
-                        externalId: tvdbId,
-                        title: (string)show.title,
-                        expectedTitle: (string)show.title,
-                        germanTitle: germanTitle,
+                        (int)show.id,
+                        tvdbId,
+                        (string)show.title,
+                        (string)show.title,
+                        germanTitle,
                         aliases: aliases,
                         mediaType: _mediaType
                     );
 
-                    logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
-                    return searchItem;
+                    items.Add(searchItem);
                 }
             }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
-            }
 
-            return null;
+            _logger.LogInformation($"Finished fetching all items from Sonarr ({InstanceName})");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching all shows from Sonarr ({InstanceName}) : {ex.Message}");
         }
 
-        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+        return items;
+    }
+
+    public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    {
+        var httpClient = _clientFactory.CreateClient();
+
+        try
         {
-            var httpClient = clientFactory.CreateClient();
+            var sonarrUrl =
+                $"{Options.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={Options.ApiKey}";
+            _logger.LogInformation(
+                $"Fetching item by external ID from Sonarr ({InstanceName}): {UrlUtilities.RedactApiKey(sonarrUrl)}");
+            var response = await httpClient.GetStringAsync(sonarrUrl);
+            var shows = JsonConvert.DeserializeObject<dynamic>(response);
+            var show = shows?[0];
 
-            try
+            if (show != null)
             {
-                (string? germanTitle, string? tvdbId, string[]? aliases) = await titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
-
+                var tvdbId = (string)show.tvdbId;
                 if (tvdbId == null)
                 {
+                    _logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
                     return null;
                 }
 
-                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
-                var sonarrApiResponse = await httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
-
-                if (shows == null)
-                {
-                    logger.LogError($"Parsing Sonarr API response for TVDB ID {tvdbId} resulted in null");
-                    return null;
-                }
-                else if (shows.Count == 0)
-                {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
-                    return null;
-                }
-
-                var expectedTitle = (string)shows[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
-                    return null;
-                }
+                var (germanTitle, aliases) =
+                    await _titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
 
                 var searchItem = new SearchItem
                 (
-                    arrId: (int)shows[0].id,
-                    externalId: tvdbId,
-                    title: (string)shows[0].title,
-                    expectedTitle: (string)shows[0].title,
-                    germanTitle: germanTitle,
+                    (int)show.id,
+                    tvdbId,
+                    (string)show.title,
+                    (string)show.title,
+                    germanTitle,
                     aliases: aliases,
                     mediaType: _mediaType
                 );
 
-                logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
+                _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
                 return searchItem;
             }
-            catch (Exception ex)
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single show from Sonarr ({InstanceName}): {ex.Message}");
+        }
+
+        return null;
+    }
+
+    public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+    {
+        var httpClient = _clientFactory.CreateClient();
+
+        try
+        {
+            var (germanTitle, tvdbId, aliases) =
+                await _titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
+
+            if (tvdbId == null) return null;
+
+            var sonarrUrl =
+                $"{Options.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={Options.ApiKey}";
+            var sonarrApiResponse = await httpClient.GetStringAsync(sonarrUrl);
+            var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
+
+            if (shows == null)
             {
-                logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
+                _logger.LogError($"Parsing Sonarr ({InstanceName}) API response for TVDB ID {tvdbId} resulted in null");
+                return null;
             }
 
-            return null;
+            if (shows.Count == 0)
+            {
+                _logger.LogWarning($"No results found for TVDB ID {tvdbId}");
+                return null;
+            }
+
+            var expectedTitle = (string)shows[0].title;
+            if (expectedTitle == null)
+            {
+                _logger.LogError($"Sonarr ({InstanceName}) : Title for TVDB ID {tvdbId} is null");
+                return null;
+            }
+
+            var searchItem = new SearchItem
+            (
+                (int)shows[0].id,
+                tvdbId,
+                (string)shows[0].title,
+                (string)shows[0].title,
+                germanTitle,
+                aliases: aliases,
+                mediaType: _mediaType
+            );
+
+            _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
+            return searchItem;
         }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single show from Sonarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
     }
-}
+}

UmlautAdaptarr/Services/ArrSyncBackgroundService.cs

@@ -1,145 +1,170 @@
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Services.Factory;
 
-namespace UmlautAdaptarr.Services
+namespace UmlautAdaptarr.Services;
+
+public class ArrSyncBackgroundService(
+    ArrApplicationFactory arrApplicationFactory,
+    CacheService cacheService,
+    ILogger<ArrSyncBackgroundService> logger)
+    : BackgroundService
 {
-    public class ArrSyncBackgroundService(
-        SonarrClient sonarrClient,
-        LidarrClient lidarrClient,
-        ReadarrClient readarrClient,
-        CacheService cacheService,
-        ILogger<ArrSyncBackgroundService> logger) : BackgroundService
+    public ArrApplicationFactory ArrApplicationFactory { get; } = arrApplicationFactory;
+
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        logger.LogInformation("ArrSyncBackgroundService is starting.");
+        var lastRunSuccess = true;
+
+        while (!stoppingToken.IsCancellationRequested)
         {
-            logger.LogInformation("ArrSyncBackgroundService is starting.");
-            bool lastRunSuccess = true;
+            logger.LogInformation("ArrSyncBackgroundService is running.");
+            var syncSuccess = await FetchAndUpdateDataAsync();
+            logger.LogInformation("ArrSyncBackgroundService has completed an iteration.");
 
-            while (!stoppingToken.IsCancellationRequested)
+            if (syncSuccess)
             {
-                logger.LogInformation("ArrSyncBackgroundService is running.");
-                var syncSuccess = await FetchAndUpdateDataAsync();
-                logger.LogInformation("ArrSyncBackgroundService has completed an iteration.");
-
-                if (syncSuccess)
+                lastRunSuccess = true;
+                await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
+            }
+            else
+            {
+                if (lastRunSuccess)
                 {
-                    lastRunSuccess = true;
-                    await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
+                    lastRunSuccess = false;
+                    logger.LogInformation(
+                        "ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
+                    await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
                 }
                 else
                 {
-                    if (lastRunSuccess)
-                    {
-                        lastRunSuccess = false;
-                        logger.LogInformation("ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
-                        await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
-                    }
-                    else
-                    {
-                        logger.LogInformation("ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
-                        await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
-                    }
-                }
-            }
-
-            logger.LogInformation("ArrSyncBackgroundService is stopping.");
-        }
-
-        private async Task<bool> FetchAndUpdateDataAsync()
-        {
-            try
-            {
-                var success = true;
-                if (readarrClient.ReadarrOptions.Enabled)
-                {
-                    var syncSuccess = await FetchItemsFromReadarrAsync();
-                    success = success && syncSuccess;
-                }
-                if (sonarrClient.SonarrOptions.Enabled)
-                {
-                    var syncSuccess = await FetchItemsFromSonarrAsync();
-                    success = success && syncSuccess;
-                }
-                if (lidarrClient.LidarrOptions.Enabled)
-                {
-                    var syncSuccess = await FetchItemsFromLidarrAsync();
-                    success = success && syncSuccess;
-                }
-                return success;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
-            }
-            return false;
-        }
-
-        private async Task<bool> FetchItemsFromSonarrAsync()
-        {
-            try
-            {
-                var items = await sonarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-                return items?.Any()?? false;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
-            }
-            return false;
-        }
-
-        private async Task<bool> FetchItemsFromLidarrAsync()
-        {
-            try
-            {
-                var items = await lidarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-                return items?.Any() ?? false;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
-            }
-            return false;
-        }
-
-        private async Task<bool> FetchItemsFromReadarrAsync()
-        {
-            try
-            {
-                var items = await readarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-                return items?.Any() ?? false;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
-            }
-            return false;
-        }
-
-        private void UpdateSearchItems(IEnumerable<SearchItem>? searchItems)
-        {
-            foreach (var searchItem in searchItems ?? [])
-            {
-                try
-                {
-                    cacheService.CacheSearchItem(searchItem);
-                }
-                catch (Exception ex)
-                {
-                    logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
+                    logger.LogInformation(
+                        "ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
+                    await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
                 }
             }
         }
+
+        logger.LogInformation("ArrSyncBackgroundService is stopping.");
     }
-}
+
+    private async Task<bool> FetchAndUpdateDataAsync()
+    {
+        try
+        {
+            var success = true;
+
+
+            if (ArrApplicationFactory.SonarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromSonarrAsync();
+                success = success && syncSuccess;
+            }
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromReadarrAsync();
+                success = success && syncSuccess;
+            }
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromLidarrAsync();
+                success = success && syncSuccess;
+            }
+
+
+            return success;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
+        }
+
+        return false;
+    }
+
+    private async Task<bool> FetchItemsFromSonarrAsync()
+    {
+        try
+        {
+            var items = new List<SearchItem>();
+
+            foreach (var sonarrClient in ArrApplicationFactory.SonarrInstances)
+            {
+                var result = await sonarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+
+            UpdateSearchItems(items);
+            return items?.Any() ?? false;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
+        }
+
+        return false;
+    }
+
+    private async Task<bool> FetchItemsFromLidarrAsync()
+    {
+        try
+        {
+            var items = new List<SearchItem>();
+
+            foreach (var lidarrClient in ArrApplicationFactory.LidarrInstances)
+            {
+                var result = await lidarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+            UpdateSearchItems(items);
+            return items?.Any() ?? false;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
+        }
+
+        return false;
+    }
+
+    private async Task<bool> FetchItemsFromReadarrAsync()
+    {
+        try
+        {
+            var items = new List<SearchItem>();
+
+            foreach (var readarrClient in ArrApplicationFactory.ReadarrInstances)
+            {
+                var result = await readarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+            UpdateSearchItems(items);
+            return items?.Any() ?? false;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
+        }
+
+        return false;
+    }
+
+    private void UpdateSearchItems(IEnumerable<SearchItem>? searchItems)
+    {
+        foreach (var searchItem in searchItems ?? [])
+            try
+            {
+                cacheService.CacheSearchItem(searchItem);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
+            }
+    }
+}

UmlautAdaptarr/Services/CacheService.cs

@@ -1,20 +1,19 @@
-using Microsoft.AspNetCore.Mvc.Formatters;
-using Microsoft.Extensions.Caching.Memory;
-using System.Reflection.Metadata.Ecma335;
-using System.Text.RegularExpressions;
+using Microsoft.Extensions.Caching.Memory;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public partial class CacheService(IMemoryCache cache)
+	public partial class CacheService(IMemoryCache cache)
     {
         private readonly Dictionary<string, HashSet<string>> VariationIndex = [];
         private readonly Dictionary<string, List<(HashSet<string> TitleVariations, string CacheKey)>> BookVariationIndex = [];
         private readonly Dictionary<string, List<(HashSet<string> TitleVariations, string CacheKey)>> AudioVariationIndex = [];
         private const int VARIATION_LOOKUP_CACHE_LENGTH = 5;
+		private const string TitleRenamePrefix = "title_rename_";
+		private static readonly TimeSpan TitleRenameCacheDuration = TimeSpan.FromHours(12);
 
-        public void CacheSearchItem(SearchItem item)
+		public void CacheSearchItem(SearchItem item)
         {
             var prefix = item.MediaType;
             var cacheKey = $"{prefix}_extid_{item.ExternalId}";
@@ -196,8 +195,19 @@ namespace UmlautAdaptarr.Services
             return null;
         }
 
+		public void CacheTitleRename(string changedTitle, string originalTitle)
+		{
+			if (string.IsNullOrWhiteSpace(changedTitle) || string.IsNullOrWhiteSpace(originalTitle))
+				return;
 
-        [GeneratedRegex("\\s")]
-        private static partial Regex WhiteSpaceRegex();
-    }
+			var key = $"{TitleRenamePrefix}{changedTitle.Trim().ToLowerInvariant()}";
+			cache.Set(key, originalTitle, TitleRenameCacheDuration);
+		}
+
+		public string? GetOriginalTitleFromRenamed(string changedTitle)
+		{
+			var key = $"{TitleRenamePrefix}{changedTitle.Trim().ToLowerInvariant()}";
+			return cache.TryGetValue(key, out string? originalTitle) ? originalTitle : null;
+		}
+	}
 }

UmlautAdaptarr/Services/Factory/ArrApplicationFactory.cs

@@ -0,0 +1,77 @@
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Providers;
+
+namespace UmlautAdaptarr.Services.Factory
+{
+    /// <summary>
+    /// Factory for creating ArrApplication instances.
+    /// </summary>
+    public class ArrApplicationFactory
+    {
+        private readonly ILogger<ArrApplicationFactory> _logger;
+
+        /// <summary>
+        /// Get all IArrApplication instances.
+        /// </summary>
+        public IDictionary<string, IArrApplication> AllInstances { get; init; }
+
+        /// <summary>
+        /// Get all SonarrClient instances.
+        /// </summary>
+        public IEnumerable<SonarrClient> SonarrInstances { get; init; }
+
+        /// <summary>
+        /// Get all LidarrClient instances.
+        /// </summary>
+        public IEnumerable<LidarrClient> LidarrInstances { get; init; }
+
+        /// <summary>
+        /// Get all ReadarrClient instances.
+        /// </summary>
+        public IEnumerable<ReadarrClient> ReadarrInstances { get; init; }
+
+        /// <summary>
+        /// Constructor for the ArrApplicationFactory.
+        /// </summary>
+        /// <param name="arrApplications">A dictionary of IArrApplication instances.</param>
+        /// <param name="logger">Logger Instanz</param>
+        public ArrApplicationFactory(IDictionary<string, IArrApplication> arrApplications, ILogger<ArrApplicationFactory> logger)
+        {
+            _logger = logger;
+            try
+            {
+                SonarrInstances = arrApplications.Values.OfType<SonarrClient>();
+                LidarrInstances = arrApplications.Values.OfType<LidarrClient>();
+                ReadarrInstances = arrApplications.Values.OfType<ReadarrClient>();
+                AllInstances = arrApplications;
+
+                if (AllInstances.Values.Count == 0)
+                {
+                    throw new Exception("No ArrApplication could be successfully initialized. This could be due to a faulty configuration");
+                }
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Error while registering ArrFactory. This is most likely a config problem, please check your environment variables.", e.Message);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Returns an IArrApplication instance that matches the given name.
+        /// </summary>
+        /// <param name="nameOfArrInstance">The name of the IArrApplication instance being sought.</param>
+        /// <returns>The IArrApplication instance that matches the given name.</returns>
+        /// <exception cref="ArgumentException">Thrown when no IArrApplication instance with the given name can be found.</exception>
+        public IArrApplication GetArrInstanceByName(string nameOfArrInstance)
+        {
+            var instance = AllInstances.FirstOrDefault(up => up.Key.Equals(nameOfArrInstance)).Value;
+            if (instance == null)
+            {
+                throw new ArgumentException($"No ArrService with the name {nameOfArrInstance} could be found");
+            }
+
+            return instance;
+        }
+    }
+}

UmlautAdaptarr/Services/HttpProxyService.cs

@@ -1,6 +1,8 @@
-using System.Net;
+using Microsoft.Extensions.Options;
+using System.Net;
 using System.Net.Sockets;
 using System.Text;
+using UmlautAdaptarr.Options;
 
 namespace UmlautAdaptarr.Services
 {
@@ -8,13 +10,20 @@ namespace UmlautAdaptarr.Services
     {
         private TcpListener _listener;
         private readonly ILogger<HttpProxyService> _logger;
-        private readonly int _proxyPort = 5006; // TODO move to appsettings.json
         private readonly IHttpClientFactory _clientFactory;
+        private readonly GlobalOptions _options;
+        private readonly HashSet<string> _knownHosts = [];
+        private readonly object _hostsLock = new();
+        private readonly IConfiguration _configuration;
+        private static readonly string[] newLineSeparator = ["\r\n"];
 
-        public HttpProxyService(ILogger<HttpProxyService> logger, IHttpClientFactory clientFactory)
+        public HttpProxyService(ILogger<HttpProxyService> logger, IHttpClientFactory clientFactory, IConfiguration configuration, IOptions<GlobalOptions> options)
         {
+            _options = options.Value;
             _logger = logger;
+            _configuration = configuration;
             _clientFactory = clientFactory;
+            _knownHosts.Add("prowlarr.servarr.com");
         }
 
         private async Task HandleRequests(CancellationToken stoppingToken)
@@ -30,9 +39,27 @@ namespace UmlautAdaptarr.Services
         {
             using var clientStream = new NetworkStream(clientSocket, ownsSocket: true);
             var buffer = new byte[8192];
-            var bytesRead = await clientStream.ReadAsync(buffer, 0, buffer.Length);
+            var bytesRead = await clientStream.ReadAsync(buffer);
             var requestString = Encoding.ASCII.GetString(buffer, 0, bytesRead);
 
+            if (!string.IsNullOrEmpty(_options.ApiKey))
+            {
+                var headers = ParseHeaders(buffer, bytesRead);
+
+                if (!headers.TryGetValue("Proxy-Authorization", out var proxyAuthorizationHeader) ||
+                    !ValidateApiKey(proxyAuthorizationHeader))
+                {
+                    var isFirstRequest = !headers.ContainsKey("Proxy-Authorization");
+                    if (!isFirstRequest)
+                    {
+                        _logger.LogWarning("Unauthorized access attempt.");
+                    }
+                    await clientStream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 407 Proxy Authentication Required\r\nProxy-Authenticate: Basic realm=\"Proxy\"\r\n\r\n"));
+                    clientSocket.Close();
+                    return;
+                }
+            }
+
             if (requestString.StartsWith("CONNECT"))
             {
                 // Handle HTTPS CONNECT request
@@ -44,19 +71,34 @@ namespace UmlautAdaptarr.Services
                 await HandleHttp(requestString, clientStream, clientSocket, buffer, bytesRead);
             }
         }
+        
+        private bool ValidateApiKey(string proxyAuthorizationHeader)
+        {
+            // Expect the header to be in the format: "Basic <base64encodedApiKey>"
+            if (proxyAuthorizationHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
+            {
+                var encodedKey = proxyAuthorizationHeader["Basic ".Length..].Trim();
+                var decodedKey = Encoding.ASCII.GetString(Convert.FromBase64String(encodedKey));
+                var password = decodedKey.Split(':')[^1];
+                return password == _options.ApiKey;
+            }
+            return false;
+        }
 
         private async Task HandleHttpsConnect(string requestString, NetworkStream clientStream, Socket clientSocket)
         {
-            var targetInfo = ParseTargetInfo(requestString);
-            if (targetInfo.host != "prowlarr.servarr.com")
+            var (host, port) = ParseTargetInfo(requestString);
+
+            // Prowlarr will send grab requests via https which cannot be changed
+            if (!_knownHosts.Contains(host))
             {
-                _logger.LogWarning($"IMPORTANT! {Environment.NewLine} Indexer {targetInfo.host} needs to be set to http:// instead of https:// {Environment.NewLine}" +
-                    $"UmlautAdaptarr will not work for {targetInfo.host}!");
+                _logger.LogWarning($"IMPORTANT! {Environment.NewLine} Indexer {host} needs to be set to http:// instead of https:// {Environment.NewLine}" +
+                    $"UmlautAdaptarr will not work for {host}!");
             }
             using var targetSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
             try
             {
-                await targetSocket.ConnectAsync(targetInfo.host, targetInfo.port);
+                await targetSocket.ConnectAsync(host, port);
                 await clientStream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 200 Connection Established\r\n\r\n"));
                 using var targetStream = new NetworkStream(targetSocket, ownsSocket: true);
                 await RelayTraffic(clientStream, targetStream);
@@ -74,9 +116,23 @@ namespace UmlautAdaptarr.Services
             {
                 var headers = ParseHeaders(buffer, bytesRead);
                 string userAgent = headers.FirstOrDefault(h => h.Key == "User-Agent").Value;
-
                 var uri = new Uri(requestString.Split(' ')[1]);
-                var modifiedUri = $"http://localhost:5005/_/{uri.Host}{uri.PathAndQuery}";  // TODO read port from appsettings?
+
+                // Add to known hosts if not already present
+                lock (_hostsLock)
+                {
+                    if (!_knownHosts.Contains(uri.Host))
+                    {
+                        _knownHosts.Add(uri.Host);
+                    }
+                }
+
+                var url = _configuration["Kestrel:Endpoints:Http:Url"];
+                var port = new Uri(url).Port;
+
+                var apiKey = string.IsNullOrEmpty(_options.ApiKey) ? "_" : _options.ApiKey;
+
+                var modifiedUri = $"http://localhost:{port}/{apiKey}/{uri.Host}{uri.PathAndQuery}";
                 using var client = _clientFactory.CreateClient();
                 var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, modifiedUri);
                 httpRequestMessage.Headers.Add("User-Agent", userAgent);
@@ -108,21 +164,21 @@ namespace UmlautAdaptarr.Services
         {
             var headers = new Dictionary<string, string>();
             var headerString = Encoding.ASCII.GetString(buffer, 0, length);
-            var lines = headerString.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
+            var lines = headerString.Split(newLineSeparator, StringSplitOptions.RemoveEmptyEntries);
             foreach (var line in lines.Skip(1)) // Skip the request line
             {
                 var colonIndex = line.IndexOf(':');
                 if (colonIndex > 0)
                 {
-                    var key = line.Substring(0, colonIndex).Trim();
-                    var value = line.Substring(colonIndex + 1).Trim();
+                    var key = line[..colonIndex].Trim();
+                    var value = line[(colonIndex + 1)..].Trim();
                     headers[key] = value;
                 }
             }
             return headers;
         }
 
-        private (string host, int port) ParseTargetInfo(string requestLine)
+        private static (string host, int port) ParseTargetInfo(string requestLine)
         {
             var parts = requestLine.Split(' ')[1].Split(':');
             return (parts[0], int.Parse(parts[1]));
@@ -135,7 +191,7 @@ namespace UmlautAdaptarr.Services
             await Task.WhenAll(clientToTargetTask, targetToClientTask);
         }
 
-        private async Task RelayStream(NetworkStream input, NetworkStream output)
+        private static async Task RelayStream(NetworkStream input, NetworkStream output)
         {
             byte[] buffer = new byte[8192];
             int bytesRead;
@@ -148,7 +204,7 @@ namespace UmlautAdaptarr.Services
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
-            _listener = new TcpListener(IPAddress.Any, _proxyPort);
+            _listener = new TcpListener(IPAddress.Any, _options.ProxyPort);
             _listener.Start();
             Task.Run(() => HandleRequests(cancellationToken), cancellationToken);
             return Task.CompletedTask;

UmlautAdaptarr/Services/ProxyRequestService.cs

@@ -81,7 +81,7 @@ namespace UmlautAdaptarr.Services
 
                 if (responseMessage.IsSuccessStatusCode)
                 {
-                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(12));
+                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(_options.IndexerRequestsCacheDurationInMinutes));
                 }
 
                 return responseMessage;

UmlautAdaptarr/Services/SearchItemLookupService.cs

@@ -1,12 +1,11 @@
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Services.Factory;
 
 namespace UmlautAdaptarr.Services
 {
     public class SearchItemLookupService(CacheService cacheService,
-                                         SonarrClient sonarrClient,
-                                         ReadarrClient readarrClient,
-                                         LidarrClient lidarrClient)
+        ArrApplicationFactory arrApplicationFactory)
     {
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
@@ -22,23 +21,40 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (sonarrClient.SonarrOptions.Enabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+
+                    if (sonarrInstances.Any())
                     {
-                        fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                        foreach (var sonarrClient in sonarrInstances)
+                        {
+                            fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                        }
                     }
                     break;
                 case "audio":
-                    if (lidarrClient.LidarrOptions.Enabled)
+
+                    var lidarrInstances = arrApplicationFactory.LidarrInstances;
+
+                    if (lidarrInstances.Any())
                     {
-                        await lidarrClient.FetchItemByExternalIdAsync(externalId);
-                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        foreach (var lidarrClient in lidarrInstances)
+                        {
+                            await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                            fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        }
                     }
                     break;
                 case "book":
-                    if (readarrClient.ReadarrOptions.Enabled)
+
+                    var readarrInstances = arrApplicationFactory.ReadarrInstances;
+                    if (readarrInstances.Any())
                     {
-                        await readarrClient.FetchItemByExternalIdAsync(externalId);
-                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        foreach (var readarrClient in readarrInstances)
+                        {
+                            await readarrClient.FetchItemByExternalIdAsync(externalId);
+                            fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        }
                     }
                     break;
             }
@@ -66,7 +82,9 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (sonarrClient.SonarrOptions.Enabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+                    foreach (var sonarrClient in sonarrInstances)
                     {
                         fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
                     }

UmlautAdaptarr/Services/TitleApiService.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System.Text;
 using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
@@ -22,7 +23,7 @@ namespace UmlautAdaptarr.Services
             lastRequestTime = DateTime.Now;
         }
 
-        // TODO add cache, TODO add bulk request
+        // TODO add caching
         public async Task<(string? germanTitle, string[]? aliases)> FetchGermanTitleAndAliasesByExternalIdAsync(string mediaType, string externalId)
         {
             try
@@ -68,6 +69,68 @@ namespace UmlautAdaptarr.Services
             return (null, null);
         }
 
+        public async Task<Dictionary<string, (string? germanTitle, string[]? aliases)>> FetchGermanTitlesAndAliasesByExternalIdBulkAsync(IEnumerable<string> tvdbIds)
+        {
+            try
+            {
+                await EnsureMinimumDelayAsync();
+
+                var httpClient = clientFactory.CreateClient();
+                var bulkApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?bulk=true";
+                logger.LogInformation($"TitleApiService POST {UrlUtilities.RedactApiKey(bulkApiUrl)}");
+
+                // Prepare POST request payload
+                var payload = new { tvdbIds = tvdbIds.ToArray() };
+                var jsonPayload = JsonConvert.SerializeObject(payload);
+                var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+                // Send POST request
+                var response = await httpClient.PostAsync(bulkApiUrl, content);
+                if (!response.IsSuccessStatusCode)
+                {
+                    logger.LogError($"Failed to fetch German titles via bulk API. Status Code: {response.StatusCode}");
+                    return [];
+                }
+
+                var responseContent = await response.Content.ReadAsStringAsync();
+                var bulkApiResponseData = JsonConvert.DeserializeObject<dynamic>(responseContent);
+
+                if (bulkApiResponseData == null || bulkApiResponseData.status != "success")
+                {
+                    logger.LogError($"Parsing UmlautAdaptarr Bulk API response resulted in null or an error status.");
+                    return [];
+                }
+
+                // Process response data
+                var results = new Dictionary<string, (string? germanTitle, string[]? aliases)>();
+                foreach (var entry in bulkApiResponseData.data)
+                {
+                    string tvdbId = entry.tvdbId;
+                    string? germanTitle = entry.germanTitle;
+
+                    string[]? aliases = null;
+                    if (entry.aliases != null)
+                    {
+                        JArray aliasesArray = JArray.FromObject(entry.aliases);
+                        aliases = aliasesArray.Children<JObject>()
+                            .Select(alias => alias["name"].ToString())
+                            .ToArray();
+                    }
+
+                    results[tvdbId] = (germanTitle, aliases);
+                }
+
+                logger.LogInformation($"Successfully fetched German titles for {results.Count} TVDB IDs via bulk API.");
+
+                return results;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error fetching German titles in bulk: {ex.Message}");
+                return new Dictionary<string, (string? germanTitle, string[]? aliases)>();
+            }
+        }
+
         public async Task<(string? germanTitle, string? externalId, string[]? aliases)> FetchGermanTitleAndExternalIdAndAliasesByTitle(string mediaType, string title)
         {
             try

UmlautAdaptarr/Services/TitleMatchingService.cs

@@ -1,14 +1,18 @@
 using Microsoft.Extensions.FileSystemGlobbing.Internal;
+using Microsoft.Extensions.Options;
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public partial class TitleMatchingService(CacheService cacheService, ILogger<TitleMatchingService> logger)
+    public partial class TitleMatchingService(CacheService cacheService, ILogger<TitleMatchingService> logger, IOptions<GlobalOptions> options)
     {
-        public string RenameTitlesInContent(string content, SearchItem? searchItem)
+		public GlobalOptions _options { get; } = options.Value;
+
+		public string RenameTitlesInContent(string content, SearchItem? searchItem)
         {
             var xDoc = XDocument.Parse(content);
 
@@ -46,10 +50,10 @@ namespace UmlautAdaptarr.Services
                     switch (mediaType)
                     {
                         case "tv":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
+                            FindAndReplaceForMoviesAndTV(searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "movie":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
+                            FindAndReplaceForMoviesAndTV(searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "audio":
                             FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
@@ -69,11 +73,11 @@ namespace UmlautAdaptarr.Services
         public void FindAndReplaceForBooksAndAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
         {
             var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
-            var titleMatch = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+            var (foundMatch, bestStart, bestEndInOriginal) = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
 
-            if (authorMatch.foundMatch && titleMatch.foundMatch)
+            if (authorMatch.foundMatch && foundMatch)
             {
-                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, titleMatch.bestEndInOriginal);
+                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, bestEndInOriginal);
 
                 // Check and adjust for immediate following delimiter
                 char[] delimiters = [' ', '-', '_', '.'];
@@ -94,7 +98,11 @@ namespace UmlautAdaptarr.Services
 
                 // Update the title element
                 titleElement.Value = updatedTitle;
-                logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{updatedTitle}'");
+                if (_options.EnableChangedTitleCache)
+                {
+					cacheService.CacheTitleRename(updatedTitle, originalTitle);
+				}
+				logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{updatedTitle}'");
             }
             else
             {
@@ -103,7 +111,7 @@ namespace UmlautAdaptarr.Services
         }
 
 
-        private (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
+        private static (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
         {
             bool found = false;
             int bestStart = int.MaxValue;
@@ -131,7 +139,7 @@ namespace UmlautAdaptarr.Services
         }
 
         // Maps an index from the normalized string back to a corresponding index in the original string
-        private int MapNormalizedIndexToOriginal(string normalizedOriginal, string originalTitle, int normalizedIndex)
+        private static int MapNormalizedIndexToOriginal(string normalizedOriginal, string originalTitle, int normalizedIndex)
         {
             // Count non-special characters up to the given index in the normalized string
             int nonSpecialCharCount = 0;
@@ -161,7 +169,7 @@ namespace UmlautAdaptarr.Services
         }
 
         // This method replaces the first variation that starts at the beginning of the release title
-        private static void FindAndReplaceForMoviesAndTV(ILogger<TitleMatchingService> logger, SearchItem searchItem, XElement? titleElement, string originalTitle, string normalizedOriginalTitle)
+        private void FindAndReplaceForMoviesAndTV(SearchItem searchItem, XElement? titleElement, string originalTitle, string normalizedOriginalTitle)
         {
             var titleMatchVariations = searchItem.TitleMatchVariations;
             var expectedTitle = searchItem.ExpectedTitle;
@@ -196,9 +204,9 @@ namespace UmlautAdaptarr.Services
                     // Workaround for the rare case of e.g. "Frieren: Beyond Journey's End" that also has the alias "Frieren"
                     if (expectedTitle!.StartsWith(variation, StringComparison.OrdinalIgnoreCase))
                     {
-                        // See if we already matched the whole title by checking if S01E01 pattern is coming next to avoid false positives
+                        // See if we already matched the whole title by checking if S01E01/S2024E123 pattern is coming next to avoid false positives
                         // - that won't help with movies but with tv shows
-                        var seasonMatchingPattern = $"^{separator}S\\d{{1,2}}E\\d{{1,2}}";
+                        var seasonMatchingPattern = $"^{separator}S\\d{{1,4}}E\\d{{1,4}}";
                         if (!Regex.IsMatch(suffix, seasonMatchingPattern))
                         {
                             logger.LogWarning($"TitleMatchingService - Didn't rename: '{originalTitle}' because the expected title '{expectedTitle}' starts with the variation '{variation}'");
@@ -209,16 +217,8 @@ namespace UmlautAdaptarr.Services
                     // Clean up any leading separator from the suffix
                     suffix = Regex.Replace(suffix, "^ +", "");
 
-                    // TODO EVALUTE! definitely make this optional - this adds GERMAN to the title is the title is german to make sure it's recognized as german
-                    // can lead to problems with shows such as "dark" that have international dubs
-                    /*
-                    // Check if "german" is not in the original title, ignoring case
-                    if (!Regex.IsMatch(originalTitle, "german", RegexOptions.IgnoreCase))
-                    {
-                        // Insert "GERMAN" after the newTitlePrefix
-                        newTitlePrefix += separator + "GERMAN";
-                    }
-                    */
+                    // TODO add this when radarr is implemented
+                    // FixBadReleaseNaming
 
                     // Construct the new title with the original suffix
                     var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : suffix.StartsWith(separator) ? suffix : $"{separator}{suffix}");
@@ -226,13 +226,60 @@ namespace UmlautAdaptarr.Services
                     // Update the title element's value with the new title
                     //titleElement.Value = newTitle + $"({originalTitle.Substring(0, variationLength)})";
                     titleElement.Value = newTitle;
-
-                    logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{newTitle}'");
+					if (_options.EnableChangedTitleCache)
+					{
+						cacheService.CacheTitleRename(newTitle, originalTitle);
+					}
+					logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{newTitle}'");
                     break;
                 }
             }
         }
 
+        private static readonly string[] MissingGermanTagReleaseGroups = ["tvr"];
+        private static readonly string[] HEVCInsteadOfx265TagReleaseGroups = ["eisbaer"];
+        private static readonly string[] WrongTagsReleaseGroups = ["eisbaer"];
+        private static string FixBadReleaseNaming(string title, string seperator, ILogger<TitleMatchingService> logger)
+        {
+            var releaseGroup = GetReleaseGroup(title);
+            if (MissingGermanTagReleaseGroups.Contains(releaseGroup))
+            {
+                // Check if "german" is not in the title, ignoring case
+                if (!Regex.IsMatch(title, "german", RegexOptions.IgnoreCase))
+                {
+                    logger.LogInformation($"FixBadReleaseNaming - found missing GERMAN tag for {title}");
+                    // TODO not finished
+                    // Insert "GERMAN" after the newTitlePrefix
+                    //newTitlePrefix += separator + "GERMAN";
+                }
+            }
+
+            if (HEVCInsteadOfx265TagReleaseGroups.Contains(releaseGroup))
+            {
+                if (!title.Contains("REMUX", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    logger.LogInformation($"FixBadReleaseNaming - found HEVC instead of x265 for {title}");
+                    title = title.Replace("HEVC", "x265");
+                }
+            }
+
+            if (WrongTagsReleaseGroups.Contains(releaseGroup))
+            {
+                if (title.Contains($"{seperator}RM{seperator}"))
+                {
+                    logger.LogInformation($"FixBadReleaseNaming - found bad Tag RM instead of REMASTERED for {title}");
+                    title = title.Replace($"{seperator}RM{seperator}", $"{seperator}REMASTERED{seperator}");
+                }
+            }
+
+            return "";
+        }
+
+        private static string? GetReleaseGroup(string title)
+        {
+            return title.Contains('-') ? title[(title.LastIndexOf('-') + 1)..].Trim() : null;
+        }
+
         private static string ReplaceSeperatorsWithSpace(string title)
         {
             // Replace all known separators with space for normalization
@@ -262,23 +309,23 @@ namespace UmlautAdaptarr.Services
                 return null;
             }
 
-            if (category == "7000" || category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase))
+            if (category == "7000" || category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase) ||category.StartsWith("Bücher", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
+            else if (category == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Filme", StringComparison.OrdinalIgnoreCase))
             {
                 return "movies";
             }
-            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
+            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Serien", StringComparison.OrdinalIgnoreCase))
             {
                 return "tv";
             }
-            else if (category == "3030" || category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase))
+            else if (category == "3030" || category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase) || category.Contains("Hörbuch", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category == "3000" || category.StartsWith("Audio"))
+            else if (category == "3000" || category.StartsWith("Audio", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Musik", StringComparison.OrdinalIgnoreCase))
             {
                 return "audio";
             }

UmlautAdaptarr/UmlautAdaptarr.csproj

@@ -9,10 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.0.0" />
+    <PackageReference Include="IL.FluentValidation.Extensions.Options" Version="11.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="9.0.7" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.7" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    <PackageReference Include="Serilog.AspNetCore" Version="9.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
   </ItemGroup>
 
 </Project>

UmlautAdaptarr/Utilities/ApiKeyMaskingEnricher.cs

@@ -0,0 +1,69 @@
+using System.Collections;
+using System.Text.RegularExpressions;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace UmlautAdaptarr.Utilities;
+
+public class ApiKeyMaskingEnricher : ILogEventEnricher
+{
+    private readonly List<string> apiKeys = new();
+
+    public ApiKeyMaskingEnricher(string appsetting)
+    {
+        ExtractApiKeysFromAppSettings(appsetting);
+        ExtractApiKeysFromEnvironmentVariables();
+        apiKeys = new List<string>(apiKeys.Distinct());
+    }
+
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        //if (logEvent.Properties.TryGetValue("apikey", out var value) && value is ScalarValue scalarValue)
+        //{
+            var maskedValue = new ScalarValue("**Hidden Api Key**");
+            foreach (var apikey in apiKeys) logEvent.AddOrUpdateProperty(new LogEventProperty(apikey, maskedValue));
+       // }
+    }
+
+
+    /// <summary>
+    ///     Scan all Env Variabels for known Apikeys
+    /// </summary>
+    /// <returns>List of all Apikeys</returns>
+    public List<string> ExtractApiKeysFromEnvironmentVariables()
+    {
+        var envVariables = Environment.GetEnvironmentVariables();
+
+        foreach (DictionaryEntry envVariable in envVariables)
+            if (envVariable.Key.ToString()!.Contains("ApiKey"))
+                apiKeys.Add(envVariable.Value.ToString());
+
+        return apiKeys;
+    }
+
+
+    public List<string> ExtractApiKeysFromAppSettings(string filePath)
+    {
+        try
+        {
+            if (File.Exists(filePath))
+            {
+                var fileContent = File.ReadAllText(filePath);
+
+                var pattern = "\"ApiKey\": \"(.*?)\"";
+                var regex = new Regex(pattern);
+                var matches = regex.Matches(fileContent);
+
+                foreach (Match match in matches) apiKeys.Add(match.Groups[1].Value);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+
+        return apiKeys;
+    }
+}
+
+

UmlautAdaptarr/Utilities/Extensions.cs

@@ -99,7 +99,7 @@ namespace UmlautAdaptarr.Utilities
         {
             if (removeUmlauts)
             {
-                return NoSpecialCharactersExceptHypenRegex().Replace(text, "");
+                return NoSpecialCharactersExceptHyphenRegex().Replace(text, "");
             }
             else
             {
@@ -157,9 +157,9 @@ namespace UmlautAdaptarr.Utilities
         }
 
         [GeneratedRegex("[^a-zA-Z0-9 -]+", RegexOptions.Compiled)]
-        private static partial Regex NoSpecialCharactersExceptHypenRegex();
+        private static partial Regex NoSpecialCharactersExceptHyphenRegex();
 
-        [GeneratedRegex("[^a-zA-Z0-9 -öäüßÖÄÜß]+", RegexOptions.Compiled)]
+        [GeneratedRegex("[^a-zA-Z0-9 öäüßÖÄÜß-]+", RegexOptions.Compiled)]
         private static partial Regex NoSpecialCharactersExceptHyphenAndUmlautsRegex();
 
         [GeneratedRegex(@"\s+")]

UmlautAdaptarr/Utilities/Helper.cs

@@ -0,0 +1,56 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UmlautAdaptarr.Utilities;
+
+public static class Helper
+{
+    public static void ShowLogo()
+    {
+        Console.WriteLine(
+            "\r\n _   _           _             _    ___      _             _                  \r\n| | | |         | |           | |  / _ \\    | |           | |                 \r\n| | | |_ __ ___ | | __ _ _   _| |_/ /_\\ \\ __| | __ _ _ __ | |_ __ _ _ __ _ __ \r\n| | | | '_ ` _ \\| |/ _` | | | | __|  _  |/ _` |/ _` | '_ \\| __/ _` | '__| '__|\r\n| |_| | | | | | | | (_| | |_| | |_| | | | (_| | (_| | |_) | || (_| | |  | |   \r\n \\___/|_| |_| |_|_|\\__,_|\\__,_|\\__\\_| |_/\\__,_|\\__,_| .__/ \\__\\__,_|_|  |_|   \r\n                                                    | |                       \r\n                                                    |_|                       \r\n");
+    }
+
+    public static async Task ShowInformation()
+    {
+        Console.WriteLine("--------------------------[IP Leak Test]-----------------------------");
+        var ipInfo = await GetPublicIpAddressInfoAsync();
+
+        if (ipInfo != null)
+        {
+            Console.WriteLine($"Your Public IP Address is '{ipInfo.Ip}'");
+            Console.WriteLine($"Hostname: {ipInfo.Hostname}");
+            Console.WriteLine($"City: {ipInfo.City}");
+            Console.WriteLine($"Region: {ipInfo.Region}");
+            Console.WriteLine($"Country: {ipInfo.Country}");
+            Console.WriteLine($"Provider: {ipInfo.Org}");
+        }
+        else
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("Error: Could not retrieve public IP information.");
+            Console.ResetColor();
+        }
+
+        Console.WriteLine("--------------------------------------------------------------------");
+    }
+
+
+    private static async Task<IpInfo?> GetPublicIpAddressInfoAsync()
+    {
+        using var client = new HttpClient();
+        client.Timeout = TimeSpan.FromSeconds(10);
+
+        try
+        {
+            var response = await client.GetAsync("https://ipinfo.io/json");
+            response.EnsureSuccessStatusCode();
+            var content = await response.Content.ReadAsStringAsync();
+            return JsonSerializer.Deserialize<IpInfo>(content);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+}

UmlautAdaptarr/Utilities/KeyedServiceExtensions.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.ObjectModel;
+
+namespace UmlautAdaptarr.Utilities
+{
+    // License: This code is published under the MIT license.
+    // Source: https://stackoverflow.com/questions/77559201/
+    public static class KeyedServiceExtensions
+    {
+        public static void AllowResolvingKeyedServicesAsDictionary(
+            this IServiceCollection sc)
+        {
+            // KeyedServiceCache caches all the keys of a given type for a
+            // specific service type. By making it a singleton we only have
+            // determine the keys once, which makes resolving the dict very fast.
+            sc.AddSingleton(typeof(KeyedServiceCache<,>));
+
+            // KeyedServiceCache depends on the IServiceCollection to get
+            // the list of keys. That's why we register that here as well, as it
+            // is not registered by default in MS.DI.
+            sc.AddSingleton(sc);
+
+            // Last we make the registration for the dictionary itself, which maps
+            // to our custom type below. This registration must be  transient, as
+            // the containing services could have any lifetime and this registration
+            // should by itself not cause Captive Dependencies.
+            sc.AddTransient(typeof(IDictionary<,>), typeof(KeyedServiceDictionary<,>));
+
+            // For completeness, let's also allow IReadOnlyDictionary to be resolved.
+            sc.AddTransient(
+                typeof(IReadOnlyDictionary<,>), typeof(KeyedServiceDictionary<,>));
+        }
+
+        // We inherit from ReadOnlyDictionary, to disallow consumers from changing
+        // the wrapped dependencies while reusing all its functionality. This way
+        // we don't have to implement IDictionary<T,V> ourselves; too much work.
+        private sealed class KeyedServiceDictionary<TKey, TService>(
+            KeyedServiceCache<TKey, TService> keys, IServiceProvider provider)
+            : ReadOnlyDictionary<TKey, TService>(Create(keys, provider))
+            where TKey : notnull
+            where TService : notnull
+        {
+            private static Dictionary<TKey, TService> Create(
+                KeyedServiceCache<TKey, TService> keys, IServiceProvider provider)
+            {
+                var dict = new Dictionary<TKey, TService>(capacity: keys.Keys.Length);
+
+                foreach (TKey key in keys.Keys)
+                {
+                    dict[key] = provider.GetRequiredKeyedService<TService>(key);
+                }
+
+                return dict;
+            }
+        }
+
+        private sealed class KeyedServiceCache<TKey, TService>(IServiceCollection sc)
+            where TKey : notnull
+            where TService : notnull
+        {
+            // Once this class is resolved, all registrations are guaranteed to be
+            // made, so we can, at that point, safely iterate the collection to get
+            // the keys for the service type.
+            public TKey[] Keys { get; } = (
+                from service in sc
+                where service.ServiceKey != null
+                where service.ServiceKey!.GetType() == typeof(TKey)
+                where service.ServiceType == typeof(TService)
+                select (TKey)service.ServiceKey!)
+                .ToArray();
+        }
+
+    }
+}

UmlautAdaptarr/Utilities/ProxyExtension.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Net;
-using UmlautAdaptarr.Options;
-
-namespace UmlautAdaptarr.Utilities
-{
-    /// <summary>
-    /// Extension methods for configuring proxies.
-    /// </summary>
-    public static class ProxyExtension
-    {
-        /// <summary>
-        /// Logger instance for logging proxy configurations.
-        /// </summary>
-        private static ILogger Logger = GlobalStaticLogger.Logger;
-
-        /// <summary>
-        /// Configures the proxy settings for the provided HttpClientHandler instance.
-        /// </summary>
-        /// <param name="handler">The HttpClientHandler instance to configure.</param>
-        /// <param name="proxyOptions">ProxyOptions options to be used for configuration.</param>
-        /// <returns>The configured HttpClientHandler instance.</returns>
-        public static HttpClientHandler ConfigureProxy(this HttpClientHandler handler, ProxyOptions? proxyOptions)
-        {
-            try
-            {
-                if (proxyOptions != null && proxyOptions.Enabled)
-                {
-                    Logger.LogInformation("Use Proxy {0}", proxyOptions.Address);
-                    handler.UseProxy = true;
-                    handler.Proxy = new WebProxy(proxyOptions.Address, proxyOptions.BypassOnLocal);
-
-                    if (!string.IsNullOrEmpty(proxyOptions.Username) && !string.IsNullOrEmpty(proxyOptions.Password))
-                    {
-                        Logger.LogInformation("Use Proxy Credentials from User {0}", proxyOptions.Username);
-                        handler.DefaultProxyCredentials =
-                            new NetworkCredential(proxyOptions.Username, proxyOptions.Password);
-                    }
-                }
-                else
-                {
-                    Logger.LogDebug("No proxy was set");
-                }
-            }
-            catch (Exception ex)
-            {
-                Logger.LogError(ex, "Error occurred while configuring proxy, no Proxy will be used!");
-            }
-
-            return handler;
-        }
-    }
-}

UmlautAdaptarr/Utilities/ServicesExtensions.cs

@@ -1,92 +1,191 @@
-using UmlautAdaptarr.Options;
-using UmlautAdaptarr.Options.ArrOptions;
+using FluentValidation;
+using System.Linq.Expressions;
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Providers;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Validator;
 
-namespace UmlautAdaptarr.Utilities
+namespace UmlautAdaptarr.Utilities;
+
+/// <summary>
+///     Extension methods for configuring services related to ARR Applications
+/// </summary>
+public static class ServicesExtensions
 {
+
     /// <summary>
-    /// Extension methods for configuring services related to ARR Applications
+    /// Logger instance for logging proxy configurations.
     /// </summary>
-    public static class ServicesExtensions
+    private static ILogger Logger = GlobalStaticLogger.Logger;
+
+    /// <summary>
+    ///     Adds a service with specified options and service to the service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type for the service.</typeparam>
+    /// <typeparam name="TService">The service type for the service.</typeparam>
+    /// <typeparam name="TInterface">The Interface of the service type</typeparam>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <param name="sectionName">The name of the configuration section containing service options.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    private static async Task<WebApplicationBuilder> AddServicesWithOptions<TOptions, TService, TInterface>(
+        this WebApplicationBuilder builder, string sectionName)
+        where TOptions : class, new()
+        where TService : class, TInterface
+        where TInterface : class
     {
-
-        /// <summary>
-        /// Adds a service with specified options and service to the service collection.
-        /// </summary>
-        /// <typeparam name="TOptions">The options type for the service.</typeparam>
-        /// <typeparam name="TService">The service type for the service.</typeparam>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <param name="sectionName">The name of the configuration section containing service options.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder, string sectionName)
-            where TOptions : class
-            where TService : class
+        try
         {
-            if (builder.Services == null)
+            if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+
+            var singleInstance = builder.Configuration.GetSection(sectionName).Get<TOptions>();
+
+            var singleHost = (string?)typeof(TOptions).GetProperty("Host")?.GetValue(singleInstance, null);
+
+            // If we have no Single Instance, we try to parse for an Array
+            var optionsArray = singleHost == null
+                ? builder.Configuration.GetSection(sectionName).Get<TOptions[]>()
+                :
+                [
+                    singleInstance
+                ];
+
+            if (optionsArray == null || !optionsArray.Any())
+                throw new InvalidOperationException(
+                    $"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
+
+            foreach (var option in optionsArray)
             {
-                throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+              GlobalInstanceOptionsValidator validator = new();
+
+              var results = await validator.ValidateAsync(option as GlobalInstanceOptions);
+
+                if (!results.IsValid)
+                {
+                    foreach (var failure in results.Errors)
+                    {
+                        Console.WriteLine(($"Property {failure.PropertyName } failed validation. Error was: {failure.ErrorMessage}"));
+                    }
+
+                    throw new Exception("Please fix cour environment variables and then Start UmlautAdaptarr again");
+                }
+
+                var instanceState = (bool)(typeof(TOptions).GetProperty("Enabled")?.GetValue(option, null) ?? false);
+
+                // We only want to create instances that are enabled in the Configs
+                if (instanceState)
+                {
+                    // User can give the Instance a readable Name otherwise we use the Host Property
+                    var instanceName = (string)(typeof(TOptions).GetProperty("Name")?.GetValue(option, null) ??
+                                                (string)typeof(TOptions).GetProperty("Host")?.GetValue(option, null)!);
+
+                    // Dark Magic , we don't know the Property's of TOptions , and we won't cast them for each Options
+                    // Todo eventuell schönere Lösung finden
+                    var paraexpression = Expression.Parameter(Type.GetType(option.GetType().FullName), "x");
+
+                    foreach (var prop in option.GetType().GetProperties())
+                    {
+                        var val = Expression.Constant(prop.GetValue(option));
+                        var memberexpression = Expression.PropertyOrField(paraexpression, prop.Name);
+
+                        if (prop.PropertyType == typeof(int) || prop.PropertyType == typeof(string) || prop.PropertyType == typeof(bool))
+                        {
+                            var assign = Expression.Assign(memberexpression, Expression.Convert(val, prop.PropertyType));
+                            var exp = Expression.Lambda<Action<TOptions>>(assign, paraexpression);
+                            builder.Services.Configure(instanceName, exp.Compile());
+                        }
+                        else
+                        {
+                            Logger.LogWarning(prop.PropertyType + "No Support");
+                        }
+                    }
+
+                    builder.Services.AddKeyedSingleton<TInterface, TService>(instanceName);
+                }
             }
 
-            var options = builder.Configuration.GetSection(sectionName).Get<TOptions>();
-            if (options == null)
-            {
-                throw new InvalidOperationException($"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
-            }
-
-            builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
-            builder.Services.AddSingleton<TService>();
             return builder;
         }
-
-        /// <summary>
-        /// Adds support for Sonarr with default options and client.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddSonarrSupport(this WebApplicationBuilder builder)
+        catch (Exception ex)
         {
-            return builder.AddServiceWithOptions<SonarrInstanceOptions, SonarrClient>("Sonarr");
+            Console.WriteLine($"Error in AddServicesWithOptions: {ex.Message}");
+            throw;
         }
 
-        /// <summary>
-        /// Adds support for Lidarr with default options and client.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddLidarrSupport(this WebApplicationBuilder builder)
-        {
-            return builder.AddServiceWithOptions<LidarrInstanceOptions, LidarrClient>("Lidarr");
-        }
-
-        /// <summary>
-        /// Adds support for Readarr with default options and client.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddReadarrSupport(this WebApplicationBuilder builder)
-        {
-            return builder.AddServiceWithOptions<ReadarrInstanceOptions, ReadarrClient>("Readarr");
-        }
-
-        /// <summary>
-        /// Adds a title lookup service to the service collection.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddTitleLookupService(this WebApplicationBuilder builder)
-        {
-            return builder.AddServiceWithOptions<GlobalOptions, TitleApiService>("Settings");
-        }
-
-        /// <summary>
-        /// Adds a proxy request service to the service collection.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddProxyRequestService(this WebApplicationBuilder builder)
-        {
-            return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
-        }
     }
-}
+
+    /// <summary>
+    ///     Adds a service with specified options and service to the service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type for the service.</typeparam>
+    /// <typeparam name="TService">The service type for the service.</typeparam>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <param name="sectionName">The name of the configuration section containing service options.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder,
+        string sectionName)
+        where TOptions : class
+        where TService : class
+    {
+        if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+
+        var options = builder.Configuration.GetSection(sectionName).Get<TOptions>() ?? throw new InvalidOperationException(
+                $"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
+        builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
+        builder.Services.AddSingleton<TService>();
+
+        return builder;
+    }
+
+    /// <summary>
+    ///     Adds support for Sonarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static Task<WebApplicationBuilder> AddSonarrSupport(this WebApplicationBuilder builder)
+    {
+        //  builder.Serviceses.AddSingleton<IOptionsMonitoSonarrInstanceOptionsns>, OptionsMonitoSonarrInstanceOptionsns>>();
+        return builder.AddServicesWithOptions<SonarrInstanceOptions, SonarrClient, IArrApplication>("Sonarr");
+    }
+
+    /// <summary>
+    ///     Adds support for Lidarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static Task<WebApplicationBuilder> AddLidarrSupport(this WebApplicationBuilder builder)
+    {
+        return builder.AddServicesWithOptions<LidarrInstanceOptions, LidarrClient, IArrApplication>("Lidarr");
+    }
+
+    /// <summary>
+    ///     Adds support for Readarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static Task<WebApplicationBuilder> AddReadarrSupport(this WebApplicationBuilder builder)
+    {
+        return builder.AddServicesWithOptions<ReadarrInstanceOptions, ReadarrClient, IArrApplication>("Readarr");
+    }
+
+    /// <summary>
+    ///     Adds a title lookup service to the service collection.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddTitleLookupService(this WebApplicationBuilder builder)
+    {
+        return builder.AddServiceWithOptions<GlobalOptions, TitleApiService>("Settings");
+    }
+
+    /// <summary>
+    ///     Adds a proxy request service to the service collection.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddProxyRequestService(this WebApplicationBuilder builder)
+    {
+        return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
+    }
+}

UmlautAdaptarr/Utilities/UrlUtilities.cs

@@ -5,7 +5,8 @@ namespace UmlautAdaptarr.Utilities
 {
     public partial class UrlUtilities
     {
-        [GeneratedRegex(@"^(?!http:\/\/)([a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+.*)$")]
+        [GeneratedRegex(@"^(?!http:\/\/)([a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+(:\d+)?(/.*)?)$")]
+
         private static partial Regex UrlMatchingRegex();
         public static bool IsValidDomain(string domain)
         {

UmlautAdaptarr/Validator/GlobalInstanceOptionsValidator.cs

@@ -0,0 +1,71 @@
+using FluentValidation;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+namespace UmlautAdaptarr.Validator;
+
+public class GlobalInstanceOptionsValidator : AbstractValidator<GlobalInstanceOptions>
+{
+    private readonly static HttpClient httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(3)
+    };
+
+    public GlobalInstanceOptionsValidator()
+    {
+        RuleFor(x => x.Enabled).NotNull();
+
+        When(x => x.Enabled, () =>
+        {
+            RuleFor(x => x.Host)
+                .NotEmpty().WithMessage("Host is required when Enabled is true.")
+                .Must(BeAValidUrl).WithMessage("Host/Url must start with http:// or https:// and be a valid address.");
+
+            RuleFor(x => x.ApiKey)
+                .NotEmpty().WithMessage("ApiKey is required when Enabled is true.");
+
+            RuleFor(x => x)
+                .MustAsync(BeReachable)
+                .WithMessage("Host/Url is not reachable. Please check your Host or your UmlautAdaptrr Settings");
+        });
+    }
+
+    private bool BeAValidUrl(string url)
+    {
+        return Uri.TryCreate(url, UriKind.Absolute, out var uriResult)
+               && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
+    }
+
+    private static async Task<bool> BeReachable(GlobalInstanceOptions opts, CancellationToken cancellationToken)
+    {
+        var endTime = DateTime.Now.AddMinutes(3);
+        var reachable = false;
+        var url = $"{opts.Host}/api?apikey={opts.ApiKey}";
+
+        while (DateTime.Now < endTime)
+        {
+            try
+            {
+                using var response = await httpClient.GetAsync(url, cancellationToken);
+                if (response.IsSuccessStatusCode)
+                {
+                    reachable = true;
+                    break;
+                }
+                else
+                {
+                    Console.WriteLine($"Reachable check got unexpected status code {response.StatusCode}.");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+
+            // Wait for 15 seconds for next try
+            Console.WriteLine($"The URL \"{opts.Host}/api?apikey=[REDACTED]\" is not reachable. Next attempt in 15 seconds...");
+            Thread.Sleep(15000);
+        }
+
+        return reachable;
+    }
+}

UmlautAdaptarr/appsettings.json

@@ -20,22 +20,42 @@
   // Settings__UmlautAdaptarrApiHost=https://umlautadaptarr.pcjones.de/api/v1
   "Settings": {
     "UserAgent": "UmlautAdaptarr/1.0",
-    "UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1"
+    "UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1",
+    "IndexerRequestsCacheDurationInMinutes": 12,
+    "ApiKey": null,
+    "ProxyPort": 5006,
+    "EnableChangedTitleCache": false // Set to true if you are using crowdnfo.net post processing script
   },
-  "Sonarr": {
-    // Docker Environment Variables:
-    // - Sonarr__Enabled: true (set to false to disable)
-    // - Sonarr__Host: your_sonarr_host_url
-    // - Sonarr__ApiKey: your_sonarr_api_key
-    "Enabled": false,
-    "Host": "your_sonarr_host_url",
-    "ApiKey": "your_sonarr_api_key"
-  },
-  "Lidarr": {
-    // Docker Environment Variables:
-    // - Lidarr__Enabled: true (set to false to disable)
-    // - Lidarr__Host: your_lidarr_host_url
-    // - Lidarr__ApiKey: your_lidarr_api_key
+  "Sonarr": [
+    {
+      // Docker Environment Variables:
+      // - Sonarr__0__Enabled: true (set to false to disable)
+      // - Sonarr__0__Name: Name of the Instance (Optional)
+      // - Sonarr__0__Host: your_sonarr_host_url
+      // - Sonarr__0__ApiKey: your_sonarr_api_key
+      "Enabled": false,
+      "Name": "Sonarr",
+      "Host": "your_sonarr_host_url",
+      "ApiKey": "your_sonarr_api_key"
+    },
+    {
+      // Docker Environment Variables:
+      // - Sonarr__1__Enabled: true (set to false to disable)
+      // - Sonarr__1__Name: Name of the Instance (Optional)
+      // - Sonarr__1__Host: your_sonarr_host_url
+      // - Sonarr__1__ApiKey: your_sonarr_api_key
+      "Enabled": false,
+      "Name": "Sonarr 4k",
+      "Host": "your_other_sonarr_host_url",
+      "ApiKey": "your_other_sonarr_api_key"
+    }
+  ],
+  "Lidarr":
+  // Docker Environment Variables:
+  // - Lidarr__Enabled: true (set to false to disable)
+  // - Lidarr__Host: your_lidarr_host_url
+  // - Lidarr__ApiKey: your_lidarr_api_key
+  {
     "Enabled": false,
     "Host": "your_lidarr_host_url",
     "ApiKey": "your_lidarr_api_key"
@@ -49,18 +69,9 @@
     "Host": "your_readarr_host_url",
     "ApiKey": "your_readarr_api_key"
   },
-
-  // Docker Environment Variables:
-  // - Proxy__Enabled: true (set to false to disable)
-  // - Proxy__Address: http://yourproxyaddress:port
-  // - Proxy__Username: your_proxy_username
-  // - Proxy__Password: your_proxy_password
-  // - Proxy__BypassOnLocal: true (set to false to not bypass local IP addresses)
-  "Proxy": {
-    "Enabled": false,
-    "Address": "http://yourproxyaddress:port",
-    "Username": "your_proxy_username",
-    "Password": "your_proxy_password",
-    "BypassOnLocal": true
+  "IpLeakTest": {
+    // Docker Environment Variables:
+    // - IpLeakTest__Enabled: false (set to true to enable)
+    "Enabled": false
   }
 }

build_linux.bat

@@ -0,0 +1,4 @@
+@echo off
+dotnet publish -c Release -r linux-x64 --self-contained
+'dotnet publish -c Release -r linux-x64 --self-contained -p:PublishSingleFile=true -p:IncludeAllContentForSelfExtract=true
+pause

docker-compose.yml

@@ -6,6 +6,9 @@ services:
     build: https://github.com/PCJones/UmlautAdaptarr.git#master
     image: umlautadaptarr
     restart: unless-stopped
+    ports:
+      - "5005:5005" # can be removed if you use the recommended prowlarr+proxy configuration 
+      - "5006:5006" # can be removed if you use the alternative, non-proxy configuration
     environment:
       - TZ=Europe/Berlin
       - SONARR__ENABLED=false
@@ -20,8 +23,20 @@ services:
       - LIDARR__ENABLED=false
       - LIDARR__HOST=http://localhost:8686
       - LIDARR__APIKEY=APIKEY
-      #- Proxy__Enabled: false
-      #- Proxy__Address: http://yourproxyaddress:port
-      #- Proxy__Username: your_proxy_username
-      #- Proxy__Password: your_proxy_password
-      #- Proxy__BypassOnLocal: true (set to false to not bypass local IP addresses)
+      ### example for multiple instances of same type
+      #- SONARR__0__NAME=NAME 1 (optional)
+      #- SONARR__0__ENABLED=false
+      #- SONARR__0__HOST=http://localhost:8989
+      #- SONARR__0__APIKEY=APIKEY
+      #- SONARR__1__NAME=NAME 2 (optional)
+      #- SONARR__1__ENABLED=false
+      #- SONARR__1__HOST=http://localhost:8989
+      #- SONARR__1__APIKEY=APIKEY
+
+      ### Advanced options (with default values))
+      #- IpLeakTest__Enabled=false
+      #- SETTINGS__IndexerRequestsCacheDurationInMinutes=12 # How long to cache indexer requests for. Default is 12 minutes.
+      #- SETTINGS__ApiKey= # API key for requests to the UmlautAdaptarr. Optional, probably only needed for seedboxes.
+      #- SETTINGS__ProxyPort=5006 # Proxy port for the internal UmlautAdaptarr proxy used for Prowlarr.
+      #- Kestrel__Endpoints__Http__Url=http://[::]:5005 # HTTP port for the UmlautAdaptarr
+

run_on_seedbox.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Download linux binary from https://github.com/PCJones/UmlautAdaptarr/releases
+
+# script by schumi4 - THX!
+
+#seedbox fix
+export DOTNET_GCHeapHardLimit=20000000
+
+# Basic Configuration
+export TZ=Europe/Berlin
+
+# Sonarr Configuration
+export SONARR__ENABLED=true
+export SONARR__HOST=https://name.server.usbx.me/sonarr/
+export SONARR__APIKEY=APIKEY
+
+# Radarr Configuration
+export RADARR__ENABLED=false
+export RADARR__HOST=http://localhost:7878
+export RADARR__APIKEY=APIKEY
+
+# Readarr Configuration
+export READARR__ENABLED=false
+export READARR__HOST=http://localhost:8787
+export READARR__APIKEY=APIKEY
+
+# Lidarr Configuration
+export LIDARR__ENABLED=false
+export LIDARR__HOST=http://localhost:8686
+export LIDARR__APIKEY=APIKEY
+
+# Multiple Sonarr Instances (commented out by default)
+#export SONARR__0__NAME="NAME 1"
+#export SONARR__0__ENABLED=false
+#export SONARR__0__HOST=http://localhost:8989
+#export SONARR__0__APIKEY=APIKEY
+#export SONARR__1__NAME="NAME 2"
+#export SONARR__1__ENABLED=false
+#export SONARR__1__HOST=http://localhost:8989
+#export SONARR__1__APIKEY=APIKEY
+
+# Advanced Options
+#export IpLeakTest__Enabled=false
+#export SETTINGS__IndexerRequestsCacheDurationInMinutes=12
+export SETTINGS__ApiKey="apikey" # Change to something unique! Then in Prowlarr, in the proxy settings set any username and use this ApiKey as password.
+export SETTINGS__ProxyPort=1234 # Port for Proxy
+export Kestrel__Endpoints__Http__Url="http://[::]:1235" # Port for UmlautAdaptarr API
+
+chmod +x ./publish/UmlautAdaptarr
+
+./publish/UmlautAdaptarr