Update docker compose

This reverts commit 45bc7baa4a.

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,101 @@
 # UmlautAdaptarr
 
-## Testversion kommt in wenigen Tagen
+## English description coming soon
 
-### Kleine Preview
+## Erste Testversion
+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).
+
+Momentan ist docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. 
+
+[Link zum Docker Image](https://hub.docker.com/r/pcjones/umlautadaptarr)
+
+Zusätzlich müsst ihr in Sonarr oder Prowlarr einen neuen Indexer hinzufügen (für jeden Indexer, bei dem UmlautAdapdarr greifen soll).
+
+Am Beispiel von sceneNZBs:
+
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/07c7ca45-e0e5-4a82-af63-365bb23c55c9)
+
+Also alles wie immer, nur dass ihr als API-URL nicht direkt z.B. `https://scenenzbs.com` eingebt, sondern 
+`http://localhost:5005/_/scenenzbs.com`
+
+Den API-Key müsst ihr natürlich auch ganz normal setzen.
+
+## Was macht UmlautAdaptarr überhaupt?
+UmlautAdaptarr löst mehrere Probleme:
+- Releases mit Umlauten werden grundsätzlich nicht korrekt von den *Arrs importiert
+- Releases mit Umlauten werden oft nicht korrekt gefunden (*Arrs suchen nach "o" statt "ö" & es fehlt häufig die korrekte Zuordnung zur Serie/zum Film beim Indexer)
+- 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.
+
+# Wie macht UmlautAdaptarr das?
+UmlautAdaptarr tut so, als wäre es ein Indexer. In Wahrheit schaltet sich UmlautAdaptarr aber nur zwischen die *arrs und den echten Indexer und kann somit die Suchen sowie die Ergebnisse abfangen und bearbeiten.
+Am Ende werden die gefundenen Releases immer so umbenannt, dass die Arrs sie einwandfrei erkennen.
+Einige Beispiele findet ihr unter Features.
+
+
+## Features
+
+| Feature                                                           | Status        |
+|-------------------------------------------------------------------|---------------|
+| Prowlarr & NZB Hydra Support                                                    | ✓|
+| Sonarr Support                                         | ✓             |
+| Lidarr Support                                                    | ✓|
+| Readarr Support                                                   | ✓       |
+| Releases mit deutschem Titel werden erkannt   | ✓             |
+| Releases mit TVDB-Alias Titel werden erkannt  | ✓             |
+| Korrekte Suche und Erkennung von Titel mit Umlauten                            | ✓             |
+| Anfragen-Caching für 5 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
+| Usenet (newznab) Support                                          |✓|
+| Torrent (torznab) Support                                         |✓|
+| Radarr Support                                                    | Geplant       |
+| Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
+| Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
+| Wünsche?                                                          | Vorschläge?   |
+
+## 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:**  
+**Vorher:** Release wird zwar gefunden, kann aber kann nicht zu geordnet werden.
-![Vorherige Suche ohne deutsche Titel](https://i.imgur.com/7pfRzgH.png)  
+![Vorherige Suche ohne deutsche Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/1fce2909-a36c-4f1b-8497-85903357fee3)
-Release wird zwar gefunden, kann aber kann nicht zu geordnet werden.
 
-**Jetzt:**  
+**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://i.imgur.com/k55YIN9.png)  
+![Jetzige Suche mit deutschen Titeln](https://github.com/PCJones/UmlautAdaptarr/assets/377223/0edf43ba-2beb-4f22-aaf4-30f9a619dbd6)
-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.
 
-**Vorher:**  
-![Vorherige Suche, englische Titel](https://i.imgur.com/pbRlOeX.png)  
-Es werden nur Releases mit dem englischen Titel der Serie gefunden
 
-**Jetzt:**  
+**Vorher:** Es werden nur Releases mit dem englischen Titel der Serie gefunden
-![Jetzige Suche, deutsche und englische Titel](https://i.imgur.com/eeq0Voj.png)  
+![Vorherige Suche, englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/ed7ca0fa-ac36-4584-87ac-b29f32dd9ace)
-Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
 
-PS:
+**Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
-Das Problem, dass Prowlarr mit SceneNZBs nicht richtig funktioniert ist damit auch behoben :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,
@@ -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,
+            SearchItem? searchItem
-            string expectedTitle)
+            )
         {
             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/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,89 @@ 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 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 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 +174,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 +198,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+")]
+        [GeneratedRegex(@"\(\d{4}\)$")]
-        private static partial Regex MultipleWhitespaceRegex();
+        private static partial Regex YearAtEndOfTitleRegex();
     }
 }

UmlautAdaptarr/Options/ArrOptions/ArrApplicationBaseOptions.cs

@@ -0,0 +1,23 @@
+namespace UmlautAdaptarr.Options.ArrOptions
+{
+    /// <summary>
+    /// Base Options for ARR applications
+    /// </summary>
+    public class ArrApplicationBaseOptions
+    {
+        /// <summary>
+        /// Indicates whether the Arr application is enabled.
+        /// </summary>
+        public bool Enabled { 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/LidarrInstanceOptions.cs

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

UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs

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

UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs

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

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/Options/Proxy.cs

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

UmlautAdaptarr/Options/ProxyOptions.cs

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

UmlautAdaptarr/Program.cs

@@ -1,7 +1,8 @@
 using System.Net;
-using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Routing;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Utilities;
 
 internal class Program
 {
@@ -10,10 +11,8 @@ internal class Program
         // TODO:
         // add option to sort by nzb age
 
-        // TODO
+    
-        // add delay between requests
+       var builder = WebApplication.CreateBuilder(args);
-
-        var builder = WebApplication.CreateBuilder(args);
 
         var configuration = builder.Configuration;
 
@@ -25,27 +24,45 @@ internal class Program
                 AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.Brotli
             };
 
+            var proxyOptions = configuration.GetSection("Proxy").Get<ProxyOptions>();
+            handler.ConfigureProxy(proxyOptions);
             return handler;
         });
 
         builder.Services.AddMemoryCache(options =>
         {
+            // TODO cache size limit? option?
             //options.SizeLimit = 20000;
-        });        
+        });
+
+
+        // TODO workaround to not log api keys
+        builder.Logging.AddFilter((category, level) =>
+        {
+            // Prevent logging of HTTP request and response if the category is HttpClient
+            if (category.Contains("System.Net.Http.HttpClient") || category.Contains("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
+            {
+                return false;
+            }
+            return true;
+        });
 
         builder.Services.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<IHostedService, HttpProxyService>();
 
         var app = builder.Build();
 
+        GlobalStaticLogger.Initialize(app.Services.GetService<ILoggerFactory>()!);
         app.UseHttpsRedirection();
-
         app.UseAuthorization();
 
         app.MapControllerRoute(name: "caps",

UmlautAdaptarr/Providers/ArrClientFactory.cs

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

UmlautAdaptarr/Providers/LidarrClient.cs

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

UmlautAdaptarr/Providers/ReadarrClient.cs

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

UmlautAdaptarr/Providers/SonarrClient.cs

@@ -1,7 +1,7 @@
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using System.Net.Http;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
@@ -9,12 +9,11 @@ namespace UmlautAdaptarr.Providers
 {
     public class SonarrClient(
         IHttpClientFactory clientFactory,
-        IConfiguration configuration,
         TitleApiService titleService,
+        IOptions<SonarrInstanceOptions> options,
         ILogger<SonarrClient> logger) : ArrClientBase()
     {
-        private readonly string _sonarrHost = configuration.GetValue<string>("SONARR_HOST") ?? throw new ArgumentException("SONARR_HOST environment variable must be set");
+        public SonarrInstanceOptions SonarrOptions { get; } = options.Value;
-        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";
 
         public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
@@ -24,8 +23,7 @@ namespace UmlautAdaptarr.Providers
 
             try
             {
-
+                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
-                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);
@@ -41,6 +39,7 @@ namespace UmlautAdaptarr.Providers
                             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
                         (
@@ -73,7 +72,7 @@ namespace UmlautAdaptarr.Providers
 
             try
             {
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
+                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
                 logger.LogInformation($"Fetching item by external ID from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
                 var response = await httpClient.GetStringAsync(sonarrUrl);
                 var shows = JsonConvert.DeserializeObject<dynamic>(response);
@@ -100,7 +99,7 @@ namespace UmlautAdaptarr.Providers
                         mediaType: _mediaType
                     );
 
-                    logger.LogInformation($"Successfully fetched show {searchItem} from Sonarr.");
+                    logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
                     return searchItem;
                 }
             }
@@ -125,7 +124,7 @@ namespace UmlautAdaptarr.Providers
                     return null;
                 }
 
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
+                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
                 var sonarrApiResponse = await httpClient.GetStringAsync(sonarrUrl);
                 var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
 
@@ -158,7 +157,7 @@ namespace UmlautAdaptarr.Providers
                     mediaType: _mediaType
                 );
 
-                logger.LogInformation($"Successfully fetched show {searchItem} from Sonarr.");
+                logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
                 return searchItem;
             }
             catch (Exception ex)

UmlautAdaptarr/Services/ArrSyncBackgroundService.cs

@@ -13,53 +13,123 @@ namespace UmlautAdaptarr.Services
 {
     public class ArrSyncBackgroundService(
         SonarrClient sonarrClient,
+        LidarrClient lidarrClient,
+        ReadarrClient readarrClient,
         CacheService cacheService,
         ILogger<ArrSyncBackgroundService> logger) : BackgroundService
     {
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             logger.LogInformation("ArrSyncBackgroundService is starting.");
+            bool lastRunSuccess = true;
 
             while (!stoppingToken.IsCancellationRequested)
             {
                 logger.LogInformation("ArrSyncBackgroundService is running.");
-                await FetchAndUpdateDataAsync();
+                var syncSuccess = await FetchAndUpdateDataAsync();
                 logger.LogInformation("ArrSyncBackgroundService has completed an iteration.");
 
-                await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
+                if (syncSuccess)
+                {
+                    lastRunSuccess = true;
+                    await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
+                }
+                else
+                {
+                    if (lastRunSuccess)
+                    {
+                        lastRunSuccess = false;
+                        logger.LogInformation("ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
+                        await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
+                    }
+                    else
+                    {
+                        logger.LogInformation("ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
+                        await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
+                    }
+                }
             }
 
             logger.LogInformation("ArrSyncBackgroundService is stopping.");
         }
 
-        private async Task FetchAndUpdateDataAsync()
+        private async Task<bool> FetchAndUpdateDataAsync()
         {
             try
             {
-                await FetchItemsFromSonarrAsync();
+                var success = true;
+                if (readarrClient.ReadarrOptions.Enabled)
+                {
+                    var syncSuccess = await FetchItemsFromReadarrAsync();
+                    success = success && syncSuccess;
+                }
+                if (sonarrClient.SonarrOptions.Enabled)
+                {
+                    var syncSuccess = await FetchItemsFromSonarrAsync();
+                    success = success && syncSuccess;
+                }
+                if (lidarrClient.LidarrOptions.Enabled)
+                {
+                    var syncSuccess = await FetchItemsFromLidarrAsync();
+                    success = success && syncSuccess;
+                }
+                return success;
             }
             catch (Exception ex)
             {
                 logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
             }
+            return false;
         }
 
-        private async Task FetchItemsFromSonarrAsync()
+        private async Task<bool> FetchItemsFromSonarrAsync()
         {
             try
             {
                 var items = await sonarrClient.FetchAllItemsAsync();
                 UpdateSearchItems(items);
+                return items?.Any()?? false;
             }
             catch (Exception ex)
             {
                 logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
             }
+            return false;
         }
 
-        private void UpdateSearchItems(IEnumerable<SearchItem> searchItems)
+        private async Task<bool> FetchItemsFromLidarrAsync()
         {
-            foreach (var searchItem in searchItems)
+            try
+            {
+                var items = await lidarrClient.FetchAllItemsAsync();
+                UpdateSearchItems(items);
+                return items?.Any() ?? false;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
+            }
+            return false;
+        }
+
+        private async Task<bool> FetchItemsFromReadarrAsync()
+        {
+            try
+            {
+                var items = await readarrClient.FetchAllItemsAsync();
+                UpdateSearchItems(items);
+                return items?.Any() ?? false;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
+            }
+            return false;
+        }
+
+        private void UpdateSearchItems(IEnumerable<SearchItem>? searchItems)
+        {
+            foreach (var searchItem in searchItems ?? [])
             {
                 try
                 {

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();
+            var cacheKey = $"{prefix}_extid_{item.ExternalId}";
-            // TODO maybe we need to also add the media type (movie/book/show etc)
+            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 normalizedVariation = variation.RemoveAccentButKeepGermanUmlauts().ToLower();
-                var cacheKey = $"{prefix}_var_{normalizedVariation}";
+                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/HttpProxyService.cs

@@ -0,0 +1,163 @@
+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;
+
+        public HttpProxyService(ILogger<HttpProxyService> logger, IHttpClientFactory clientFactory)
+        {
+            _logger = logger;
+            _clientFactory = clientFactory;
+        }
+
+        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, 0, buffer.Length);
+            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 targetInfo = ParseTargetInfo(requestString);
+            if (targetInfo.host != "prowlarr.servarr.com")
+            {
+                _logger.LogWarning($"IMPORTANT! {Environment.NewLine} Indexer {targetInfo.host} needs to be set to http:// instead of https:// {Environment.NewLine}" +
+                    $"UmlautAdaptarr will not work for {targetInfo.host}!");
+            }
+            using var targetSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+            try
+            {
+                await targetSocket.ConnectAsync(targetInfo.host, targetInfo.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]);
+                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(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
+            foreach (var line in lines.Skip(1)) // Skip the request line
+            {
+                var colonIndex = line.IndexOf(':');
+                if (colonIndex > 0)
+                {
+                    var key = line.Substring(0, colonIndex).Trim();
+                    var value = line.Substring(colonIndex + 1).Trim();
+                    headers[key] = value;
+                }
+            }
+            return headers;
+        }
+
+        private (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 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

@@ -3,7 +3,10 @@ using UmlautAdaptarr.Providers;
 
 namespace UmlautAdaptarr.Services
 {
-    public class SearchItemLookupService(CacheService cacheService, SonarrClient sonarrClient)
+    public class SearchItemLookupService(CacheService cacheService,
+                                         SonarrClient sonarrClient,
+                                         ReadarrClient readarrClient,
+                                         LidarrClient lidarrClient)
     {
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
@@ -19,9 +22,25 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                    if (sonarrClient.SonarrOptions.Enabled)
+                    {
+                        fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                    }
+                    break;
+                case "audio":
+                    if (lidarrClient.LidarrOptions.Enabled)
+                    {
+                        await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                    }
+                    break;
+                case "book":
+                    if (readarrClient.ReadarrOptions.Enabled)
+                    {
+                        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 +66,14 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
+                    if (sonarrClient.SonarrOptions.Enabled)
+                    {
+                        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 +87,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"]
+        public GlobalOptions Options { get; } = options.Value;
-                                                         ?? throw new ArgumentException("UmlautAdaptarrApiHost must be set in appsettings.json");
+
         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 = searchItem == null;
-            bool useCacheService = string.IsNullOrEmpty(expectedTitle) || titleMatchVariations?.Length == 0;
 
             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);
+                        searchItem = cacheService.SearchItemByTitle(mediaType, cleanTitleSeperatedBySpace);
-                        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;
-                        }
                     }
 
-                    // Attempt to find a variation that matches the start of the original title
+                    if (searchItem == null)
-                    foreach (var variation in titleMatchVariations!)
                     {
-                        // Skip variations that are already the expectedTitle
+                        // Skip processing this item if no matching SearchItem is found
-                        if (variation == expectedTitle)
+                        continue;
-                        {
+                    }
-                            continue;
-                        }
 
-                        // Variation is already normalized at creation
+                    switch (mediaType)
-                        var pattern = "^" + Regex.Escape(variation).Replace("\\ ", "[._ ]");
+                    {
-
+                        case "tv":
-                        // Check if the originalTitle starts with the variation (ignoring case and separators)
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
-                        if (Regex.IsMatch(normalizedOriginalTitle, pattern, RegexOptions.IgnoreCase))
+                            break;
-                        {
+                        case "movie":
-                            // Find the first separator used in the original title for consistent replacement
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
-                            var separator = FindFirstSeparator(originalTitle);
+                            break;
-                            // Reconstruct the expected title using the original separator
+                        case "audio":
-                            var newTitlePrefix = expectedTitle!.Replace(" ", separator.ToString());
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
-
+                            break;
-                            // Extract the suffix from the original title starting right after the matched variation length
+                        case "book":
-                            var variationLength = variation.Length;
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
-                            var suffix = originalTitle[Math.Min(variationLength, originalTitle.Length)..];
+                            break;
-
+                        default:
-                            // Clean up any leading separators from the suffix
+                            throw new NotImplementedException();
-                            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
-                        }
                     }
                 }
             }
@@ -101,10 +66,175 @@ namespace UmlautAdaptarr.Services
             return xDoc.ToString();
         }
 
-
+        public void FindAndReplaceForBooksAndAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
-        private static string NormalizeTitle(string title)
+        {
+            var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+            var titleMatch = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+
+            if (authorMatch.foundMatch && titleMatch.foundMatch)
+            {
+                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, titleMatch.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 (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 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 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) ? "" : 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 string ReplaceSeperatorsWithSpace(string title)
         {
-            title = title.RemoveAccentButKeepGermanUmlauts();
             // Replace all known separators with space for normalization
             return WordSeperationCharRegex().Replace(title, " ".ToString());
         }
@@ -112,12 +242,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 +262,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 +289,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,6 +9,8 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <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" />
   </ItemGroup>

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 NoSpecialCharactersExceptHypenRegex().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 NoSpecialCharactersExceptHypenRegex();
+
+        [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/ProxyExtension.cs

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

UmlautAdaptarr/Utilities/ServicesExtensions.cs

@@ -0,0 +1,92 @@
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Services;
+
+namespace UmlautAdaptarr.Utilities
+{
+    /// <summary>
+    /// Extension methods for configuring services related to ARR Applications
+    /// </summary>
+    public static class ServicesExtensions
+    {
+
+        /// <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>();
+            if (options == null)
+            {
+                throw new InvalidOperationException($"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
+            }
+
+            builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
+            builder.Services.AddSingleton<TService>();
+            return builder;
+        }
+
+        /// <summary>
+        /// Adds support for Sonarr with default options and client.
+        /// </summary>
+        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
+        public static WebApplicationBuilder AddSonarrSupport(this WebApplicationBuilder builder)
+        {
+            return builder.AddServiceWithOptions<SonarrInstanceOptions, SonarrClient>("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.AddServiceWithOptions<LidarrInstanceOptions, LidarrClient>("Lidarr");
+        }
+
+        /// <summary>
+        /// Adds support for Readarr with default options and client.
+        /// </summary>
+        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
+        public static WebApplicationBuilder AddReadarrSupport(this WebApplicationBuilder builder)
+        {
+            return builder.AddServiceWithOptions<ReadarrInstanceOptions, ReadarrClient>("Readarr");
+        }
+
+        /// <summary>
+        /// Adds a title lookup service to the service collection.
+        /// </summary>
+        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
+        public static WebApplicationBuilder AddTitleLookupService(this WebApplicationBuilder builder)
+        {
+            return builder.AddServiceWithOptions<GlobalOptions, TitleApiService>("Settings");
+        }
+
+        /// <summary>
+        /// Adds a proxy request service to the service collection.
+        /// </summary>
+        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
+        public static WebApplicationBuilder AddProxyRequestService(this WebApplicationBuilder builder)
+        {
+            return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
+        }
+    }
+}

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/appsettings.json

@@ -3,18 +3,64 @@
     "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__Enabled: true (set to false to disable)
+    // - Sonarr__Host: your_sonarr_host_url
+    // - Sonarr__ApiKey: your_sonarr_api_key
+    "Enabled": false,
+    "Host": "your_sonarr_host_url",
+    "ApiKey": "your_sonarr_api_key"
+  },
+  "Lidarr": {
+    // Docker Environment Variables:
+    // - Lidarr__Enabled: true (set to false to disable)
+    // - Lidarr__Host: your_lidarr_host_url
+    // - Lidarr__ApiKey: your_lidarr_api_key
+    "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"
+  },
+
+  // Docker Environment Variables:
+  // - Proxy__Enabled: true (set to false to disable)
+  // - Proxy__Address: http://yourproxyaddress:port
+  // - Proxy__Username: your_proxy_username
+  // - Proxy__Password: your_proxy_password
+  // - Proxy__BypassOnLocal: true (set to false to not bypass local IP addresses)
+  "Proxy": {
+    "Enabled": false,
+    "Address": "http://yourproxyaddress:port",
+    "Username": "your_proxy_username",
+    "Password": "your_proxy_password",
+    "BypassOnLocal": true
   }
 }

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

docker-compose.yml

@@ -1,9 +1,27 @@
 version: '3.8'
 services:
   umlautadaptarr:
-    build: .
+    #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
     environment:
-      SONARR_HOST: "http://localhost:8989"
+      - TZ=Europe/Berlin
-      SONARR_API_KEY: ""
+      - SONARR__ENABLED=false
-    ports:
+      - SONARR__HOST=http://localhost:8989
-      - "5005:5005" 
+      - 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
+      #- Proxy__Enabled: false
+      #- Proxy__Address: http://yourproxyaddress:port
+      #- Proxy__Username: your_proxy_username
+      #- Proxy__Password: your_proxy_password
+      #- Proxy__BypassOnLocal: true (set to false to not bypass local IP addresses)