Update docker compose

Forward user-agent when using http proxy
Change warning text
2024-04-15 04:25:21 +02:00 · 2024-04-15 03:42:20 +02:00 · 2024-04-15 03:21:51 +02:00 · 2024-04-15 03:20:36 +02:00 · 2024-04-15 03:17:14 +02:00 · 2024-04-15 03:05:09 +02:00
33 changed files with 1184 additions and 376 deletions
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 ## 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 und Lidarr schon Auswirkungen (abgesehen vom Caching).
+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. 

@@ -30,7 +30,7 @@ UmlautAdaptarr löst mehrere Probleme:

 # 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, das die Arrs sie einwandfrei erkennen.
+Am Ende werden die gefundenen Releases immer so umbenannt, dass die Arrs sie einwandfrei erkennen.
 Einige Beispiele findet ihr unter Features.


@@ -38,15 +38,17 @@ Einige Beispiele findet ihr unter Features.

 | Feature                                                           | Status        |
 |-------------------------------------------------------------------|---------------|
-| Prowlarr Support                                                    | ✓|
+| 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       |
-| Readarr Support                                                   | Geplant       |
 | Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
 | Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
 | Wünsche?                                                          | Vorschläge?   |
@@ -55,16 +57,18 @@ Einige Beispiele findet ihr unter Features.
 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:** 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)

 **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)
+

 **Vorher:** Es werden nur Releases mit dem englischen Titel der Serie gefunden
-![Vorherige Suche, englische Titel](https://i.imgur.com/pbRlOeX.png)  
+![Vorherige Suche, englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/ed7ca0fa-ac36-4584-87ac-b29f32dd9ace)

 **Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
-![Jetzige Suche, deutsche und englische Titel](https://i.imgur.com/eeq0Voj.png)  
+![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`.

@@ -83,9 +87,13 @@ Sonarr erwartet immer den Englischen Namen, der hier natürlich nicht gegeben is
 ## Kontakt & Support
 - Öffne gerne ein Issue auf GitHub falls du Unterstützung benötigst.
 - [Telegram](https://t.me/pc_jones)
- Discord: pcjones1
- Reddit: /u/IreliaIsLife
+- 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
--- a/UmlautAdaptarr/Controllers/CapsController.cs
+++ b/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 ?
--- a/UmlautAdaptarr/Controllers/SearchController.cs
+++ b/UmlautAdaptarr/Controllers/SearchController.cs
@@ -6,9 +6,10 @@ 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,
@@ -52,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;
@@ -95,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 ?
@@ -129,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
@@ -151,11 +152,12 @@ 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[] AUDIO_CATEGORY_IDS = ["3000", "3010", "3020", "3040", "3050"];
+        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)
@@ -180,11 +182,18 @@ namespace UmlautAdaptarr.Controllers
            {
                if (queryParameters.TryGetValue("cat", out string? categories) && !string.IsNullOrEmpty(categories))
                {
-                    // Search for audio
-                    if (categories.Split(',').Any(category => AUDIO_CATEGORY_IDS.Contains(category)))
+                    // 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.ToLower());
+                        searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.GetLidarrTitleForExternalId());
                    }
                }
            }
--- a/UmlautAdaptarr/Models/SearchItem.cs
+++ b/UmlautAdaptarr/Models/SearchItem.cs
@@ -12,6 +12,7 @@ namespace UmlautAdaptarr.Models
        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; }
@@ -36,63 +37,134 @@ namespace UmlautAdaptarr.Models
            ExpectedAuthor = expectedAuthor;
            GermanTitle = germanTitle;
            MediaType = mediaType;
-            if (mediaType == "audio" && expectedAuthor != null)
+            if ((mediaType == "audio" || mediaType == "book") && expectedAuthor != null)
            {
-                // e.g. Die Ärzte - best of die Ärzte
-                if (expectedTitle.Contains(expectedAuthor))
-                {
-                    var titleWithoutAuthorName = expectedTitle.Replace(expectedAuthor, string.Empty).RemoveExtraWhitespaces().Trim();
-                    TitleMatchVariations = GenerateVariations(titleWithoutAuthorName, mediaType).ToArray();
-                }
-                else
-                {
-                    TitleMatchVariations = GenerateVariations(expectedTitle, mediaType).ToArray();
-                }
-                TitleSearchVariations = GenerateVariations($"{expectedAuthor} {expectedTitle}", mediaType).ToArray();
-                AuthorMatchVariations = GenerateVariations(expectedAuthor, mediaType).ToArray();
+                GenerateVariationsForBooksAndAudio(expectedTitle, mediaType, expectedAuthor);
            }
            else
            {
-                TitleSearchVariations = GenerateVariations(germanTitle, mediaType).ToArray();
-
-                var allTitleVariations = new List<string>(TitleSearchVariations);
-
-                // If aliases are not null, generate variations for each and add them to the list
-                // TODO (not necessarily here) only use deu and eng alias
-                if (aliases != null)
+                // 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)
                {
-                    foreach (var alias in aliases)
+                    string year = yearAtEndOfTitleMatch.Value[1..^1];
+                    if (GermanTitle != null && !GermanTitle.Contains(year))
                    {
-                        allTitleVariations.AddRange(GenerateVariations(alias, mediaType));
+                        GermanTitle = $"{germanTitle} {year}";
+                    }
+
+                    if (aliases != null)
+                    {
+                        for (int i = 0; i < aliases.Length; i++)
+                        {
+                            if (!aliases[i].Contains(year))
+                            {
+                                aliases[i] = $"{aliases[i]} {year}";
+                            }
+                        }
                    }
                }

-                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));
-
-                }
-
-                TitleMatchVariations = allTitleVariations.Distinct().ToArray();
+                GenerateVariationsForTV(GermanTitle, mediaType, aliases);
            }
        }

-        private IEnumerable<string> GenerateVariations(string? germanTitle, string mediaType)
+        private void GenerateVariationsForTV(string? germanTitle, string mediaType, string[]? aliases)
        {
-            if (germanTitle == null)
+            TitleSearchVariations = GenerateVariations(germanTitle, mediaType).ToArray();
+
+            var allTitleVariations = new List<string>(TitleSearchVariations);
+
+            // If aliases are not null, generate variations for each and add them to the list
+            // TODO (not necessarily here) only use deu and eng alias
+            if (aliases != null)
+            {
+                foreach (var alias in aliases)
+                {
+                    allTitleVariations.AddRange(GenerateVariations(alias, mediaType));
+
+                    // If title contains ":" also match for "-"
+                    if (alias.Contains(':'))
+                    {
+                        allTitleVariations.Add(alias.Replace(":", " -"));
+                    }
+                }
+            }
+
+            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 void GenerateVariationsForBooksAndAudio(string expectedTitle, string mediaType, string? expectedAuthor)
+        {
+            // 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().GetCleanTitle();

            // Start with base variations including handling umlauts
            var baseVariations = new List<string>
@@ -102,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('-'))
@@ -121,17 +198,26 @@ namespace UmlautAdaptarr.Models
                });
            }

-            // If a german title starts with der/die/das also accept variations without it
-            if (mediaType != "audio" && cleanTitle.StartsWith("Der") || cleanTitle.StartsWith("Die") || cleanTitle.StartsWith("Das"))
+            // 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 = germanTitle[3..].Trim();
+                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 => variation.RemoveExtraWhitespaces());

            return cleanedVariations.Distinct();
        }
+
+        [GeneratedRegex(@"\(\d{4}\)$")]
+        private static partial Regex YearAtEndOfTitleRegex();
    }
 }
--- a/UmlautAdaptarr/Options/ArrOptions/ArrApplicationBaseOptions.cs
+++ b/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; }
+    }
+}
--- a/UmlautAdaptarr/Options/ArrOptions/LidarrInstanceOptions.cs
+++ b/UmlautAdaptarr/Options/ArrOptions/LidarrInstanceOptions.cs
@@ -0,0 +1,9 @@
+namespace UmlautAdaptarr.Options.ArrOptions
+{
+    /// <summary>
+    /// Lidarr Options
+    /// </summary>
+    public class LidarrInstanceOptions : ArrApplicationBaseOptions
+    {
+    }
+}
--- a/UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs
+++ b/UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs
@@ -0,0 +1,9 @@
+namespace UmlautAdaptarr.Options.ArrOptions
+{
+    /// <summary>
+    /// Readarr Options
+    /// </summary>
+    public class ReadarrInstanceOptions : ArrApplicationBaseOptions
+    {
+    }
+}
--- a/UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs
+++ b/UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs
@@ -0,0 +1,9 @@
+namespace UmlautAdaptarr.Options.ArrOptions
+{
+    /// <summary>
+    /// Sonarr Options
+    /// </summary>
+    public class SonarrInstanceOptions : ArrApplicationBaseOptions
+    {
+    }
+}
--- a/UmlautAdaptarr/Options/GlobalOptions.cs
+++ b/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; }
+    }
+}
--- a/UmlautAdaptarr/Options/Proxy.cs
+++ b/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; }
+}
--- a/UmlautAdaptarr/Options/ProxyOptions.cs
+++ b/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; }
+}
--- a/UmlautAdaptarr/Program.cs
+++ b/UmlautAdaptarr/Program.cs
@@ -1,8 +1,8 @@
-using Microsoft.Extensions.Configuration;
 using System.Net;
-using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Routing;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Utilities;

 internal class Program
 {
@@ -24,11 +24,14 @@ 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;
        });

@@ -46,18 +49,20 @@ internal class Program

        builder.Services.AddControllers();
        builder.Services.AddHostedService<ArrSyncBackgroundService>();
-        builder.Services.AddSingleton<TitleApiService>();
+        builder.AddTitleLookupService();
        builder.Services.AddSingleton<SearchItemLookupService>();
        builder.Services.AddSingleton<TitleMatchingService>();
-        builder.Services.AddSingleton<SonarrClient>();
-        builder.Services.AddSingleton<LidarrClient>();
+        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",
--- a/UmlautAdaptarr/Providers/ArrClientFactory.cs
+++ b/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());
+            }
+        }
+    }
+}
--- a/UmlautAdaptarr/Providers/LidarrClient.cs
+++ b/UmlautAdaptarr/Providers/LidarrClient.cs
@@ -1,7 +1,9 @@
 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;

@@ -9,13 +11,11 @@ namespace UmlautAdaptarr.Providers
 {
    public class LidarrClient(
        IHttpClientFactory clientFactory,
-        IConfiguration configuration,
        CacheService cacheService,
        IMemoryCache cache,
-        ILogger<LidarrClient> logger) : ArrClientBase()
+        ILogger<LidarrClient> logger, IOptions<LidarrInstanceOptions> options) : ArrClientBase()
    {
-        private readonly string _lidarrHost = configuration.GetValue<string>("LIDARR_HOST") ?? throw new ArgumentException("LIDARR_HOST environment variable must be set");
-        private readonly string _lidarrApiKey = configuration.GetValue<string>("LIDARR_API_KEY") ?? throw new ArgumentException("LIDARR_API_KEY environment variable must be set");
+        public LidarrInstanceOptions LidarrOptions { get; } = options.Value;
        private readonly string _mediaType = "audio";

        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
@@ -25,7 +25,7 @@ namespace UmlautAdaptarr.Providers

            try
            {
-                var lidarrArtistsUrl = $"{_lidarrHost}/api/v1/artist?apikey={_lidarrApiKey}";
+                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);
@@ -40,18 +40,20 @@ namespace UmlautAdaptarr.Providers
                {
                    var artistId = (int)artist.id;

-                    var lidarrAlbumUrl = $"{_lidarrHost}/api/v1/album?artistId={artistId}&apikey={_lidarrApiKey}";
+                    var lidarrAlbumUrl = $"{LidarrOptions.Host}/api/v1/album?artistId={artistId}&apikey={LidarrOptions.ApiKey}";

-                    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(lidarrArtistsUrl)}");
-                        var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
-                        albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
-                    }
+                    // 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)
                    {
@@ -74,7 +76,7 @@ namespace UmlautAdaptarr.Providers
                        string[]? aliases = null;

                        // Abuse externalId to set the search string Lidarr uses
-                        var externalId = expectedTitle.RemoveGermanUmlautDots().RemoveAccent().RemoveSpecialCharacters().RemoveExtraWhitespaces().ToLower();
+                        var externalId = expectedTitle.GetLidarrTitleForExternalId();

                        var searchItem = new SearchItem
                        (
@@ -107,6 +109,7 @@ namespace UmlautAdaptarr.Providers
            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 ?? [])
                {
@@ -132,7 +135,7 @@ namespace UmlautAdaptarr.Providers
        {
            try
            {
-               // this should never be called at the moment
+                // this should never be called at the moment
                throw new NotImplementedException();
            }
            catch (Exception ex)
--- a/UmlautAdaptarr/Providers/ReadarrClient.cs
+++ b/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;
+        }
+    }
+}
--- a/UmlautAdaptarr/Providers/SonarrClient.cs
+++ b/UmlautAdaptarr/Providers/SonarrClient.cs
@@ -1,5 +1,7 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;

@@ -7,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");
-        private readonly string _sonarrApiKey = configuration.GetValue<string>("SONARR_API_KEY") ?? throw new ArgumentException("SONARR_API_KEY environment variable must be set");
+        public SonarrInstanceOptions SonarrOptions { get; } = options.Value;
        private readonly string _mediaType = "tv";

        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
@@ -22,8 +23,7 @@ namespace UmlautAdaptarr.Providers

            try
            {
-
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?includeSeasonImages=false&apikey={_sonarrApiKey}";
+                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
                logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
                var response = await httpClient.GetStringAsync(sonarrUrl);
                var shows = JsonConvert.DeserializeObject<List<dynamic>>(response);
@@ -39,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
                        (
@@ -71,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);
@@ -98,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;
                }
            }
@@ -123,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);

@@ -156,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)
--- a/UmlautAdaptarr/Services/ArrSyncBackgroundService.cs
+++ b/UmlautAdaptarr/Services/ArrSyncBackgroundService.cs
@@ -14,15 +14,14 @@ namespace UmlautAdaptarr.Services
    public class ArrSyncBackgroundService(
        SonarrClient sonarrClient,
        LidarrClient lidarrClient,
+        ReadarrClient readarrClient,
        CacheService cacheService,
-        IConfiguration configuration,
        ILogger<ArrSyncBackgroundService> logger) : BackgroundService
    {
-        private readonly bool _sonarrEnabled = configuration.GetValue<bool>("SONARR_ENABLED");
-        private readonly bool _lidarrEnabled = configuration.GetValue<bool>("LIDARR_ENABLED");
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            logger.LogInformation("ArrSyncBackgroundService is starting.");
+            bool lastRunSuccess = true;

            while (!stoppingToken.IsCancellationRequested)
            {
@@ -32,12 +31,22 @@ namespace UmlautAdaptarr.Services

                if (syncSuccess)
                {
+                    lastRunSuccess = true;
                    await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
                }
                else
                {
-                    logger.LogInformation("ArrSyncBackgroundService is sleeping for one hour only because not all syncs were successful.");
-                    await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
+                    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);
+                    }
                }
            }

@@ -49,13 +58,20 @@ namespace UmlautAdaptarr.Services
            try
            {
                var success = true;
-                if (_sonarrEnabled)
+                if (readarrClient.ReadarrOptions.Enabled)
                {
-                    success = await FetchItemsFromSonarrAsync();
+                    var syncSuccess = await FetchItemsFromReadarrAsync();
+                    success = success && syncSuccess;
                }
-                if (_lidarrEnabled)
+                if (sonarrClient.SonarrOptions.Enabled)
                {
-                    success = await FetchItemsFromLidarrAsync();
+                    var syncSuccess = await FetchItemsFromSonarrAsync();
+                    success = success && syncSuccess;
+                }
+                if (lidarrClient.LidarrOptions.Enabled)
+                {
+                    var syncSuccess = await FetchItemsFromLidarrAsync();
+                    success = success && syncSuccess;
                }
                return success;
            }
@@ -96,6 +112,21 @@ namespace UmlautAdaptarr.Services
            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 ?? [])
--- a/UmlautAdaptarr/Services/CacheService.cs
+++ b/UmlautAdaptarr/Services/CacheService.cs
@@ -10,6 +10,7 @@ namespace UmlautAdaptarr.Services
    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;

@@ -23,6 +24,11 @@ namespace UmlautAdaptarr.Services
                CacheAudioSearchItem(item, cacheKey);
                return;
            }
+            else if (item.MediaType == "book")
+            {
+                    CacheBookSearchItem(item, cacheKey);
+                    return;
+            }

            var normalizedTitle = item.Title.RemoveAccentButKeepGermanUmlauts().ToLower();

@@ -61,42 +67,80 @@ namespace UmlautAdaptarr.Services
            }
        }

+        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")
+            if (mediaType == "audio" || mediaType == "book")
            {
-                return FindBestMatchForAudio(normalizedTitle.NormalizeForComparison());
+                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)
@@ -126,9 +170,11 @@ namespace UmlautAdaptarr.Services
            return item;
        }

-        private SearchItem? FindBestMatchForAudio(string normalizedOriginalTitle)
+        private SearchItem? FindBestMatchForBooksAndAudio(string normalizedOriginalTitle, string mediaType)
        {
-            foreach (var authorEntry in AudioVariationIndex)
+            var index = mediaType == "audio" ? AudioVariationIndex : BookVariationIndex;
+            
+            foreach (var authorEntry in index)
            {
                if (normalizedOriginalTitle.Contains(authorEntry.Key))
                {
--- a/UmlautAdaptarr/Services/HttpProxyService.cs
+++ b/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;
+        }
+    }
+}
--- a/UmlautAdaptarr/Services/ProxyRequestService.cs
+++ b/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}")
--- a/UmlautAdaptarr/Services/SearchItemLookupService.cs
+++ b/UmlautAdaptarr/Services/SearchItemLookupService.cs
@@ -3,10 +3,11 @@ using UmlautAdaptarr.Providers;

 namespace UmlautAdaptarr.Services
 {
-    public class SearchItemLookupService(CacheService cacheService, SonarrClient sonarrClient, LidarrClient lidarrClient, IConfiguration configuration)
+    public class SearchItemLookupService(CacheService cacheService,
+                                         SonarrClient sonarrClient,
+                                         ReadarrClient readarrClient,
+                                         LidarrClient lidarrClient)
    {
-        private readonly bool _sonarrEnabled = configuration.GetValue<bool>("SONARR_ENABLED");
-        private readonly bool _lidarrEnabled = configuration.GetValue<bool>("LIDARR_ENABLED");
        public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
        {
            // Attempt to get the item from the cache first
@@ -21,15 +22,23 @@ namespace UmlautAdaptarr.Services
            switch (mediaType)
            {
                case "tv":
-                    if (_sonarrEnabled)
+                    if (sonarrClient.SonarrOptions.Enabled)
                    {
                        fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
                    }
                    break;
                case "audio":
-                    if (_lidarrEnabled)
+                    if (lidarrClient.LidarrOptions.Enabled)
                    {
-                        fetchedItem = await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                        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;
            }
@@ -57,13 +66,15 @@ namespace UmlautAdaptarr.Services
            switch (mediaType)
            {
                case "tv":
-                    if (_sonarrEnabled)
+                    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.
            }

--- a/UmlautAdaptarr/Services/TitleApiService.cs
+++ b/UmlautAdaptarr/Services/TitleApiService.cs
@@ -1,24 +1,28 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Utilities;

 namespace UmlautAdaptarr.Services
 {
-    public class TitleApiService(IHttpClientFactory clientFactory, IConfiguration configuration, ILogger<TitleApiService> logger)
+    public class TitleApiService(IHttpClientFactory clientFactory, ILogger<TitleApiService> logger, IOptions<GlobalOptions> options)
    {
-        private readonly string _umlautAdaptarrApiHost = configuration["Settings:UmlautAdaptarrApiHost"]
-                                                         ?? throw new ArgumentException("UmlautAdaptarrApiHost must be set in appsettings.json");
+        public GlobalOptions Options { get; } = options.Value;
+
        private DateTime lastRequestTime = DateTime.MinValue;

        private async Task EnsureMinimumDelayAsync()
        {
            var sinceLastRequest = DateTime.Now - lastRequestTime;
-            if (sinceLastRequest < TimeSpan.FromSeconds(2))
+            if (sinceLastRequest < TimeSpan.FromSeconds(1))
            {
-                await Task.Delay(TimeSpan.FromSeconds(2) - sinceLastRequest);
+                await Task.Delay(TimeSpan.FromSeconds(1) - sinceLastRequest);
            }
            lastRequestTime = DateTime.Now;
        }

+        // TODO add cache, TODO add bulk request
        public async Task<(string? germanTitle, string[]? aliases)> FetchGermanTitleAndAliasesByExternalIdAsync(string mediaType, string externalId)
        {
            try
@@ -26,7 +30,8 @@ namespace UmlautAdaptarr.Services
                await EnsureMinimumDelayAsync();

                var httpClient = clientFactory.CreateClient();
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
+                var titleApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
+                logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                var response = await httpClient.GetStringAsync(titleApiUrl);
                var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(response);

@@ -71,7 +76,8 @@ namespace UmlautAdaptarr.Services

                var httpClient = clientFactory.CreateClient();
                var tvdbCleanTitle = title.Replace("ß", "ss");
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
+                var titleApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
+                logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                var titleApiResponse = await httpClient.GetStringAsync(titleApiUrl);
                var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);

--- a/UmlautAdaptarr/Services/TitleMatchingService.cs
+++ b/UmlautAdaptarr/Services/TitleMatchingService.cs
@@ -20,7 +20,7 @@ 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;
@@ -34,7 +34,7 @@ namespace UmlautAdaptarr.Services
                    if (useCacheService)
                    {
                        // Use CacheService to find a matching SearchItem by title
-                        searchItem = cacheService.SearchItemByTitle(mediaType, normalizedOriginalTitle);
+                        searchItem = cacheService.SearchItemByTitle(mediaType, cleanTitleSeperatedBySpace);
                    }

                    if (searchItem == null)
@@ -46,13 +46,16 @@ namespace UmlautAdaptarr.Services
                    switch (mediaType)
                    {
                        case "tv":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, normalizedOriginalTitle!);
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                            break;
                        case "movie":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, normalizedOriginalTitle!);
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                            break;
                        case "audio":
-                            FindAndReplaceForAudio(searchItem, titleElement, originalTitle!);
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
+                            break;
+                        case "book":
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
                            break;
                        default:
                            throw new NotImplementedException();
@@ -63,18 +66,17 @@ namespace UmlautAdaptarr.Services
            return xDoc.ToString();
        }

-        public void FindAndReplaceForAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
+        public void FindAndReplaceForBooksAndAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
        {
            var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
            var titleMatch = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);

-            if (authorMatch.Item1 && titleMatch.Item1)
+            if (authorMatch.foundMatch && titleMatch.foundMatch)
            {
-                int matchEndPositionInOriginal = Math.Max(authorMatch.Item3, titleMatch.Item3);
+                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, titleMatch.bestEndInOriginal);

-                var test = originalTitle[matchEndPositionInOriginal];
                // Check and adjust for immediate following delimiter
-                char[] delimiters = new char[] { ' ', '-', '_', '.' };
+                char[] delimiters = [' ', '-', '_', '.'];
                if (matchEndPositionInOriginal < originalTitle.Length && delimiters.Contains(originalTitle[matchEndPositionInOriginal]))
                {
                    matchEndPositionInOriginal++; // Skip the delimiter if it's immediately after the match
@@ -84,7 +86,11 @@ namespace UmlautAdaptarr.Services
                string suffix = originalTitle[matchEndPositionInOriginal..].TrimStart([' ', '-', '_', '.']).Trim();

                // Concatenate the expected title with the remaining suffix
-                var updatedTitle = $"{searchItem.ExpectedAuthor} - {searchItem.ExpectedTitle}-[{suffix}]";
+                var updatedTitle = $"{searchItem.ExpectedAuthor} - {searchItem.ExpectedTitle}";
+                if (suffix.Length >= 3)
+                {
+                    updatedTitle += $"-[{suffix}]";
+                }

                // Update the title element
                titleElement.Value = updatedTitle;
@@ -92,12 +98,12 @@ namespace UmlautAdaptarr.Services
            }
            else
            {
-                logger.LogInformation("TitleMatchingService - No satisfactory fuzzy match found for both author and title.");
+                logger.LogDebug($"TitleMatchingService - No satisfactory fuzzy match found for both author and title for {originalTitle}.");
            }
        }


-        private Tuple<bool, int, int> FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
+        private (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
        {
            bool found = false;
            int bestStart = int.MaxValue;
@@ -120,8 +126,8 @@ namespace UmlautAdaptarr.Services
                }
            }

-            if (!found) return Tuple.Create(false, 0, 0);
-            return Tuple.Create(found, bestStart, bestEndInOriginal);
+            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
@@ -160,6 +166,7 @@ namespace UmlautAdaptarr.Services
            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)
            {
@@ -199,8 +206,8 @@ namespace UmlautAdaptarr.Services
                        }
                    }

-                    // Clean up any leading separators from the suffix
-                    suffix = Regex.Replace(suffix, "^[._ ]+", "");
+                    // 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
@@ -214,21 +221,20 @@ namespace UmlautAdaptarr.Services
                    */

                    // Construct the new title with the original suffix
-                    var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : separator + 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; // Break after the first successful match and modification
+                    break;
                }
            }
        }

-        private static string NormalizeTitle(string title)
+        private static string ReplaceSeperatorsWithSpace(string title)
        {
-            title = title.RemoveAccentButKeepGermanUmlauts();
            // Replace all known separators with space for normalization
            return WordSeperationCharRegex().Replace(title, " ".ToString());
        }
@@ -236,7 +242,7 @@ 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)
@@ -256,23 +262,23 @@ 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.StartsWith("Audio"))
+            else if (category == "3000" || category.StartsWith("Audio"))
            {
                return "audio";
            }
--- a/UmlautAdaptarr/Services/TitleQueryServiceLegacy.cs
+++ b/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?.HasUmlauts() ?? 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);
-            }
-        }
-    }
-}
--- a/UmlautAdaptarr/UmlautAdaptarr.csproj
+++ b/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>
--- a/UmlautAdaptarr/Utilities/Extensions.cs
+++ b/UmlautAdaptarr/Utilities/Extensions.cs
@@ -47,20 +47,64 @@ namespace UmlautAdaptarr.Utilities
            return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
        }

-        // TODO possibly replace GetCleanTitle with RemoveSpecialCharacters
+        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(")", "").Replace("?","").Replace(":", "").Replace("'", "");
+            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)
+        public static string RemoveSpecialCharacters(this string text, bool removeUmlauts = true)
        {
-            return SpecialCharactersRegex().Replace(text, "");
+            if (removeUmlauts)
+            {
+                return NoSpecialCharactersExceptHypenRegex().Replace(text, "");
+            }
+            else
+            {
+                return NoSpecialCharactersExceptHyphenAndUmlautsRegex().Replace(text, "");
+            }
        }


@@ -88,6 +132,18 @@ namespace UmlautAdaptarr.Utilities
                .Replace("ß", "ss");
        }

+        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, " ");
@@ -100,10 +156,16 @@ namespace UmlautAdaptarr.Utilities
            return umlauts.Any(text.Contains);
        }

-        [GeneratedRegex("[^a-zA-Z0-9 ]+", RegexOptions.Compiled)]
-        private static partial Regex SpecialCharactersRegex();
+        [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();
    }
 }
--- a/UmlautAdaptarr/Utilities/GlobalStaticLogger.cs
+++ b/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");
+    }
+}
--- a/UmlautAdaptarr/Utilities/ProxyExtension.cs
+++ b/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;
+        }
+    }
+}
--- a/UmlautAdaptarr/Utilities/ServicesExtensions.cs
+++ b/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");
+        }
+    }
+}
--- a/UmlautAdaptarr/Utilities/UrlUtilities.cs
+++ b/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);
--- a/UmlautAdaptarr/appsettings.json
+++ b/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
  }
 }
--- a/UmlautAdaptarr/secrets_example.json
+++ b/UmlautAdaptarr/secrets_example.json
@@ -1,8 +0,0 @@
-{
-  "SONARR_ENABLED": false,
-  "SONARR_HOST": "http://localhost:8989",
-  "SONARR_API_KEY": "",
-  "LIDARR_ENABLED": false,
-  "LIDARR_HOST": "http://localhost:8686",
-  "LIDARR_API_KEY": ""
-}
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -8,17 +8,20 @@ services:
    restart: unless-stopped
    environment:
      - TZ=Europe/Berlin
-      - SONARR_ENABLED=false
-      - SONARR_HOST=http://localhost:8989
-      - SONARR_API_KEY=API_KEY
-      - RADARR_ENABLED=false
-      - RADARR_HOST=http://localhost:7878
-      - RADARR_API_KEY=API_KEY
-      - READARR_ENABLED=false
-      - READARR_HOST=http://localhost:8787
-      - READARR_API_KEY=API_KEY
-      - LIDARR_ENABLED=false
-      - LIDARR_HOST=http://localhost:8686
-      - LIDARR_API_KEY=API_KEY
-    ports:
-      - "5005":"5005"
+      - SONARR__ENABLED=false
+      - SONARR__HOST=http://localhost:8989
+      - SONARR__APIKEY=APIKEY
+      - RADARR__ENABLED=false
+      - RADARR__HOST=http://localhost:7878
+      - RADARR__APIKEY=APIKEY
+      - READARR__ENABLED=false
+      - READARR__HOST=http://localhost:8787
+      - READARR__APIKEY=APIKEY
+      - LIDARR__ENABLED=false
+      - LIDARR__HOST=http://localhost:8686
+      - LIDARR__APIKEY=APIKEY
+      #- 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)
Author	SHA1	Message	Date
pcjones	530cbed2d3	Update docker compose	2024-04-15 04:25:21 +02:00
pcjones	94e62cf4dd	Forward user-agent when using http proxy	2024-04-15 03:42:20 +02:00
pcjones	c4069e0732	Change warning text	2024-04-15 03:21:51 +02:00
pcjones	6f743eca01	Revert "Add TODO" This reverts commit `45bc7baa4a`.	2024-04-15 03:20:36 +02:00
pcjones	45bc7baa4a	Add TODO	2024-04-15 03:17:14 +02:00
pcjones	43717d5fc4	HttpProxyService: Forward https, modify http	2024-04-15 03:05:09 +02:00
pcjones	08e13db32d	Revert "Temporarily remove API key redaction" This reverts commit `f3684d24d3`.	2024-04-15 00:59:56 +02:00
pcjones	f3684d24d3	Temporarily remove API key redaction	2024-04-15 00:56:13 +02:00
pcjones	cee3c12daa	Add HttpProxyService	2024-04-15 00:48:27 +02:00
pcjones	e888a10366	Add timestamp to log	2024-04-15 00:48:15 +02:00
pcjones	660c245069	Remove 5005 port exposing from docker compose	2024-04-14 23:32:21 +02:00
pcjones	49193ef12f	Rename ProxyService to ProxyRequestService	2024-04-14 23:22:40 +02:00
pcjones	881f3b7281	Add IPv6 support	2024-04-14 23:15:03 +02:00
pcjones	d098d1fd10	Change cache time from 5 to 12 minutes	2024-04-14 22:49:50 +02:00
pcjones	6cf87620c3	Add TODO	2024-04-14 22:44:51 +02:00
pcjones	389d685e95	Code cleanup	2024-04-14 22:44:07 +02:00
pcjones	12d9217964	Add todo	2024-04-14 22:29:10 +02:00
pcjones	5cd90b7b20	Remove secrets example	2024-04-14 22:28:38 +02:00
Jonas F	93990dbf52	Merge pull request #16 from PCJones/master Merge master in develop (readme)	2024-04-14 22:22:26 +02:00
Jonas F	49565be191	Merge pull request #15 from xpsony/Proxy_IOption Add Proxy Support, Add IOptions Pattern, Add Extensions Method	2024-04-14 22:21:23 +02:00
Felix Glang	24d5cb83a4	Add Proxy Support, Add IOptions Pattern, Add Extensions Method Currently Changes Http / Https proxy support has been added , To disguise the Ip address or if a proxy service is required IOptions pattern has been implemented. Better options handling Extensions methods have been implemented to make Program.cs smaller Added a global logger for static and extension methods appsettings.json now contains "default" data for the applications and proxy settings. The Docker variables are also specified above it. This also fixes the bug that you have to set all variables, although you only want to use Sonarr, for example	2024-04-14 16:43:09 +02:00
pcjones	f02547c0e3	Merge branch 'master' of https://github.com/PCJones/UmlautAdaptarr	2024-03-15 18:25:08 +01:00
pcjones	61e93b5b24	Enhance searchitem matching	2024-03-15 18:24:39 +01:00
pcjones	f88daf4955	Lower minimum delay between requests to 1 second	2024-03-08 10:00:29 +01:00
Jonas F	93c667422f	Update README.md	2024-03-06 20:03:16 +01:00
Jonas F	e1978d869c	Merge pull request #12 from PCJones/develop v0.4	2024-03-06 20:00:05 +01:00
pcjones	cfdfa89009	Merge branch 'develop'	2024-03-06 19:52:19 +01:00
pcjones	9bee42d7dd	Detect media Type by category ID	2024-03-06 19:52:07 +01:00
pcjones	797ff2b97e	Fix searchItem title not being logged	2024-03-01 12:53:47 +01:00
pcjones	a67d5c2d1e	Merge branch 'develop'	2024-02-29 17:20:23 +01:00
pcjones	d1d05f8264	Fix url ending with / not being recognized as valid	2024-02-29 17:17:55 +01:00
Jonas F	939b902be3	Update README.md	2024-02-26 21:33:45 +01:00
Jonas F	f56d071642	Update README.md	2024-02-26 21:26:15 +01:00
Jonas F	7513e7d227	Update README.md	2024-02-26 21:23:26 +01:00
Jonas F	7a791dab23	Update README.md	2024-02-26 21:23:00 +01:00
Jonas F	402a4deba3	Update README.md	2024-02-26 21:21:05 +01:00
Jonas F	d31508fef3	Update README.md	2024-02-26 21:20:33 +01:00
pcjones	1c329e886d	Update README	2024-02-24 16:33:50 +01:00
pcjones	6932c4b2f8	Add hyphen title matching if title contains colon	2024-02-23 14:09:20 +01:00
pcjones	ff051569ca	Fix separator being added twice	2024-02-23 14:08:56 +01:00
pcjones	dbac09bf36	Merge branch 'master' of https://github.com/PCJones/UmlautAdaptarr	2024-02-23 12:25:51 +01:00
pcjones	0bde5d5d24	Fix sync process not finishing if there was an error	2024-02-23 12:25:42 +01:00
Jonas F	99af842fc6	Update README.md	2024-02-20 15:16:19 +01:00
pcjones	fbfbeadb3e	set FORCE_TEXT_SEARCH_ORIGINAL_TITLE to true by default	2024-02-19 21:35:16 +01:00
pcjones	7cfae00511	Fix SearchItem lookup not working for newly added items in Readarr and Lidarr	2024-02-19 21:04:32 +01:00
pcjones	cac920ae88	Merge branch 'master' of https://github.com/PCJones/UmlautAdaptarr	2024-02-19 14:20:27 +01:00
pcjones	bab60771a4	Merge branch 'develop'	2024-02-19 14:20:10 +01:00
pcjones	828faae486	Lower minimum delay between two requests to 1.5 seconds; no longer use delay if cache can be used	2024-02-19 14:19:57 +01:00
Jonas F	333a18ecd5	Update README.md	2024-02-19 14:07:47 +01:00
pcjones	a4a57d899a	Merge branch 'develop'	2024-02-19 14:05:16 +01:00
pcjones	f804dd796f	Add title without umlauts as base variation	2024-02-19 06:20:47 +01:00
pcjones	b2e4dbbda6	Made apiKey parameter lowercase	2024-02-19 05:08:24 +01:00
Jonas F	cd70997507	Update README.md	2024-02-18 21:20:39 +01:00
pcjones	b741239194	Lidarr optimizations	2024-02-14 23:59:53 +01:00
pcjones	96f8ff9332	Refactor TItleMatchingService	2024-02-14 21:00:24 +01:00
pcjones	e739affb39	Use TitleMatchVariations instead of TitleSearchVariations in SearchItemByTitle	2024-02-14 20:55:13 +01:00
pcjones	92bdf14618	Remove test variable	2024-02-14 20:40:13 +01:00
pcjones	4260b07bc4	Merge branch 'master' of https://github.com/PCJones/UmlautAdaptarr	2024-02-14 11:15:51 +01:00
pcjones	4d2ac194aa	Ignore case when filtering distinct title match variations	2024-02-14 11:15:44 +01:00
pcjones	a6f332fd99	Fix hyphen in indexer url not being accepted	2024-02-14 11:14:26 +01:00
Jonas F	9c364cb652	Update README.md	2024-02-13 22:34:49 +01:00