Remove proxy environment variables from compose

Update README.md

Dockerfile

@@ -1,13 +1,10 @@
-# Use the official Microsoft .NET Core SDK image as the build environment
 FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
 WORKDIR /app
 
-# Copy everything and build the project
 COPY . ./
 RUN dotnet restore
 RUN dotnet publish -c Release -o out
 
-# Generate the runtime image
 FROM mcr.microsoft.com/dotnet/aspnet:8.0
 WORKDIR /app
 COPY --from=build-env /app/out .

README.md

@@ -1,25 +1,134 @@
 # UmlautAdaptarr
 
-## Testversion kommt in wenigen Tagen
+## English description coming soon
 
-### Kleine Preview
+## Beschreibung
+Wer möchte kann den UmlautAdaptarr jetzt gerne testen! Über Feedback würde ich mich sehr freuen!
+
+Es sollte mit allen *arrs funktionieren, hat aber nur bei Sonarr, Readarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
+
+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)
+- 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?
+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 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 12 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
+| 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       |
+| Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
+| Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
+| Wünsche?                                                          | Vorschläge?   |
+
+
+## Installation
+Momentan ist Docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. Eine Unraid-App gibt es auch, einfach nach `umlautadaptarr` suchen.
+
+[Link zum Docker Image](https://hub.docker.com/r/pcjones/umlautadaptarr)
+
+Nicht benötigte Umgebungsvariablen, z.B. wenn Readarr oder Lidarr nicht benötigt 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) In Prowlarr: Settings>Indexers bzw. Einstellungen>Indexer öffnen
+2) 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.
+3) Gehe zur Indexer-Übersichtsseite
+4) 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).
+5) 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.
+
+Dafür musst du einfach nur alle Indexer, bei denen der UmlautAdaptarr greifen soll, bearbeiten:
+
+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 ;)
 
-**Vorher:**  
-![Vorherige Suche ohne deutsche Titel](https://i.imgur.com/7pfRzgH.png)  
-Release wird zwar gefunden, kann aber kann nicht zu geordnet werden.
+**Vorher:** Release wird zwar gefunden, kann aber kann nicht zu geordnet werden.
+![Vorherige Suche ohne deutsche Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/1fce2909-a36c-4f1b-8497-85903357fee3)
 
-**Jetzt:**  
-![Jetzige Suche mit deutschen Titeln](https://i.imgur.com/k55YIN9.png)  
-2-3 weitere Releases werden gefunden, außerdem meckert Sonarr nicht mehr über den Namen und würde es bei einer automatischen Suche ohne Probleme importieren.
+**Jetzt:** 2-3 weitere Releases werden gefunden, außerdem meckert Sonarr nicht mehr über den Namen und würde es bei einer automatischen Suche ohne Probleme importieren.
+![Jetzige Suche mit deutschen Titeln](https://github.com/PCJones/UmlautAdaptarr/assets/377223/0edf43ba-2beb-4f22-aaf4-30f9a619dbd6)
 
-**Vorher:**  
-![Vorherige Suche, englische Titel](https://i.imgur.com/pbRlOeX.png)  
-Es werden nur Releases mit dem englischen Titel der Serie gefunden
 
-**Jetzt:**  
-![Jetzige Suche, deutsche und englische Titel](https://i.imgur.com/eeq0Voj.png)  
-Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
+**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)
 
-PS:
-Das Problem, dass Prowlarr mit SceneNZBs nicht richtig funktioniert ist damit auch behoben :D
+**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)
+
+
+**Vorher:** Die deutsche Produktion `Alone - Überlebe die Wildnis` hat auf [TheTVDB](https://thetvdb.com/series/alone-uberlebe-die-wildnis) den Englischen Namen `Alone Germany`.
+
+Sonarr erwartet immer den Englischen Namen, der hier natürlich nicht gegeben ist.
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/62158f77-ecc2-4747-af85-4b8f94f51ab4)
+
+**Jetzt:** UmlautAdaptarr hat die Releases in `Alone Germany` umbenannt und Sonarr hat keine Probleme mehr
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/57539ffc-b8a6-4255-a7f8-03079c10b1e8)
+
+**Vorher:** Hier wird der komplette deutsche Titel im Release angegeben (also mit `- Das Lied von Eis und Feuer`) - glücklicherweise stellt uns [TheTVDB](https://thetvdb.com/series/game-of-thrones) aber diesen längeren Titel als Alias zur Verfügung - nur nutzt Sonarr diese Informationen (bisher) einfach nicht.
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/8f3297bd-ebe4-42de-b4e6-952882c8b902)
+
+**Jetzt:** UmlautAdapatarr erkennt alle auf TheTVDB angegebenen Aliase und benennt das Release in den Englischen Titel um
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/52f0caf5-6e9d-442e-9018-ba29f954a890)
+
+## 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)
+
+## Spenden
+Über eine Spende freue ich mich natürlich immer :D
+PayPal: https://paypal.me/pcjones1
+
+Für andere Spendenmöglichkeiten gerne auf Discord oder Telegram melden - danke!
+
+### Licenses & Metadata source
+- TV Metadata source: https://thetvdb.com
+- Movie Metadata source: https://themoviedb.org
+- Licenses: TODO

UmlautAdaptarr/Controllers/CapsController.cs

@@ -6,9 +6,9 @@ using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Controllers
 {
-    public class CapsController(ProxyService proxyService) : ControllerBase
+    public class CapsController(ProxyRequestService proxyRequestService) : ControllerBase
     {
-        private readonly ProxyService _proxyService = proxyService;
+        private readonly ProxyRequestService _proxyRequestService = proxyRequestService;
 
         [HttpGet]
         public async Task<IActionResult> Caps([FromRoute] string options, [FromRoute] string domain, [FromQuery] string? apikey)
@@ -20,7 +20,7 @@ namespace UmlautAdaptarr.Controllers
 
             var requestUrl = UrlUtilities.BuildUrl(domain, "caps", apikey);
 
-            var responseMessage = await _proxyService.ProxyRequestAsync(HttpContext, requestUrl);
+            var responseMessage = await _proxyRequestService.ProxyRequestAsync(HttpContext, requestUrl);
 
             var content = await responseMessage.Content.ReadAsStringAsync();
             var encoding = responseMessage.Content.Headers.ContentType?.CharSet != null ?

UmlautAdaptarr/Controllers/SearchController.cs

@@ -1,16 +1,15 @@
 using Microsoft.AspNetCore.Mvc;
-using Newtonsoft.Json.Linq;
 using System.Text;
-using System.Xml.Linq;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Controllers
 {
-    public abstract class SearchControllerBase(ProxyService proxyService, TitleMatchingService titleMatchingService) : ControllerBase
+    public abstract class SearchControllerBase(ProxyRequestService proxyRequestService, TitleMatchingService titleMatchingService) : ControllerBase
     {
-        private readonly bool TODO_FORCE_TEXT_SEARCH_ORIGINAL_TITLE = false;
+        // 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,
                                                        string domain,
@@ -24,7 +23,7 @@ namespace UmlautAdaptarr.Controllers
                     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;
@@ -34,7 +33,7 @@ namespace UmlautAdaptarr.Controllers
                 // Rename titles in the single search content
                 if (!string.IsNullOrEmpty(initialSearchResult?.Content))
                 {
-                    inititalProcessedContent = ProcessContent(initialSearchResult.Content, searchItem?.TitleMatchVariations, searchItem?.ExpectedTitle);
+                    inititalProcessedContent = ProcessContent(initialSearchResult.Content, searchItem);
                 }
 
                 var additionalTextSearch = searchItem != null
@@ -54,7 +53,7 @@ namespace UmlautAdaptarr.Controllers
 
                     var titleSearchVariations = new List<string>(searchItem?.TitleSearchVariations);
 
-                    string searchQuery = string.Empty;
+                    var searchQuery = string.Empty;
                     if (queryParameters.TryGetValue("q", out string? q))
                     {
                         searchQuery = q ?? string.Empty;
@@ -76,7 +75,7 @@ namespace UmlautAdaptarr.Controllers
                     }
 
                     // Handle multiple search requests based on German title variations
-                    var aggregatedResult = await AggregateSearchResults(domain, queryParameters, titleSearchVariations, searchItem.TitleMatchVariations, expectedTitle);
+                    var aggregatedResult = await AggregateSearchResults(domain, queryParameters, titleSearchVariations, searchItem);
                     aggregatedResult.AggregateItems(inititalProcessedContent);
 
                     return Content(aggregatedResult.Content, aggregatedResult.ContentType, aggregatedResult.ContentEncoding);
@@ -97,7 +96,7 @@ namespace UmlautAdaptarr.Controllers
         private async Task<IActionResult> PerformSingleSearchRequest(string domain, IDictionary<string, string> queryParameters)
         {
             var requestUrl = UrlUtilities.BuildUrl(domain, queryParameters);
-            var responseMessage = await proxyService.ProxyRequestAsync(HttpContext, requestUrl);
+            var responseMessage = await proxyRequestService.ProxyRequestAsync(HttpContext, requestUrl);
             var content = await responseMessage.Content.ReadAsStringAsync();
 
             var encoding = responseMessage.Content.Headers.ContentType?.CharSet != null ?
@@ -109,17 +108,17 @@ namespace UmlautAdaptarr.Controllers
         }
 
 
-        private string ProcessContent(string content, string[]? titleMatchVariations = null, string? expectedTitle = null)
+        private string ProcessContent(string content, SearchItem? searchItem)
         {
-            return titleMatchingService.RenameTitlesInContent(content, titleMatchVariations, expectedTitle);
+            return titleMatchingService.RenameTitlesInContent(content, searchItem);
         }
 
         public async Task<AggregatedSearchResult> AggregateSearchResults(
             string domain,
             IDictionary<string, string> queryParameters,
             IEnumerable<string> titleSearchVariations,
-            string[] titleMatchVariations,
-            string expectedTitle)
+            SearchItem? searchItem
+            )
         {
             string defaultContentType = "application/xml";
             Encoding defaultEncoding = Encoding.UTF8;
@@ -131,7 +130,7 @@ namespace UmlautAdaptarr.Controllers
             {
                 queryParameters["q"] = titleVariation; // Replace the "q" parameter for each variation
                 var requestUrl = UrlUtilities.BuildUrl(domain, queryParameters);
-                var responseMessage = await proxyService.ProxyRequestAsync(HttpContext, requestUrl);
+                var responseMessage = await proxyRequestService.ProxyRequestAsync(HttpContext, requestUrl);
                 var content = await responseMessage.Content.ReadAsStringAsync();
 
                 // Only update encoding from the first response
@@ -143,7 +142,7 @@ namespace UmlautAdaptarr.Controllers
                 }
 
                 // Process and rename titles in the content
-                content = ProcessContent(content, titleMatchVariations, expectedTitle);
+                content = ProcessContent(content, searchItem);
 
                 // Aggregate the items into a single document
                 aggregatedResult.AggregateItems(content);
@@ -153,10 +152,13 @@ namespace UmlautAdaptarr.Controllers
         }
     }
 
-    public class SearchController(ProxyService proxyService,
+    public class SearchController(ProxyRequestService proxyRequestService,
                                   TitleMatchingService titleMatchingService,
-                                  SearchItemLookupService searchItemLookupService) : SearchControllerBase(proxyService, titleMatchingService)
+                                  SearchItemLookupService searchItemLookupService) : SearchControllerBase(proxyRequestService, titleMatchingService)
     {
+        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)
         {
@@ -169,10 +171,34 @@ namespace UmlautAdaptarr.Controllers
         [HttpGet]
         public async Task<IActionResult> GenericSearch([FromRoute] string options, [FromRoute] string domain)
         {
-            var queryParameters = HttpContext.Request.Query.ToDictionary(
+
+        var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+
+            SearchItem? searchItem = null;
+
+            if (queryParameters.TryGetValue("q", out string? title) && !string.IsNullOrEmpty(title))
+            {
+                if (queryParameters.TryGetValue("cat", out string? categories) && !string.IsNullOrEmpty(categories))
+                {
+                    // look for (audio-)book
+                    if (categories.Split(',').Any(category => READARR_CATEGORY_IDS.Contains(category)))
+                    {
+                        var mediaType = "book";
+                        searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.GetReadarrTitleForExternalId());
+                    }
+
+                    // look for audio (lidarr)
+                    if (searchItem == null && categories.Split(',').Any(category => LIDARR_CATEGORY_IDS.Contains(category)))
+                    {
+                        var mediaType = "audio";
+                        searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.GetLidarrTitleForExternalId());
+                    }
+                }
+            }
+
+            return await BaseSearch(options, domain, queryParameters, searchItem);
         }
 
         [HttpGet]
@@ -192,7 +218,7 @@ namespace UmlautAdaptarr.Controllers
                  q => string.Join(",", q.Value));
 
             SearchItem? searchItem = null;
-            string mediaType = "tv";
+            var mediaType = "tv";
 
             if (queryParameters.TryGetValue("tvdbid", out string? tvdbId) && !string.IsNullOrEmpty(tvdbId))
             {

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

@@ -1,4 +1,5 @@
-using System.Text.RegularExpressions;
+using Microsoft.Extensions.Logging.Abstractions;
+using System.Text.RegularExpressions;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Models
@@ -8,23 +9,70 @@ namespace UmlautAdaptarr.Models
         public int ArrId { get; set; }
         public string ExternalId { get; set; }
         public string Title { get; set; }
-        public bool HasGermanUmlaut => Title?.HasGermanUmlauts() ?? false;
+        public bool HasUmlaut => Title?.HasUmlauts() ?? false;
         public string ExpectedTitle { get; set; }
+        public string? ExpectedAuthor { get; set; }
+        // TODO rename GermanTitle into Foreign or LocalTitle?
         public string? GermanTitle { get; set; }
         public string[] TitleSearchVariations { get; set; }
         public string[] TitleMatchVariations { get; set; }
+        public string[] AuthorMatchVariations { get; set; }
         public string MediaType { get; set; }
         // TODO public MediaType instead of string
 
-        public SearchItem(int arrId, string externalId, string title, string expectedTitle, string? germanTitle, string mediaType, string[]? aliases)
+        public SearchItem(
+            int arrId,
+            string externalId,
+            string title,
+            string expectedTitle,
+            string? germanTitle,
+            string mediaType,
+            string[]? aliases,
+            string? expectedAuthor = null)
         {
             ArrId = arrId;
             ExternalId = externalId;
             Title = title;
             ExpectedTitle = expectedTitle;
+            ExpectedAuthor = expectedAuthor;
             GermanTitle = germanTitle;
-            TitleSearchVariations = GenerateTitleVariations(germanTitle).ToArray();
             MediaType = mediaType;
+            if ((mediaType == "audio" || mediaType == "book") && expectedAuthor != null)
+            {
+                GenerateVariationsForBooksAndAudio(expectedTitle, mediaType, expectedAuthor);
+            }
+            else
+            {
+                // if mediatype is movie/tv and the Expected Title ends with a year but the german title doesn't then append the year to the german title and to aliases
+                // example: https://thetvdb.com/series/385925-avatar-the-last-airbender -> german Title is without 2024
+                var yearAtEndOfTitleMatch = YearAtEndOfTitleRegex().Match(expectedTitle);
+                if (yearAtEndOfTitleMatch.Success)
+                {
+                    string year = yearAtEndOfTitleMatch.Value[1..^1];
+                    if (GermanTitle != null && !GermanTitle.Contains(year))
+                    {
+                        GermanTitle = $"{germanTitle} {year}";
+                    }
+
+                    if (aliases != null)
+                    {
+                        for (int i = 0; i < aliases.Length; i++)
+                        {
+                            if (!aliases[i].Contains(year))
+                            {
+                                aliases[i] = $"{aliases[i]} {year}";
+                            }
+                        }
+                    }
+                }
+
+                GenerateVariationsForTV(GermanTitle, mediaType, aliases);
+            }
+        }
+
+        private void GenerateVariationsForTV(string? germanTitle, string mediaType, string[]? aliases)
+        {
+            TitleSearchVariations = GenerateVariations(germanTitle, mediaType).ToArray();
 
             var allTitleVariations = new List<string>(TitleSearchVariations);
 
@@ -34,20 +82,103 @@ namespace UmlautAdaptarr.Models
             {
                 foreach (var alias in aliases)
                 {
-                    allTitleVariations.AddRange(GenerateTitleVariations(alias));
+                    allTitleVariations.AddRange(GenerateVariations(alias, mediaType));
+
+                    // If title contains ":" also match for "-"
+                    if (alias.Contains(':'))
+                    {
+                        allTitleVariations.Add(alias.Replace(":", " -"));
+                    }
                 }
             }
 
-            TitleMatchVariations = allTitleVariations.Distinct().ToArray();
+            AuthorMatchVariations = [];
+
+            // if a german title ends with (DE) also add a search string that replaces (DE) with GERMAN
+            // also add a matching title without (DE)
+            if (germanTitle?.EndsWith("(DE)") ?? false)
+            {
+                TitleSearchVariations = [.. TitleSearchVariations,
+                    ..
+                    GenerateVariations(
+                        germanTitle.Replace("(DE)", " GERMAN").RemoveExtraWhitespaces(),
+                    mediaType)];
+
+                allTitleVariations.AddRange(GenerateVariations(germanTitle.Replace("(DE)", "").Trim(), mediaType));
+
+            }
+
+            // 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)
+            {
+                allTitleVariations.Add(germanTitle.Replace(":", " -"));
+            }
+
+            TitleMatchVariations = allTitleVariations.Distinct(StringComparer.InvariantCultureIgnoreCase).ToArray();
         }
 
-        private IEnumerable<string> GenerateTitleVariations(string? germanTitle)
+        private void GenerateVariationsForBooksAndAudio(string expectedTitle, string mediaType, string? expectedAuthor)
         {
-            if (germanTitle == null)
+            // e.g. Die Ärzte - best of die Ärzte
+            if (expectedTitle.Contains(expectedAuthor))
+            {
+                var titleWithoutAuthorName = expectedTitle.Replace(expectedAuthor, string.Empty).RemoveExtraWhitespaces().Trim();
+
+                if (titleWithoutAuthorName.Length < 2)
+                {
+                    // TODO log warning that this album can't be searched for automatically
+                }
+                TitleMatchVariations = GenerateVariations(titleWithoutAuthorName, mediaType).ToArray();
+            }
+            else
+            {
+                TitleMatchVariations = GenerateVariations(expectedTitle, mediaType).ToArray();
+            }
+
+            TitleSearchVariations = GenerateVariations($"{expectedAuthor} {expectedTitle}", mediaType).ToArray();
+            AuthorMatchVariations = GenerateVariations(expectedAuthor, mediaType).ToArray();
+
+            if (mediaType == "book")
+            {
+                if (expectedAuthor?.Contains(' ') ?? false)
+                {
+                    var nameParts = expectedAuthor.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+                    var lastName = nameParts.Last();
+                    var firstNames = nameParts.Take(nameParts.Length - 1);
+
+                    var alternativeExpectedAuthor = $"{lastName}, {string.Join(" ", firstNames)}";
+                    AuthorMatchVariations = [.. AuthorMatchVariations, .. GenerateVariations(alternativeExpectedAuthor, mediaType)];
+                }
+            }
+        }
+
+        private static IEnumerable<string> GenerateVariations(string? title, string mediaType)
+        {
+            if (title == null)
+            {
+                return [];
+            }
+
+            var cleanTitle = title.GetCleanTitle();
+
+            if (cleanTitle?.Length == 0)
             {
                 return [];
             }
-            var cleanTitle = germanTitle.RemoveAccentButKeepGermanUmlauts();
 
             // Start with base variations including handling umlauts
             var baseVariations = new List<string>
@@ -57,6 +188,11 @@ namespace UmlautAdaptarr.Models
                     cleanTitle.RemoveGermanUmlautDots()
                 };
 
+            if (mediaType == "book" || mediaType == "audio")
+            {
+                baseVariations.Add(cleanTitle.RemoveGermanUmlauts());
+            }
+
             // TODO: determine if this is really needed
             // Additional variations to accommodate titles with "-"
             if (cleanTitle.Contains('-'))
@@ -76,13 +212,26 @@ namespace UmlautAdaptarr.Models
                 });
             }
 
+            // If a title starts with der/die/das also accept variations without it
+            // Same for english the, an, a
+            if (cleanTitle.StartsWith("Der ") || cleanTitle.StartsWith("Die ") || cleanTitle.StartsWith("Das ")
+                || cleanTitle.StartsWith("The ") || cleanTitle.StartsWith("An "))
+            {
+                var cleanTitleWithoutArticle = title[3..].Trim();
+                baseVariations.AddRange(GenerateVariations(cleanTitleWithoutArticle, mediaType));
+            } else if (cleanTitle.StartsWith("A "))
+            {
+                var cleanTitleWithoutArticle = title[2..].Trim();
+                baseVariations.AddRange(GenerateVariations(cleanTitleWithoutArticle, mediaType));
+            }
+
             // Remove multiple spaces
-            var cleanedVariations = baseVariations.Select(variation => MultipleWhitespaceRegex().Replace(variation, " "));
+            var cleanedVariations = baseVariations.Select(variation => variation.RemoveExtraWhitespaces());
 
             return cleanedVariations.Distinct();
         }
 
-        [GeneratedRegex(@"\s+")]
-        private static partial Regex MultipleWhitespaceRegex();
+        [GeneratedRegex(@"\(\d{4}\)$")]
+        private static partial Regex YearAtEndOfTitleRegex();
     }
 }

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/GlobalInstanceOptions.cs

@@ -0,0 +1,25 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions
+{
+    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>
+        public string Host { get; set; }
+
+        /// <summary>
+        /// The API key of the ARR application.
+        /// </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/GlobalOptions.cs

@@ -0,0 +1,18 @@
+namespace UmlautAdaptarr.Options
+{
+    /// <summary>
+    /// Global options for the UmlautAdaptarr application.
+    /// </summary>
+    public class GlobalOptions
+    {
+        /// <summary>
+        /// The host of the UmlautAdaptarr API.
+        /// </summary>
+        public string UmlautAdaptarrApiHost { get; set; }
+
+        /// <summary>
+        /// The User-Agent string used in HTTP requests.
+        /// </summary>
+        public string UserAgent { get; set; }
+    }
+}

UmlautAdaptarr/Program.cs

@@ -1,28 +1,42 @@
 using System.Net;
-using UmlautAdaptarr.Providers;
+using Serilog;
+using Serilog.Filters;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Routing;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Services.Factory;
+using UmlautAdaptarr.Utilities;
 
 internal class Program
 {
     private static void Main(string[] args)
     {
+        Helper.ShowLogo();
+        Helper.ShowInformation();
         // TODO:
         // add option to sort by nzb age
-
-        // TODO
-        // add delay between requests
-
         var builder = WebApplication.CreateBuilder(args);
-
         var configuration = builder.Configuration;
 
+        // TODO workaround to not log api keys
+        Log.Logger = new LoggerConfiguration()
+            .ReadFrom.Configuration(configuration)
+            .WriteTo.Console(outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
+            .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();
+
+
+        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
             };
 
             return handler;
@@ -30,54 +44,59 @@ internal class Program
 
         builder.Services.AddMemoryCache(options =>
         {
+            // TODO cache size limit? option?
             //options.SizeLimit = 20000;
         });
 
+        builder.Services.AllowResolvingKeyedServicesAsDictionary();
         builder.Services.AddControllers();
-        builder.Services.AddHostedService<ArrSyncBackgroundService>();
-        builder.Services.AddSingleton<TitleApiService>(); // TODO rename
+        builder.AddTitleLookupService();
         builder.Services.AddSingleton<SearchItemLookupService>();
         builder.Services.AddSingleton<TitleMatchingService>();
-        builder.Services.AddSingleton<SonarrClient>();
+        builder.AddSonarrSupport();
+        builder.AddLidarrSupport();
+        builder.AddReadarrSupport();
         builder.Services.AddSingleton<CacheService>();
-        builder.Services.AddSingleton<ProxyService>();
+        builder.Services.AddSingleton<ProxyRequestService>();
+        builder.Services.AddSingleton<ArrApplicationFactory>();
+        builder.Services.AddHostedService<ArrSyncBackgroundService>();
+        builder.Services.AddSingleton<IHostedService, HttpProxyService>();
 
         var app = builder.Build();
 
+        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",
+            "{options}/{*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",
+            "{options}/{*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",
+            "{options}/{*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",
+            "{options}/{*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",
+            "{options}/{*domain}",
+            new { controller = "Search", action = "BookSearch" },
+            new { t = new TRouteConstraint("book") });
 
+        app.MapControllerRoute("generic-search",
+            "{options}/{*domain}",
+            new { controller = "Search", action = "GenericSearch" },
+            new { t = new TRouteConstraint("search") });
         app.Run();
     }
 }

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/LidarrClient.cs

@@ -0,0 +1,168 @@
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Utilities;
+
+namespace UmlautAdaptarr.Providers;
+
+public class LidarrClient : ArrClientBase
+{
+    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, IOptionsMonitor<LidarrInstanceOptions> options,
+        ILogger<LidarrClient> logger)
+    {
+        _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

@@ -0,0 +1,186 @@
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Utilities;
+
+namespace UmlautAdaptarr.Providers;
+
+public class ReadarrClient : ArrClientBase
+{
+    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,
+        IOptionsMonitor<ReadarrInstanceOptions> options,
+        ILogger<ReadarrClient> logger)
+    {
+        _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,172 +1,192 @@
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using System.Net.Http;
 using UmlautAdaptarr.Models;
+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,
-        IConfiguration configuration,
         TitleApiService titleService,
-        ILogger<SonarrClient> logger) : ArrClientBase()
+        IOptionsMonitor<SonarrInstanceOptions> options,
+        ILogger<SonarrClient> logger)
     {
-        private readonly string _sonarrHost = configuration.GetValue<string>("SONARR_HOST") ?? throw new ArgumentException("SONARR_HOST environment variable must be set");
-        private readonly string _sonarrApiKey = configuration.GetValue<string>("SONARR_API_KEY") ?? throw new ArgumentException("SONARR_API_KEY environment variable must be set");
-        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 = $"{_sonarrHost}/api/v3/series?includeSeasonImages=false&apikey={_sonarrApiKey}";
-                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.");
-                    foreach (var show in shows)
-                    {
-                        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);
-                    }
-                }
-
-                logger.LogInformation($"Finished fetching all items from Sonarr");
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all shows from Sonarr: {ex.Message}");
-            }
-
-            return items;
-        }
-
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
-        {
-            var httpClient = clientFactory.CreateClient();
-
-            try
-            {
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
-                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)
+                _logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr ({InstanceName}).");
+                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;
                     }
-                    (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
 
+                    var (germanTitle, 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} 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 = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
-                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} 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,75 +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,
-        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.");
+            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.");
-                await FetchAndUpdateDataAsync();
-                logger.LogInformation("ArrSyncBackgroundService has completed an iteration.");
-
+                lastRunSuccess = true;
                 await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
             }
-
-            logger.LogInformation("ArrSyncBackgroundService is stopping.");
-        }
-
-        private async Task FetchAndUpdateDataAsync()
-        {
-            try
+            else
             {
-                await FetchItemsFromSonarrAsync();
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
-            }
-        }
-
-        private async Task FetchItemsFromSonarrAsync()
-        {
-            try
-            {
-                var items = await sonarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
-            }
-        }
-
-        private void UpdateSearchItems(IEnumerable<SearchItem> searchItems)
-        {
-            foreach (var searchItem in searchItems)
-            {
-                try
+                if (lastRunSuccess)
                 {
-                    cacheService.CacheSearchItem(searchItem);
+                    lastRunSuccess = false;
+                    logger.LogInformation(
+                        "ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
+                    await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
                 }
-                catch (Exception ex)
+                else
                 {
-                    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,70 +1,146 @@
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.Extensions.Caching.Memory;
+using System.Reflection.Metadata.Ecma335;
+using System.Text.RegularExpressions;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public 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;
 
         public void CacheSearchItem(SearchItem item)
         {
             var prefix = item.MediaType;
-            var normalizedTitle = item.Title.RemoveAccentButKeepGermanUmlauts().ToLower();
-            // TODO maybe we need to also add the media type (movie/book/show etc)
+            var cacheKey = $"{prefix}_extid_{item.ExternalId}";
+            cache.Set(cacheKey, item);
+            if (item.MediaType == "audio")
+            {
+                CacheAudioSearchItem(item, cacheKey);
+                return;
+            }
+            else if (item.MediaType == "book")
+            {
+                    CacheBookSearchItem(item, cacheKey);
+                    return;
+            }
+
+            var normalizedTitle = item.Title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
-            cache.Set($"{prefix}_extid_{item.ExternalId}", item);
             cache.Set($"{prefix}_title_{normalizedTitle}", item);
 
-            foreach (var variation in item.TitleSearchVariations)
+            foreach (var variation in item.TitleMatchVariations)
             {
-                var normalizedVariation = item.Title.RemoveAccentButKeepGermanUmlauts().ToLower();
-                var cacheKey = $"{prefix}_var_{normalizedVariation}";
+                var normalizedVariation = variation.RemoveAccentButKeepGermanUmlauts().ToLower();
+                cacheKey = $"{prefix}_var_{normalizedVariation}";
                 cache.Set(cacheKey, item);
 
                 // Indexing by prefix
                 var indexPrefix = normalizedVariation[..Math.Min(VARIATION_LOOKUP_CACHE_LENGTH, variation.Length)].ToLower();
                 if (!VariationIndex.ContainsKey(indexPrefix))
                 {
-                    VariationIndex[indexPrefix] = new HashSet<string>();
+                    VariationIndex[indexPrefix] = [];
                 }
                 VariationIndex[indexPrefix].Add(cacheKey);
             }
         }
 
+        public void CacheAudioSearchItem(SearchItem item, string cacheKey)
+        {
+            // Index author and title variations
+            foreach (var authorVariation in item.AuthorMatchVariations)
+            {
+                var normalizedAuthor = authorVariation.NormalizeForComparison();
+
+                if (!AudioVariationIndex.ContainsKey(normalizedAuthor))
+                {
+                    AudioVariationIndex[normalizedAuthor] = [];
+                }
+
+                var titleVariations = item.TitleMatchVariations.Select(titleMatchVariation => titleMatchVariation.NormalizeForComparison()).ToHashSet();
+                AudioVariationIndex[normalizedAuthor].Add((titleVariations, cacheKey));
+            }
+        }
+
+        public void CacheBookSearchItem(SearchItem item, string cacheKey)
+        {
+            // Index author and title variations
+            foreach (var authorVariation in item.AuthorMatchVariations)
+            {
+                var normalizedAuthor = authorVariation.NormalizeForComparison();
+
+                if (!BookVariationIndex.ContainsKey(normalizedAuthor))
+                {
+                    BookVariationIndex[normalizedAuthor] = [];
+                }
+
+                var titleVariations = item.TitleMatchVariations.Select(titleMatchVariation => titleMatchVariation.NormalizeForComparison()).ToHashSet();
+                BookVariationIndex[normalizedAuthor].Add((titleVariations, cacheKey));
+            }
+        }
+
         public SearchItem? SearchItemByTitle(string mediaType, string title)
         {
             var normalizedTitle = title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
+            if (mediaType == "audio" || mediaType == "book")
+            {
+                return FindBestMatchForBooksAndAudio(normalizedTitle.NormalizeForComparison(), mediaType);
+            }
+
             // Use the first few characters of the normalized title for cache prefix search
             var cacheSearchPrefix = normalizedTitle[..Math.Min(VARIATION_LOOKUP_CACHE_LENGTH, normalizedTitle.Length)];
 
+            SearchItem? bestSearchItemMatch = null;
+            var bestVariationMatchLength = 0;
+            HashSet<string> checkedSearchItems = [];
+
             if (VariationIndex.TryGetValue(cacheSearchPrefix, out var cacheKeys))
             {
                 foreach (var cacheKey in cacheKeys)
                 {
                     if (cache.TryGetValue(cacheKey, out SearchItem? item))
                     {
-                        if (item?.MediaType != mediaType)
+                        if (item == null || item.MediaType != mediaType)
                         {
                             continue;
                         }
+
+                        var searchItemIdentifier = $"{item.MediaType}_{item.ExternalId}";
+
+                        if (checkedSearchItems.Contains(searchItemIdentifier))
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            checkedSearchItems.Add(searchItemIdentifier);
+                        }
+
                         // After finding a potential item, compare normalizedTitle with each German title variation
-                        foreach (var variation in item?.TitleSearchVariations ?? [])
+                        foreach (var variation in item.TitleMatchVariations ?? [])
                         {
                             var normalizedVariation = variation.RemoveAccentButKeepGermanUmlauts().ToLower();
                             if (normalizedTitle.StartsWith(variation, StringComparison.OrdinalIgnoreCase))
                             {
-                                return item;
+                                // If we find a variation match that is "longer" then most likely that one is correct and the earlier match was wrong (if it was from another searchItem)
+                                if (variation.Length > bestVariationMatchLength)
+                                {
+                                    bestSearchItemMatch = item;
+                                    bestVariationMatchLength = variation.Length;
+                                }
                             }
                         }
                     }
                 }
             }
 
-            return null;
+            return bestSearchItemMatch;
         }
 
         public SearchItem? GetSearchItemByExternalId(string mediaType, string externalId)
@@ -80,10 +156,12 @@ namespace UmlautAdaptarr.Services
         {
             var normalizedTitle = title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
+
             if (mediaType == "generic")
             {
                 // TODO
             }
+
             cache.TryGetValue($"{mediaType}_var_{normalizedTitle}", out SearchItem? item);
             if (item == null)
             {
@@ -91,5 +169,35 @@ namespace UmlautAdaptarr.Services
             }
             return item;
         }
+
+        private SearchItem? FindBestMatchForBooksAndAudio(string normalizedOriginalTitle, string mediaType)
+        {
+            var index = mediaType == "audio" ? AudioVariationIndex : BookVariationIndex;
+            
+            foreach (var authorEntry in index)
+            {
+                if (normalizedOriginalTitle.Contains(authorEntry.Key))
+                {
+                    var sortedEntries = authorEntry.Value.OrderByDescending(entry => entry.TitleVariations.FirstOrDefault()?.Length).ToList();
+
+                    foreach (var (titleVariations, cacheKey) in sortedEntries)
+                    {
+                        if (titleVariations.Any(normalizedOriginalTitle.Contains))
+                        {
+                            if (cache.TryGetValue(cacheKey, out SearchItem? item))
+                            {
+                                return item;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
+
+        [GeneratedRegex("\\s")]
+        private static partial Regex WhiteSpaceRegex();
     }
 }

UmlautAdaptarr/Services/Factory/ArrApplicationFactory.cs

@@ -0,0 +1,77 @@
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Providers;
+
+namespace UmlautAdaptarr.Services.Factory
+{
+    /// <summary>
+    /// Factory for creating RrApplication 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="rrArrApplications">A dictionary of IArrApplication instances.</param>
+        /// <param name="logger">Logger Instanz</param>
+        public ArrApplicationFactory(IDictionary<string, IArrApplication> rrArrApplications, ILogger<ArrApplicationFactory> logger)
+        {
+            _logger = logger;
+            try
+            {
+                SonarrInstances = rrArrApplications.Values.OfType<SonarrClient>();
+                LidarrInstances = rrArrApplications.Values.OfType<LidarrClient>();
+                ReadarrInstances = rrArrApplications.Values.OfType<ReadarrClient>();
+                AllInstances = rrArrApplications;
+
+                if (!AllInstances.Values.Any())
+                {
+                    throw new Exception("No RrApplication could be successfully initialized. This could be due to a faulty configuration");
+                }
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Error while Register ArrFactory. This might be a Config Problem", 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

@@ -0,0 +1,178 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+namespace UmlautAdaptarr.Services
+{
+    public class HttpProxyService : IHostedService
+    {
+        private TcpListener _listener;
+        private readonly ILogger<HttpProxyService> _logger;
+        private readonly int _proxyPort = 5006; // TODO move to appsettings.json
+        private readonly IHttpClientFactory _clientFactory;
+        private readonly HashSet<string> _knownHosts = [];
+        private readonly object _hostsLock = new();
+        private static readonly string[] newLineSeparator = ["\r\n"];
+
+        public HttpProxyService(ILogger<HttpProxyService> logger, IHttpClientFactory clientFactory)
+        {
+            _logger = logger;
+            _clientFactory = clientFactory;
+            _knownHosts.Add("prowlarr.servarr.com");
+        }
+
+        private async Task HandleRequests(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                var clientSocket = await _listener.AcceptSocketAsync();
+                _ = Task.Run(() => ProcessRequest(clientSocket), stoppingToken);
+            }
+        }
+
+        private async Task ProcessRequest(Socket clientSocket)
+        {
+            using var clientStream = new NetworkStream(clientSocket, ownsSocket: true);
+            var buffer = new byte[8192];
+            var bytesRead = await clientStream.ReadAsync(buffer);
+            var requestString = Encoding.ASCII.GetString(buffer, 0, bytesRead);
+
+            if (requestString.StartsWith("CONNECT"))
+            {
+                // Handle HTTPS CONNECT request
+                await HandleHttpsConnect(requestString, clientStream, clientSocket);
+            }
+            else
+            {
+                // Handle HTTP request
+                await HandleHttp(requestString, clientStream, clientSocket, buffer, bytesRead);
+            }
+        }
+
+        private async Task HandleHttpsConnect(string requestString, NetworkStream clientStream, Socket clientSocket)
+        {
+            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 {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(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);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"Failed to connect to target: {ex.Message}");
+                clientSocket.Close();
+            }
+        }
+
+        private async Task HandleHttp(string requestString, NetworkStream clientStream, Socket clientSocket, byte[] buffer, int bytesRead)
+        {
+            try
+            {
+                var headers = ParseHeaders(buffer, bytesRead);
+                string userAgent = headers.FirstOrDefault(h => h.Key == "User-Agent").Value;
+                var uri = new Uri(requestString.Split(' ')[1]);
+
+                // Add to known hosts if not already present
+                lock (_hostsLock)
+                {
+                    if (!_knownHosts.Contains(uri.Host))
+                    {
+                        _knownHosts.Add(uri.Host);
+                    }
+                }
+
+                var modifiedUri = $"http://localhost:5005/_/{uri.Host}{uri.PathAndQuery}";  // TODO read port from appsettings?
+                using var client = _clientFactory.CreateClient();
+                var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, modifiedUri);
+                httpRequestMessage.Headers.Add("User-Agent", userAgent);
+                var result = await client.SendAsync(httpRequestMessage);
+
+                if (result.IsSuccessStatusCode)
+                {
+                    var responseData = await result.Content.ReadAsByteArrayAsync();
+                    await clientStream.WriteAsync(Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nContent-Length: {responseData.Length}\r\n\r\n"));
+                    await clientStream.WriteAsync(responseData);
+                }
+                else
+                {
+                    await clientStream.WriteAsync(Encoding.ASCII.GetBytes($"HTTP/1.1 {result.StatusCode}\r\n\r\n"));
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"HTTP Proxy error: {ex.Message}");
+                await clientStream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 500 Internal Server Error\r\n\r\n"));
+            }
+            finally
+            {
+                clientSocket.Close();
+            }
+        }
+
+        private Dictionary<string, string> ParseHeaders(byte[] buffer, int length)
+        {
+            var headers = new Dictionary<string, string>();
+            var headerString = Encoding.ASCII.GetString(buffer, 0, length);
+            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[..colonIndex].Trim();
+                    var value = line[(colonIndex + 1)..].Trim();
+                    headers[key] = value;
+                }
+            }
+            return headers;
+        }
+
+        private static (string host, int port) ParseTargetInfo(string requestLine)
+        {
+            var parts = requestLine.Split(' ')[1].Split(':');
+            return (parts[0], int.Parse(parts[1]));
+        }
+
+        private async Task RelayTraffic(NetworkStream clientStream, NetworkStream targetStream)
+        {
+            var clientToTargetTask = RelayStream(clientStream, targetStream);
+            var targetToClientTask = RelayStream(targetStream, clientStream);
+            await Task.WhenAll(clientToTargetTask, targetToClientTask);
+        }
+
+        private static async Task RelayStream(NetworkStream input, NetworkStream output)
+        {
+            byte[] buffer = new byte[8192];
+            int bytesRead;
+            while ((bytesRead = await input.ReadAsync(buffer.AsMemory(0, buffer.Length))) > 0)
+            {
+                await output.WriteAsync(buffer.AsMemory(0, bytesRead));
+                await output.FlushAsync();
+            }
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _listener = new TcpListener(IPAddress.Any, _proxyPort);
+            _listener.Start();
+            Task.Run(() => HandleRequests(cancellationToken), cancellationToken);
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _listener.Stop();
+            return Task.CompletedTask;
+        }
+    }
+}

UmlautAdaptarr/Services/ProxyRequestService.cs

@@ -1,25 +1,44 @@
 using Microsoft.Extensions.Caching.Memory;
 using System.Collections.Concurrent;
+using Microsoft.Extensions.Options;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public class ProxyService
+    public class ProxyRequestService
     {
         private readonly HttpClient _httpClient;
         private readonly string _userAgent;
-        private readonly ILogger<ProxyService> _logger;
+        private readonly ILogger<ProxyRequestService> _logger;
         private readonly IMemoryCache _cache;
+        private readonly GlobalOptions _options;
         private static readonly ConcurrentDictionary<string, DateTimeOffset> _lastRequestTimes = new();
+        private static readonly TimeSpan MINIMUM_DELAY_FOR_SAME_HOST = new(0, 0, 0, 1);
 
-        public ProxyService(IHttpClientFactory clientFactory, IConfiguration configuration, ILogger<ProxyService> logger, IMemoryCache cache)
+        public ProxyRequestService(IHttpClientFactory clientFactory, ILogger<ProxyRequestService> logger, IMemoryCache cache, IOptions<GlobalOptions> options)
         {
+            _options = options.Value;
             _httpClient = clientFactory.CreateClient("HttpClient") ?? throw new ArgumentNullException(nameof(clientFactory));
-            _userAgent = configuration["Settings:UserAgent"] ?? throw new ArgumentException("UserAgent must be set in appsettings.json");
+            _userAgent =  _options.UserAgent ?? throw new ArgumentException("UserAgent must be set in appsettings.json");
             _logger = logger;
             _cache = cache;
         }
 
+        private static async Task EnsureMinimumDelayAsync(string targetUri)
+        {
+            var host = new Uri(targetUri).Host;
+            if (_lastRequestTimes.TryGetValue(host, out var lastRequestTime))
+            {
+                var timeSinceLastRequest = DateTimeOffset.Now - lastRequestTime;
+                if (timeSinceLastRequest < MINIMUM_DELAY_FOR_SAME_HOST)
+                {
+                    await Task.Delay(MINIMUM_DELAY_FOR_SAME_HOST - timeSinceLastRequest);
+                }
+            }
+            _lastRequestTimes[host] = DateTimeOffset.Now;
+        }
+
         public async Task<HttpResponseMessage> ProxyRequestAsync(HttpContext context, string targetUri)
         {
             if (!HttpMethods.IsGet(context.Request.Method))
@@ -27,18 +46,6 @@ namespace UmlautAdaptarr.Services
                 throw new ArgumentException("Only GET requests are supported", context.Request.Method);
             }
 
-            // Throttling mechanism
-            var host = new Uri(targetUri).Host;
-            if (_lastRequestTimes.TryGetValue(host, out var lastRequestTime))
-            {
-                var timeSinceLastRequest = DateTimeOffset.Now - lastRequestTime;
-                if (timeSinceLastRequest < TimeSpan.FromSeconds(3))
-                {
-                    await Task.Delay(TimeSpan.FromSeconds(3) - timeSinceLastRequest);
-                }
-            }
-            _lastRequestTimes[host] = DateTimeOffset.Now;
-
             // Check cache
             if (_cache.TryGetValue(targetUri, out HttpResponseMessage cachedResponse))
             {
@@ -46,6 +53,8 @@ namespace UmlautAdaptarr.Services
                 return cachedResponse!;
             }
 
+            await EnsureMinimumDelayAsync(targetUri);
+
             var requestMessage = new HttpRequestMessage
             {
                 RequestUri = new Uri(targetUri),
@@ -67,12 +76,12 @@ namespace UmlautAdaptarr.Services
 
             try
             {
-                _logger.LogInformation($"ProxyService GET {UrlUtilities.RedactApiKey(targetUri)}");
+                _logger.LogInformation($"ProxyRequestService GET {UrlUtilities.RedactApiKey(targetUri)}");
                 var responseMessage = await _httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, context.RequestAborted);
 
                 if (responseMessage.IsSuccessStatusCode)
                 {
-                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(5));
+                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(12));
                 }
 
                 return responseMessage;
@@ -81,7 +90,6 @@ namespace UmlautAdaptarr.Services
             {
                 _logger.LogError(ex, $"Error proxying request: {UrlUtilities.RedactApiKey(targetUri)}. Error: {ex.Message}");
 
-                // Create a response message indicating an internal server error
                 var errorResponse = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError)
                 {
                     Content = new StringContent($"An error occurred while processing your request: {ex.Message}")

UmlautAdaptarr/Services/SearchItemLookupService.cs

@@ -1,9 +1,11 @@
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Services.Factory;
 
 namespace UmlautAdaptarr.Services
 {
-    public class SearchItemLookupService(CacheService cacheService, SonarrClient sonarrClient)
+    public class SearchItemLookupService(CacheService cacheService,
+        ArrApplicationFactory arrApplicationFactory)
     {
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
@@ -19,9 +21,42 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+
+                    if (sonarrInstances.Any())
+                    {
+                        foreach (var sonarrClient in sonarrInstances)
+                        {
+                            fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                        }
+                    }
+                    break;
+                case "audio":
+
+                    var lidarrInstances = arrApplicationFactory.LidarrInstances;
+
+                    if (lidarrInstances.Any())
+                    {
+                        foreach (var lidarrClient in lidarrInstances)
+                        {
+                            await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                            fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        }
+                    }
+                    break;
+                case "book":
+
+                    var readarrInstances = arrApplicationFactory.ReadarrInstances;
+                    if (readarrInstances.Any())
+                    {
+                        foreach (var readarrClient in readarrInstances)
+                        {
+                            await readarrClient.FetchItemByExternalIdAsync(externalId);
+                            fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        }
+                    }
                     break;
-                    // TODO Add cases for other sources like Radarr, Lidarr, etc.
             }
 
             // If an item is fetched, cache it
@@ -47,7 +82,16 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+                    foreach (var sonarrClient in sonarrInstances)
+                    {
+                        fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
+                    }
+                    break;
+                case "audio":
+                    break;
+                case "book":
                     break;
                     // TODO add cases for other sources as needed, such as Radarr, Lidarr, etc.
             }
@@ -61,5 +105,4 @@ namespace UmlautAdaptarr.Services
             return fetchedItem;
         }
     }
-
 }

UmlautAdaptarr/Services/TitleApiService.cs

@@ -1,24 +1,28 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public class TitleApiService(IHttpClientFactory clientFactory, IConfiguration configuration, ILogger<TitleApiService> logger)
+    public class TitleApiService(IHttpClientFactory clientFactory, ILogger<TitleApiService> logger, IOptions<GlobalOptions> options)
     {
-        private readonly string _umlautAdaptarrApiHost = configuration["Settings:UmlautAdaptarrApiHost"]
-                                                         ?? throw new ArgumentException("UmlautAdaptarrApiHost must be set in appsettings.json");
+        public GlobalOptions Options { get; } = options.Value;
+
         private DateTime lastRequestTime = DateTime.MinValue;
 
         private async Task EnsureMinimumDelayAsync()
         {
             var sinceLastRequest = DateTime.Now - lastRequestTime;
-            if (sinceLastRequest < TimeSpan.FromSeconds(2))
+            if (sinceLastRequest < TimeSpan.FromSeconds(1))
             {
-                await Task.Delay(TimeSpan.FromSeconds(2) - sinceLastRequest);
+                await Task.Delay(TimeSpan.FromSeconds(1) - sinceLastRequest);
             }
             lastRequestTime = DateTime.Now;
         }
 
+        // TODO add cache, TODO add bulk request
         public async Task<(string? germanTitle, string[]? aliases)> FetchGermanTitleAndAliasesByExternalIdAsync(string mediaType, string externalId)
         {
             try
@@ -26,7 +30,8 @@ namespace UmlautAdaptarr.Services
                 await EnsureMinimumDelayAsync();
 
                 var httpClient = clientFactory.CreateClient();
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
+                var titleApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
+                logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                 var response = await httpClient.GetStringAsync(titleApiUrl);
                 var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(response);
 
@@ -71,7 +76,8 @@ namespace UmlautAdaptarr.Services
 
                 var httpClient = clientFactory.CreateClient();
                 var tvdbCleanTitle = title.Replace("ß", "ss");
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
+                var titleApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
+                logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                 var titleApiResponse = await httpClient.GetStringAsync(titleApiUrl);
                 var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);
 

UmlautAdaptarr/Services/TitleMatchingService.cs

@@ -1,17 +1,18 @@
-using System.Text.RegularExpressions;
+using Microsoft.Extensions.FileSystemGlobbing.Internal;
+using System.Text.RegularExpressions;
 using System.Xml.Linq;
+using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
     public partial class TitleMatchingService(CacheService cacheService, ILogger<TitleMatchingService> logger)
     {
-        public string RenameTitlesInContent(string content, string[]? titleMatchVariations, string? expectedTitle)
+        public string RenameTitlesInContent(string content, SearchItem? searchItem)
         {
             var xDoc = XDocument.Parse(content);
 
-            // If expectedTitle and titleMatchVariations are provided use them, if not use the CacheService to find matches.
-            bool useCacheService = string.IsNullOrEmpty(expectedTitle) || titleMatchVariations?.Length == 0;
+            bool useCacheService = searchItem == null;
 
             foreach (var item in xDoc.Descendants("item"))
             {
@@ -19,81 +20,45 @@ namespace UmlautAdaptarr.Services
                 if (titleElement != null)
                 {
                     var originalTitle = titleElement.Value;
-                    var normalizedOriginalTitle = NormalizeTitle(originalTitle);
+                    var cleanTitleSeperatedBySpace = ReplaceSeperatorsWithSpace(originalTitle.RemoveAccentButKeepGermanUmlauts());
+
+                    var categoryElement = item.Element("category");
+                    var category = categoryElement?.Value;
+                    var mediaType = GetMediaTypeFromCategory(category);
+
+                    if (mediaType == null)
+                    {
+                        continue;
+                    }
 
                     if (useCacheService)
                     {
-                        var categoryElement = item.Element("category");
-                        var category = categoryElement?.Value;
-                        var mediaType = GetMediaTypeFromCategory(category);
-                        if (mediaType == null)
-                        {
-                            continue;
-                        }
-
                         // Use CacheService to find a matching SearchItem by title
-                        var searchItem = cacheService.SearchItemByTitle(mediaType, originalTitle);
-                        if (searchItem != null)
-                        {
-                            // If a SearchItem is found, use its ExpectedTitle and titleMatchVariations for renaming
-                            expectedTitle = searchItem.ExpectedTitle;
-                            titleMatchVariations = searchItem.TitleMatchVariations;
-                        }
-                        else
-                        {
-                            // Skip processing this item if no matching SearchItem is found
-                            continue;
-                        }
+                        searchItem = cacheService.SearchItemByTitle(mediaType, cleanTitleSeperatedBySpace);
                     }
 
-                    // Attempt to find a variation that matches the start of the original title
-                    foreach (var variation in titleMatchVariations!)
+                    if (searchItem == null)
                     {
-                        // Skip variations that are already the expectedTitle
-                        if (variation == expectedTitle)
-                        {
-                            continue;
-                        }
+                        // Skip processing this item if no matching SearchItem is found
+                        continue;
+                    }
 
-                        // Variation is already normalized at creation
-                        var pattern = "^" + Regex.Escape(variation).Replace("\\ ", "[._ ]");
-
-                        // Check if the originalTitle starts with the variation (ignoring case and separators)
-                        if (Regex.IsMatch(normalizedOriginalTitle, pattern, RegexOptions.IgnoreCase))
-                        {
-                            // Find the first separator used in the original title for consistent replacement
-                            var separator = FindFirstSeparator(originalTitle);
-                            // Reconstruct the expected title using the original separator
-                            var newTitlePrefix = expectedTitle!.Replace(" ", separator.ToString());
-
-                            // Extract the suffix from the original title starting right after the matched variation length
-                            var variationLength = variation.Length;
-                            var suffix = originalTitle[Math.Min(variationLength, originalTitle.Length)..];
-
-                            // Clean up any leading separators 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";
-                            }
-                            */
-
-                            // Construct the new title with the original suffix
-                            var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : separator + suffix);
-
-                            // 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}'");
-                            break; // Break after the first successful match and modification
-                        }
+                    switch (mediaType)
+                    {
+                        case "tv":
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
+                            break;
+                        case "movie":
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
+                            break;
+                        case "audio":
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
+                            break;
+                        case "book":
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
+                            break;
+                        default:
+                            throw new NotImplementedException();
                     }
                 }
             }
@@ -101,10 +66,211 @@ namespace UmlautAdaptarr.Services
             return xDoc.ToString();
         }
 
-
-        private static string NormalizeTitle(string title)
+        public void FindAndReplaceForBooksAndAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
+        {
+            var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+            var (foundMatch, bestStart, bestEndInOriginal) = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+
+            if (authorMatch.foundMatch && foundMatch)
+            {
+                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, bestEndInOriginal);
+
+                // Check and adjust for immediate following delimiter
+                char[] delimiters = [' ', '-', '_', '.'];
+                if (matchEndPositionInOriginal < originalTitle.Length && delimiters.Contains(originalTitle[matchEndPositionInOriginal]))
+                {
+                    matchEndPositionInOriginal++; // Skip the delimiter if it's immediately after the match
+                }
+
+                // Ensure we trim any leading delimiters from the suffix
+                string suffix = originalTitle[matchEndPositionInOriginal..].TrimStart([' ', '-', '_', '.']).Trim();
+
+                // Concatenate the expected title with the remaining suffix
+                var updatedTitle = $"{searchItem.ExpectedAuthor} - {searchItem.ExpectedTitle}";
+                if (suffix.Length >= 3)
+                {
+                    updatedTitle += $"-[{suffix}]";
+                }
+
+                // Update the title element
+                titleElement.Value = updatedTitle;
+                logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{updatedTitle}'");
+            }
+            else
+            {
+                logger.LogDebug($"TitleMatchingService - No satisfactory fuzzy match found for both author and title for {originalTitle}.");
+            }
+        }
+
+
+        private static (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
+        {
+            bool found = false;
+            int bestStart = int.MaxValue;
+            int bestEndInOriginal = -1;
+
+            foreach (var variation in variations)
+            {
+                var normalizedVariation = variation.NormalizeForComparison();
+                int startNormalized = normalizedOriginal.IndexOf(normalizedVariation);
+
+                if (startNormalized >= 0)
+                {
+                    found = true;
+                    // Map the start position from the normalized string back to the original string
+                    int startOriginal = MapNormalizedIndexToOriginal(normalizedOriginal, originalTitle, startNormalized);
+                    int endOriginal = MapNormalizedIndexToOriginal(normalizedOriginal, originalTitle, startNormalized + normalizedVariation.Length);
+
+                    bestStart = Math.Min(bestStart, startOriginal);
+                    bestEndInOriginal = Math.Max(bestEndInOriginal, endOriginal);
+                }
+            }
+
+            if (!found) return (false, 0, 0);
+            return (found, bestStart, bestEndInOriginal);
+        }
+
+        // Maps an index from the normalized string back to a corresponding index in the original string
+        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;
+            for (int i = 0; i < normalizedIndex && i < normalizedOriginal.Length; i++)
+            {
+                if (char.IsLetterOrDigit(normalizedOriginal[i]))
+                {
+                    nonSpecialCharCount++;
+                }
+            }
+
+            // Count non-special characters in the original title to find the corresponding index
+            int originalIndex = 0;
+            for (int i = 0; i < originalTitle.Length; i++)
+            {
+                if (char.IsLetterOrDigit(originalTitle[i]))
+                {
+                    if (--nonSpecialCharCount < 0)
+                    {
+                        break;
+                    }
+                }
+                originalIndex = i;
+            }
+
+            return originalIndex;
+        }
+
+        // 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)
+        {
+            var titleMatchVariations = searchItem.TitleMatchVariations;
+            var expectedTitle = searchItem.ExpectedTitle;
+            var variationsOrderedByLength = titleMatchVariations!.OrderByDescending(variation => variation.Length);
+
+            // Attempt to find a variation that matches the start of the original title
+            foreach (var variation in variationsOrderedByLength)
+            {
+                // Skip variations that are already the expectedTitle
+                if (variation == expectedTitle)
+                {
+                    continue;
+                }
+
+                // Variation is already normalized at creation
+                var variationMatchPattern = "^" + Regex.Escape(variation).Replace("\\ ", "[._ ]");
+
+                // Check if the originalTitle starts with the variation (ignoring case and separators)
+                if (Regex.IsMatch(normalizedOriginalTitle, variationMatchPattern, RegexOptions.IgnoreCase))
+                {
+                    var originalTitleMatchPattern = "^" + Regex.Escape(variation).Replace("\\ ", "[._ ]");
+
+                    // Find the first separator used in the original title for consistent replacement
+                    var separator = FindFirstSeparator(originalTitle);
+                    // Reconstruct the expected title using the original separator
+                    var newTitlePrefix = expectedTitle!.Replace(" ", separator.ToString());
+
+                    // Extract the suffix from the original title starting right after the matched variation length
+                    var variationLength = variation.Length;
+                    var suffix = originalTitle[Math.Min(variationLength, originalTitle.Length)..];
+
+                    // 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
+                        // - that won't help with movies but with tv shows
+                        var seasonMatchingPattern = $"^{separator}S\\d{{1,2}}E\\d{{1,2}}";
+                        if (!Regex.IsMatch(suffix, seasonMatchingPattern))
+                        {
+                            logger.LogWarning($"TitleMatchingService - Didn't rename: '{originalTitle}' because the expected title '{expectedTitle}' starts with the variation '{variation}'");
+                            continue;
+                        }
+                    }
+
+                    // Clean up any leading separator from the suffix
+                    suffix = Regex.Replace(suffix, "^ +", "");
+
+                    // 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}");
+
+                    // 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}'");
+                    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)
         {
-            title = title.RemoveAccentButKeepGermanUmlauts();
             // Replace all known separators with space for normalization
             return WordSeperationCharRegex().Replace(title, " ".ToString());
         }
@@ -112,12 +278,16 @@ namespace UmlautAdaptarr.Services
         private static char FindFirstSeparator(string title)
         {
             var match = WordSeperationCharRegex().Match(title);
-            return match.Success ? match.Value.First() : ' '; // Default to space if no separator found
+            return match.Success ? match.Value.First() : ' ';
         }
 
         private static string ReconstructTitleWithSeparator(string title, char separator)
         {
-            // Replace spaces with the original separator found in the title
+            if (separator != ' ')
+            {
+                return title;
+            }
+            
             return title.Replace(' ', separator);
         }
 
@@ -128,22 +298,26 @@ namespace UmlautAdaptarr.Services
                 return null;
             }
 
-            if (category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase))
+            if (category == "7000" || category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
+            else if (category == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
             {
                 return "movies";
             }
-            else if (category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
+            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
             {
                 return "tv";
             }
-            else if (category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase))
+            else if (category == "3030" || category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
+            else if (category == "3000" || category.StartsWith("Audio"))
+            {
+                return "audio";
+            }
 
             return null;
         }
@@ -151,5 +325,6 @@ namespace UmlautAdaptarr.Services
 
         [GeneratedRegex("[._ ]")]
             private static partial Regex WordSeperationCharRegex();
+
     }
 }

UmlautAdaptarr/Services/TitleQueryServiceLegacy.cs

@@ -1,162 +0,0 @@
-using Microsoft.Extensions.Caching.Memory;
-using Newtonsoft.Json;
-using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Providers;
-using UmlautAdaptarr.Utilities;
-
-namespace UmlautAdaptarr.Services
-{
-    public class TitleQueryServiceLegacy(
-        IMemoryCache memoryCache,
-        ILogger<TitleQueryServiceLegacy> logger,
-        IConfiguration configuration,
-        IHttpClientFactory clientFactory,
-        SonarrClient sonarrClient)
-    {
-        private readonly HttpClient _httpClient = clientFactory.CreateClient("HttpClient") ?? throw new ArgumentNullException();
-        private readonly string _sonarrHost = configuration.GetValue<string>("SONARR_HOST") ?? throw new ArgumentException("SONARR_HOST environment variable must be set");
-        private readonly string _sonarrApiKey = configuration.GetValue<string>("SONARR_API_KEY") ?? throw new ArgumentException("SONARR_API_KEY environment variable must be set");
-        private readonly string _umlautAdaptarrApiHost = configuration["Settings:UmlautAdaptarrApiHost"] ?? throw new ArgumentException("UmlautAdaptarrApiHost must be set in appsettings.json");
-
-        /*public async Task<(bool hasGermanUmlaut, string? GermanTitle, string ExpectedTitle)> QueryGermanShowTitleByTVDBId(string tvdbId)
-        {
-            var sonarrCacheKey = $"SearchItem_Sonarr_{tvdbId}";
-
-            if (memoryCache.TryGetValue(sonarrCacheKey, out SearchItem? cachedItem))
-            {
-                return (cachedItem?.HasGermanUmlaut ?? false, cachedItem?.GermanTitle, cachedItem?.ExpectedTitle ?? string.Empty);
-            }
-            else
-            {
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
-                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 (false, null, string.Empty);
-                }
-                else if (shows.Count == 0)
-                {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
-                    return (false, null, string.Empty);
-                }
-
-                var expectedTitle = (string)shows[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
-                    return (false, null, string.Empty);
-                }
-
-                string? germanTitle = null;
-                var hasGermanTitle = false;
-
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?tvdbid={tvdbId}";
-                var titleApiResponse = await _httpClient.GetStringAsync(titleApiUrl);
-                var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);
-
-                if (titleApiResponseData == null)
-                {
-                    logger.LogError($"Parsing UmlautAdaptarr TitleQuery API response for TVDB ID {tvdbId} resulted in null");
-                    return (false, null, string.Empty);
-                }
-
-                if (titleApiResponseData.status == "success" && !string.IsNullOrEmpty((string)titleApiResponseData.germanTitle))
-                {
-                    germanTitle = titleApiResponseData.germanTitle;
-                    hasGermanTitle = true;
-                }
-
-                var hasGermanUmlaut = germanTitle?.HasGermanUmlauts() ?? false;
-
-                var result = (hasGermanUmlaut, germanTitle, expectedTitle);
-                memoryCache.Set(showCacheKey, result, new MemoryCacheEntryOptions
-                {
-                    Size = 1,
-                    SlidingExpiration = hasGermanTitle ? TimeSpan.FromDays(30) : TimeSpan.FromDays(7)
-                });
-
-                return result;
-            }
-        }*/
-
-        // This method is being used if the *arrs do a search with the "q" parameter (text search)
-        public async Task<(bool hasGermanUmlaut, string? GermanTitle, string ExpectedTitle)> QueryGermanShowTitleByTitle(string title)
-        {
-            // TVDB doesn't use ß - TODO: Determine if this is true
-            var tvdbCleanTitle = title.Replace("ß", "ss");
-
-            var cacheKey = $"show_{tvdbCleanTitle}";
-            if (memoryCache.TryGetValue(cacheKey, out (bool hasGermanUmlaut, string? GermanTitle, string ExpectedTitle) cachedResult))
-            {
-                return cachedResult;
-            }
-
-            var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
-            var titleApiResponse = await _httpClient.GetStringAsync(titleApiUrl);
-            var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);
-
-            if (titleApiResponseData == null)
-            {
-                logger.LogError($"Parsing UmlautAdaptarr TitleQuery API response for title {title} resulted in null");
-                return (false, null, string.Empty);
-            }
-
-            if (titleApiResponseData.status == "success" && !string.IsNullOrEmpty((string)titleApiResponseData.germanTitle))
-            {
-                var tvdbId = (string)titleApiResponseData.tvdbId;
-                if (tvdbId == null)
-                {
-                    logger.LogError($"Parsing UmlautAdaptarr TitleQuery API response tvdbId {titleApiResponseData} resulted in null");
-                    return (false, null, string.Empty);
-                }
-
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
-                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 (false, null, string.Empty);
-                }
-                else if (shows.Count == 0)
-                {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
-                    return (false, null, string.Empty);
-                }
-
-                var expectedTitle = (string)shows[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
-                    return (false, null, string.Empty);
-                }
-
-                string germanTitle ;
-                bool hasGermanTitle;
-
-                germanTitle = titleApiResponseData.germanTitle;
-                hasGermanTitle = true;
-
-                var hasGermanUmlaut = germanTitle?.HasGermanUmlauts() ?? false;
-
-                var result = (hasGermanUmlaut, germanTitle, expectedTitle);
-                memoryCache.Set(cacheKey, result, new MemoryCacheEntryOptions
-                {
-                    Size = 1,
-                    SlidingExpiration = hasGermanTitle ? TimeSpan.FromDays(30) : TimeSpan.FromDays(7)
-                });
-
-                return result;
-            }
-            else
-            {
-                logger.LogWarning($"UmlautAdaptarr TitleQuery {titleApiUrl} didn't succeed.");
-                return (false, null, string.Empty);
-            }
-        }
-    }
-}

UmlautAdaptarr/UmlautAdaptarr.csproj

@@ -9,8 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.9.2" />
+    <PackageReference Include="IL.FluentValidation.Extensions.Options" Version="11.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    <PackageReference Include="Serilog.AspNetCore" Version="8.0.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.7.3" />
   </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

@@ -1,9 +1,10 @@
 using System.Globalization;
 using System.Text;
+using System.Text.RegularExpressions;
 
 namespace UmlautAdaptarr.Utilities
 {
-    public static class Extensions
+    public static partial class Extensions
     {
         public static string GetQuery(this HttpContext context, string key)
         {
@@ -46,6 +47,67 @@ namespace UmlautAdaptarr.Utilities
             return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
         }
 
+        public static string GetLidarrTitleForExternalId(this string text)
+        {
+            text = text.RemoveGermanUmlautDots()
+                       .Replace("-", "")
+                       .GetCleanTitle()
+                       .ToLower();
+
+            // Lidarr removes the, an and a at the beginning
+            return TitlePrefixRegex()
+                .Replace(text, "")
+                .RemoveExtraWhitespaces()
+                .Trim();
+        }
+
+        public static string GetReadarrTitleForExternalId(this string text)
+        {
+            text = text.ToLower();
+
+            // Readarr removes "the" at the beginning
+            if (text.StartsWith("the "))
+            {
+                text = text[4..];
+            }
+
+            return text.RemoveGermanUmlautDots()
+                       .Replace(".", " ")
+                       .Replace("-", " ")
+                       .Replace(":", " ")
+                       .GetCleanTitle();
+        }
+
+        public static string GetCleanTitle(this string text)
+        {
+            return text
+                .Replace(".", " ")
+                .Replace(":", " ")
+                .RemoveAccentButKeepGermanUmlauts()
+                .RemoveSpecialCharacters(removeUmlauts: false)
+                .RemoveExtraWhitespaces()
+                .Trim();
+        }
+
+        public static string NormalizeForComparison(this string text)
+        {
+            // TODO see if we can replace RemoveGermanUmlautDots() with RemoveSpecialCharacters(removeUmlauts: false);
+            return text.RemoveGermanUmlautDots().RemoveAccent().RemoveSpecialCharacters().Replace(" ", "").Trim().ToLower();
+        }
+
+        public static string RemoveSpecialCharacters(this string text, bool removeUmlauts = true)
+        {
+            if (removeUmlauts)
+            {
+                return NoSpecialCharactersExceptHyphenRegex().Replace(text, "");
+            }
+            else
+            {
+                return NoSpecialCharactersExceptHyphenAndUmlautsRegex().Replace(text, "");
+            }
+        }
+
+
         public static string ReplaceGermanUmlautsWithLatinEquivalents(this string text)
         {
             return text
@@ -70,11 +132,40 @@ namespace UmlautAdaptarr.Utilities
                 .Replace("ß", "ss");
         }
 
-        public static bool HasGermanUmlauts(this string text)
+        public static string RemoveGermanUmlauts(this string text)
+        {
+            return text
+                .Replace("ö", "")
+                .Replace("ü", "")
+                .Replace("ä", "")
+                .Replace("Ö", "")
+                .Replace("Ü", "")
+                .Replace("Ä", "")
+                .Replace("ß", "");
+        }
+
+        public static string RemoveExtraWhitespaces(this string text)
+        {
+            return MultipleWhitespaceRegex().Replace(text, " ");
+        }
+
+        public static bool HasUmlauts(this string text)
         {
             if (text == null) return false;
             var umlauts = new[] { 'ö', 'ä', 'ü', 'Ä', 'Ü', 'Ö', 'ß' };
             return umlauts.Any(text.Contains);
         }
+
+        [GeneratedRegex("[^a-zA-Z0-9 -]+", RegexOptions.Compiled)]
+        private static partial Regex NoSpecialCharactersExceptHyphenRegex();
+
+        [GeneratedRegex("[^a-zA-Z0-9 öäüßÖÄÜß-]+", RegexOptions.Compiled)]
+        private static partial Regex NoSpecialCharactersExceptHyphenAndUmlautsRegex();
+
+        [GeneratedRegex(@"\s+")]
+        private static partial Regex MultipleWhitespaceRegex();
+
+        [GeneratedRegex(@"\b(the|an|a)\b", RegexOptions.IgnoreCase, "de-DE")]
+        private static partial Regex TitlePrefixRegex();
     }
 }

UmlautAdaptarr/Utilities/GlobalStaticLogger.cs

@@ -0,0 +1,19 @@
+namespace UmlautAdaptarr.Utilities
+{
+    /// <summary>
+    /// Service for providing a static logger to log errors and information. 
+    /// The GlobalStaticLogger is designed to provide a static logger that can be used to log errors and information. 
+    /// It facilitates logging for both static classes and extension methods.
+    /// </summary>
+    public static class GlobalStaticLogger
+    {
+
+        public static ILogger Logger;
+
+        /// <summary>
+        /// Initializes the GlobalStaticLogger with the provided logger factory.
+        /// </summary>
+        /// <param name="loggerFactory">The ILoggerFactory instance used to create loggers.</param>
+        public static void Initialize(ILoggerFactory loggerFactory) => Logger = loggerFactory.CreateLogger("GlobalStaticLogger");
+    }
+}

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 void ShowInformation()
+    {
+        Console.WriteLine("--------------------------[IP Leak Test]-----------------------------");
+        var ipInfo = GetPublicIpAddressInfoAsync().GetAwaiter().GetResult();
+
+        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/ServicesExtensions.cs

@@ -0,0 +1,191 @@
+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;
+
+/// <summary>
+///     Extension methods for configuring services related to ARR Applications
+/// </summary>
+public static class ServicesExtensions
+{
+
+    /// <summary>
+    /// Logger instance for logging proxy configurations.
+    /// </summary>
+    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 WebApplicationBuilder AddServicesWithOptions<TOptions, TService, TInterface>(
+        this WebApplicationBuilder builder, string sectionName)
+        where TOptions : class, new()
+        where TService : class, TInterface
+        where TInterface : class
+    {
+        try
+        {
+            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)
+            {
+              GlobalInstanceOptionsValidator validator = new GlobalInstanceOptionsValidator();
+
+              var results =  validator.Validate(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 first you config 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);
+                }
+            }
+
+            return builder;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error in AddServicesWithOptions: {ex.Message}");
+            throw;
+        }
+
+    }
+
+    /// <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 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 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 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,14 +5,14 @@ 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-]+)+.*)$")]
         private static partial Regex UrlMatchingRegex();
         public static bool IsValidDomain(string domain)
         {
             // RegEx für eine einfache URL-Validierung ohne http:// und ohne abschließenden Schrägstrich
             // Erlaubt optionale Subdomains, Domainnamen und TLDs, aber keine Pfade oder Protokolle
             var regex = UrlMatchingRegex();
-            return regex.IsMatch(domain) && !domain.EndsWith("/");
+            return regex.IsMatch(domain);
         }
 
         public static string BuildUrl(string domain, IDictionary<string, string> queryParameters)
@@ -35,7 +35,7 @@ namespace UmlautAdaptarr.Utilities
 
             if (!string.IsNullOrEmpty(apiKey))
             {
-                queryParameters["apiKey"] = apiKey;
+                queryParameters["apikey"] = apiKey;
             }
 
             return BuildUrl(domain, queryParameters);

UmlautAdaptarr/Validator/GlobalInstanceOptionsValidator.cs

@@ -0,0 +1,61 @@
+using System.Net;
+using FluentValidation;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+namespace UmlautAdaptarr.Validator;
+
+public class GlobalInstanceOptionsValidator : AbstractValidator<GlobalInstanceOptions>
+{
+    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.")
+                .Must(BeReachable)
+                .WithMessage("Host/Url is not reachable. Please check your Host or your UmlautAdaptrr Settings");
+
+            RuleFor(x => x.ApiKey)
+                .NotEmpty().WithMessage("ApiKey is required when Enabled is true.");
+        });
+    }
+
+    private bool BeAValidUrl(string url)
+    {
+        return Uri.TryCreate(url, UriKind.Absolute, out var uriResult)
+               && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
+    }
+
+    private static bool BeReachable(string url)
+    {
+        var endTime = DateTime.Now.AddMinutes(3);
+        var reachable = false;
+
+        while (DateTime.Now < endTime)
+        {
+            try
+            {
+                var request = WebRequest.Create(url);
+                request.Timeout = 3000;
+                using var response = (HttpWebResponse)request.GetResponse();
+                reachable = response.StatusCode == HttpStatusCode.OK;
+                if (reachable)
+                    break;
+            }
+            catch
+            {
+              
+            }
+
+            // Wait for 15 seconds for next try
+            Console.WriteLine($"The URL \"{url}\" is not reachable. Next attempt in 15 seconds...");
+            Thread.Sleep(15000);
+        }
+
+        return reachable;
+    }
+
+}

UmlautAdaptarr/appsettings.json

@@ -3,18 +3,66 @@
     "LogLevel": {
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
+    },
+    "Console": {
+      "TimestampFormat": "yyyy-MM-dd HH:mm:ss::"
     }
   },
   "AllowedHosts": "*",
   "Kestrel": {
     "Endpoints": {
       "Http": {
-        "Url": "http://*:5005"
+        "Url": "http://[::]:5005"
       }
     }
   },
+  // Settings__UserAgent=UmlautAdaptarr/1.0
+  // Settings__UmlautAdaptarrApiHost=https://umlautadaptarr.pcjones.de/api/v1
   "Settings": {
     "UserAgent": "UmlautAdaptarr/1.0",
     "UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1"
+  },
+  "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"
+  },
+  "Readarr": {
+    // Docker Environment Variables:
+    // - Readarr__Enabled: true (set to false to disable)
+    // - Readarr__Host: your_readarr_host_url
+    // - Readarr__ApiKey: your_readarr_api_key
+    "Enabled": false,
+    "Host": "your_readarr_host_url",
+    "ApiKey": "your_readarr_api_key"
   }
 }

UmlautAdaptarr/libman.json

@@ -0,0 +1,5 @@
+{
+  "version": "1.0",
+  "defaultProvider": "cdnjs",
+  "libraries": []
+}

UmlautAdaptarr/secrets_example.json

@@ -1,4 +0,0 @@
-{
-  "SONARR_HOST": "http://localhost:8989",
-  "SONARR_API_KEY": ""
-}

build_and_push_docker_image.bat

@@ -0,0 +1,18 @@
+@echo off
+SET IMAGE_NAME=pcjones/umlautadaptarr
+
+echo Enter the version number for the Docker image:
+set /p VERSION="Version: "
+
+echo Building Docker image with version %VERSION%...
+docker build -t %IMAGE_NAME%:%VERSION% .
+docker tag %IMAGE_NAME%:%VERSION% %IMAGE_NAME%:latest
+
+echo Pushing Docker image with version %VERSION%...
+docker push %IMAGE_NAME%:%VERSION%
+
+echo Pushing Docker image with tag latest...
+docker push %IMAGE_NAME%:latest
+
+echo Done.
+pause

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

@@ -1,9 +1,25 @@
 version: '3.8'
 services:
   umlautadaptarr:
-    build: .
-    environment:
-      SONARR_HOST: "http://localhost:8989"
-      SONARR_API_KEY: ""
+    #uncomment this to get the development branch
+    #build: https://github.com/PCJones/UmlautAdaptarr.git#develop
+    build: https://github.com/PCJones/UmlautAdaptarr.git#master
+    image: umlautadaptarr
+    restart: unless-stopped
     ports:
-      - "5005:5005" 
+      - "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
+      - SONARR__HOST=http://localhost:8989
+      - SONARR__APIKEY=APIKEY
+      - RADARR__ENABLED=false
+      - RADARR__HOST=http://localhost:7878
+      - RADARR__APIKEY=APIKEY
+      - READARR__ENABLED=false
+      - READARR__HOST=http://localhost:8787
+      - READARR__APIKEY=APIKEY
+      - LIDARR__ENABLED=false
+      - LIDARR__HOST=http://localhost:8686
+      - LIDARR__APIKEY=APIKEY