Rename Connectors -> MangaConnectors

Tranga/MangaConnectors/Connector.cs

@@ -0,0 +1,256 @@
+using System.Globalization;
+using System.IO.Compression;
+using System.Net;
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+using static System.IO.UnixFileMode;
+
+namespace Tranga.MangaConnectors;
+
+/// <summary>
+/// Base-Class for all Connectors
+/// Provides some methods to be used by all Connectors, as well as a DownloadClient
+/// </summary>
+public abstract class Connector : TBaseObject
+{
+    internal DownloadClient downloadClient { get; init; } = null!;
+
+    protected Connector(TBaseObject clone) : base(clone)
+    {
+        if (!Directory.Exists(settings.coverImageCache))
+            Directory.CreateDirectory(settings.coverImageCache);
+    }
+    
+    public abstract string name { get; } //Name of the Connector (e.g. Website)
+
+    /// <summary>
+    /// Returns all Publications with the given string.
+    /// If the string is empty or null, returns all Publication of the Connector
+    /// </summary>
+    /// <param name="publicationTitle">Search-Query</param>
+    /// <returns>Publications matching the query</returns>
+    protected abstract Publication[] GetPublications(string publicationTitle = "");
+    
+    /// <summary>
+    /// Returns all Chapters of the publication in the provided language.
+    /// If the language is empty or null, returns all Chapters in all Languages.
+    /// </summary>
+    /// <param name="publication">Publication to get Chapters for</param>
+    /// <param name="language">Language of the Chapters</param>
+    /// <returns>Array of Chapters matching Publication and Language</returns>
+    public abstract Chapter[] GetChapters(Publication publication, string language = "");
+
+    /// <summary>
+    /// Updates the available Chapters of a Publication
+    /// </summary>
+    /// <param name="publication">Publication to check</param>
+    /// <param name="language">Language to receive chapters for</param>
+    /// <param name="collection"></param>
+    /// <returns>List of Chapters that were previously not in collection</returns>
+    public List<Chapter> GetNewChaptersList(Publication publication, string language, ref HashSet<Publication> collection)
+    {
+        Log($"Getting new Chapters for {publication}");
+        Chapter[] newChapters = this.GetChapters(publication, language);
+        collection.Add(publication);
+        NumberFormatInfo decimalPoint = new (){ NumberDecimalSeparator = "." };
+        Log($"Checking for duplicates {publication}");
+        List<Chapter> newChaptersList = newChapters.Where(nChapter =>
+            float.Parse(nChapter.chapterNumber, decimalPoint) > publication.ignoreChaptersBelow &&
+            !nChapter.CheckChapterIsDownloaded(settings.downloadLocation)).ToList();
+        Log($"{newChaptersList.Count} new chapters. {publication}");
+        
+        return newChaptersList;
+    }
+
+    public Chapter[] SelectChapters(Publication publication, string searchTerm, string? language = null)
+    {
+        Chapter[] availableChapters = this.GetChapters(publication, language??"en");
+        Regex volumeRegex = new ("((v(ol)*(olume)*){1} *([0-9]+(-[0-9]+)?){1})", RegexOptions.IgnoreCase);
+        Regex chapterRegex = new ("((c(h)*(hapter)*){1} *([0-9]+(-[0-9]+)?){1})", RegexOptions.IgnoreCase);
+        Regex singleResultRegex = new("([0-9]+)", RegexOptions.IgnoreCase);
+        Regex rangeResultRegex = new("([0-9]+(-[0-9]+))", RegexOptions.IgnoreCase);
+        Regex allRegex = new("a(ll)?", RegexOptions.IgnoreCase);
+        if (volumeRegex.IsMatch(searchTerm) && chapterRegex.IsMatch(searchTerm))
+        {
+            string volume = singleResultRegex.Match(volumeRegex.Match(searchTerm).Value).Value;
+            string chapter = singleResultRegex.Match(chapterRegex.Match(searchTerm).Value).Value;
+            return availableChapters.Where(aCh => aCh.volumeNumber is not null &&
+                aCh.volumeNumber.Equals(volume, StringComparison.InvariantCultureIgnoreCase) &&
+                aCh.chapterNumber.Equals(chapter, StringComparison.InvariantCultureIgnoreCase))
+                .ToArray();
+        }
+        else if (volumeRegex.IsMatch(searchTerm))
+        {
+            string volume = volumeRegex.Match(searchTerm).Value;
+            if (rangeResultRegex.IsMatch(volume))
+            {
+                string range = rangeResultRegex.Match(volume).Value;
+                int start = Convert.ToInt32(range.Split('-')[0]);
+                int end = Convert.ToInt32(range.Split('-')[1]);
+                return availableChapters.Where(aCh => aCh.volumeNumber is not null &&
+                                                      Convert.ToInt32(aCh.volumeNumber) >= start &&
+                                                      Convert.ToInt32(aCh.volumeNumber) <= end).ToArray();
+            }
+            else if (singleResultRegex.IsMatch(volume))
+            {
+                string volumeNumber = singleResultRegex.Match(volume).Value;
+                return availableChapters.Where(aCh =>
+                    aCh.volumeNumber is not null &&
+                    aCh.volumeNumber.Equals(volumeNumber, StringComparison.InvariantCultureIgnoreCase)).ToArray();
+            }
+
+        }
+        else if (chapterRegex.IsMatch(searchTerm))
+        {
+            string chapter = chapterRegex.Match(searchTerm).Value;
+            if (rangeResultRegex.IsMatch(chapter))
+            {
+                string range = rangeResultRegex.Match(chapter).Value;
+                int start = Convert.ToInt32(range.Split('-')[0]);
+                int end = Convert.ToInt32(range.Split('-')[1]);
+                return availableChapters.Where(aCh => Convert.ToInt32(aCh.chapterNumber) >= start &&
+                                                      Convert.ToInt32(aCh.chapterNumber) <= end).ToArray();
+            }
+            else if (singleResultRegex.IsMatch(chapter))
+            {
+                string chapterNumber = singleResultRegex.Match(chapter).Value;
+                return availableChapters.Where(aCh =>
+                    aCh.chapterNumber.Equals(chapterNumber, StringComparison.InvariantCultureIgnoreCase)).ToArray();
+            }
+        }
+        else
+        {
+            if (rangeResultRegex.IsMatch(searchTerm))
+            {
+                int start = Convert.ToInt32(searchTerm.Split('-')[0]);
+                int end = Convert.ToInt32(searchTerm.Split('-')[1]);
+                return availableChapters[start..(end + 1)];
+            }
+            else if(singleResultRegex.IsMatch(searchTerm))
+                return new [] { availableChapters[Convert.ToInt32(searchTerm)] };
+            else if (allRegex.IsMatch(searchTerm))
+                return availableChapters;
+        }
+
+        return Array.Empty<Chapter>();
+    }
+    
+    /// <summary>
+    /// Retrieves the Chapter (+Images) from the website.
+    /// Should later call DownloadChapterImages to retrieve the individual Images of the Chapter and create .cbz archive.
+    /// </summary>
+    /// <param name="publication">Publication that contains Chapter</param>
+    /// <param name="chapter">Chapter with Images to retrieve</param>
+    /// <param name="cancellationToken"></param>
+    public abstract HttpStatusCode DownloadChapter(Publication publication, Chapter chapter, CancellationToken? cancellationToken = null);
+
+    /// <summary>
+    /// Copies the already downloaded cover from cache to downloadLocation
+    /// </summary>
+    /// <param name="publication">Publication to retrieve Cover for</param>
+    public void CopyCoverFromCacheToDownloadLocation(Publication publication)
+    {
+        Log($"Copy cover {publication}");
+        //Check if Publication already has a Folder and cover
+        string publicationFolder = publication.CreatePublicationFolder(settings.downloadLocation);
+        DirectoryInfo dirInfo = new (publicationFolder);
+        if (dirInfo.EnumerateFiles().Any(info => info.Name.Contains("cover", StringComparison.InvariantCultureIgnoreCase)))
+        {
+            Log($"Cover exists {publication}");
+            return;
+        }
+
+        string fileInCache = Path.Join(settings.coverImageCache, publication.coverFileNameInCache);
+        string newFilePath = Path.Join(publicationFolder, $"cover.{Path.GetFileName(fileInCache).Split('.')[^1]}" );
+        Log($"Cloning cover {fileInCache} -> {newFilePath}");
+        File.Copy(fileInCache, newFilePath, true);
+        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            File.SetUnixFileMode(newFilePath, GroupRead | GroupWrite | OtherRead | OtherWrite | UserRead | UserWrite);
+    }
+
+    /// <summary>
+    /// Downloads Image from URL and saves it to the given path(incl. fileName)
+    /// </summary>
+    /// <param name="imageUrl"></param>
+    /// <param name="fullPath"></param>
+    /// <param name="requestType">RequestType for Rate-Limit</param>
+    /// <param name="referrer">referrer used in html request header</param>
+    private HttpStatusCode DownloadImage(string imageUrl, string fullPath, byte requestType, string? referrer = null)
+    {
+        DownloadClient.RequestResult requestResult = downloadClient.MakeRequest(imageUrl, requestType, referrer);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.result == Stream.Null)
+            return requestResult.statusCode;
+        byte[] buffer = new byte[requestResult.result.Length];
+        requestResult.result.ReadExactly(buffer, 0, buffer.Length);
+        File.WriteAllBytes(fullPath, buffer);
+        return requestResult.statusCode;
+    }
+
+    /// <summary>
+    /// Downloads all Images from URLs, Compresses to zip(cbz) and saves.
+    /// </summary>
+    /// <param name="imageUrls">List of URLs to download Images from</param>
+    /// <param name="saveArchiveFilePath">Full path to save archive to (without file ending .cbz)</param>
+    /// <param name="comicInfoPath">Path of the generate Chapter ComicInfo.xml, if it was generated</param>
+    /// <param name="requestType">RequestType for RateLimits</param>
+    /// <param name="referrer">Used in http request header</param>
+    /// <param name="cancellationToken"></param>
+    protected HttpStatusCode DownloadChapterImages(string[] imageUrls, string saveArchiveFilePath, byte requestType, string? comicInfoPath = null, string? referrer = null, CancellationToken? cancellationToken = null)
+    {
+        if (cancellationToken?.IsCancellationRequested ?? false)
+            return HttpStatusCode.RequestTimeout;
+        Log($"Downloading Images for {saveArchiveFilePath}");
+        //Check if Publication Directory already exists
+        string directoryPath = Path.GetDirectoryName(saveArchiveFilePath)!;
+        if (!Directory.Exists(directoryPath))
+            Directory.CreateDirectory(directoryPath);
+
+        if (File.Exists(saveArchiveFilePath)) //Don't download twice.
+            return HttpStatusCode.OK;
+        
+        //Create a temporary folder to store images
+        string tempFolder = Directory.CreateTempSubdirectory().FullName;
+
+        int chapter = 0;
+        //Download all Images to temporary Folder
+        foreach (string imageUrl in imageUrls)
+        {
+            string[] split = imageUrl.Split('.');
+            string extension = split[^1];
+            Log($"Downloading image {chapter + 1:000}/{imageUrls.Length:000}"); //TODO
+            HttpStatusCode status = DownloadImage(imageUrl, Path.Join(tempFolder, $"{chapter++}.{extension}"), requestType, referrer);
+            if ((int)status < 200 || (int)status >= 300)
+                return status;
+            if (cancellationToken?.IsCancellationRequested ?? false)
+                return HttpStatusCode.RequestTimeout;
+        }
+        
+        if(comicInfoPath is not null)
+            File.Copy(comicInfoPath, Path.Join(tempFolder, "ComicInfo.xml"));
+        
+        Log($"Creating archive {saveArchiveFilePath}");
+        //ZIP-it and ship-it
+        ZipFile.CreateFromDirectory(tempFolder, saveArchiveFilePath);
+        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            File.SetUnixFileMode(saveArchiveFilePath, GroupRead | GroupWrite | OtherRead | OtherWrite | UserRead | UserWrite);
+        Directory.Delete(tempFolder, true); //Cleanup
+        return HttpStatusCode.OK;
+    }
+    
+    protected string SaveCoverImageToCache(string url, byte requestType)
+    {
+        string[] split = url.Split('/');
+        string filename = split[^1];
+        string saveImagePath = Path.Join(settings.coverImageCache, filename);
+
+        if (File.Exists(saveImagePath))
+            return filename;
+        
+        DownloadClient.RequestResult coverResult = downloadClient.MakeRequest(url, requestType);
+        using MemoryStream ms = new();
+        coverResult.result.CopyTo(ms);
+        File.WriteAllBytes(saveImagePath, ms.ToArray());
+        Log($"Saving cover to {saveImagePath}");
+        return filename;
+    }
+}

Tranga/MangaConnectors/DownloadClient.cs

@@ -0,0 +1,98 @@
+using System.Net;
+
+namespace Tranga.MangaConnectors;
+
+internal class DownloadClient : TBaseObject
+    {
+        private static readonly HttpClient Client = new()
+        {
+            Timeout = TimeSpan.FromSeconds(60)
+        };
+
+        private readonly Dictionary<byte, DateTime> _lastExecutedRateLimit;
+        private readonly Dictionary<byte, TimeSpan> _rateLimit;
+
+        public DownloadClient(Dictionary<byte, int> rateLimitRequestsPerMinute, TBaseObject clone) : base(clone)
+        {
+            _lastExecutedRateLimit = new();
+            _rateLimit = new();
+            foreach(KeyValuePair<byte, int> limit in rateLimitRequestsPerMinute)
+                _rateLimit.Add(limit.Key, TimeSpan.FromMinutes(1).Divide(limit.Value));
+        }
+
+        /// <summary>
+        /// Request Webpage
+        /// </summary>
+        /// <param name="url"></param>
+        /// <param name="requestType">For RateLimits: Same Endpoints use same type</param>
+        /// <param name="referrer">Used in http request header</param>
+        /// <returns>RequestResult with StatusCode and Stream of received data</returns>
+        public RequestResult MakeRequest(string url, byte requestType, string? referrer = null)
+        {
+            if (_rateLimit.TryGetValue(requestType, out TimeSpan value))
+                _lastExecutedRateLimit.TryAdd(requestType, DateTime.Now.Subtract(value));
+            else
+            {
+                Log("RequestType not configured for rate-limit.");
+                return new RequestResult(HttpStatusCode.NotAcceptable, Stream.Null);
+            }
+
+            TimeSpan rateLimitTimeout = _rateLimit[requestType]
+                .Subtract(DateTime.Now.Subtract(_lastExecutedRateLimit[requestType]));
+            
+            if(rateLimitTimeout > TimeSpan.Zero)
+                Thread.Sleep(rateLimitTimeout);
+
+            HttpResponseMessage? response = null;
+            while (response is null)
+            {
+                try
+                {
+                    HttpRequestMessage requestMessage = new(HttpMethod.Get, url);
+                    if(referrer is not null)
+                        requestMessage.Headers.Referrer = new Uri(referrer);
+                    _lastExecutedRateLimit[requestType] = DateTime.Now;
+                    response = Client.Send(requestMessage);
+                }
+                catch (HttpRequestException e)
+                {
+                    Log("Exception:\n\t{0}\n\tWaiting {1} before retrying.", e.Message, _rateLimit[requestType] * 2);
+                    Thread.Sleep(_rateLimit[requestType] * 2);
+                }
+            }
+            if (!response.IsSuccessStatusCode)
+            {
+                Log($"Request-Error {response.StatusCode}: {response.ReasonPhrase}");
+                return new RequestResult(response.StatusCode, Stream.Null);
+            }
+
+            // Request has been redirected to another page. For example, it redirects directly to the results when there is only 1 result
+            if(response.RequestMessage is not null && response.RequestMessage.RequestUri is not null)
+            {
+                return new RequestResult(response.StatusCode, response.Content.ReadAsStream(), true, response.RequestMessage.RequestUri.AbsoluteUri);
+            }
+
+            return new RequestResult(response.StatusCode, response.Content.ReadAsStream());
+        }
+
+        public struct RequestResult
+        {
+            public HttpStatusCode statusCode { get; }
+            public Stream result { get; }
+            public bool hasBeenRedirected { get; }
+            public string? redirectedToUrl { get; }
+
+            public RequestResult(HttpStatusCode statusCode, Stream result)
+            {
+                this.statusCode = statusCode;
+                this.result = result;
+            }
+
+            public RequestResult(HttpStatusCode statusCode, Stream result, bool hasBeenRedirected, string redirectedTo)
+                : this(statusCode, result)
+            {
+                this.hasBeenRedirected = hasBeenRedirected;
+                redirectedToUrl = redirectedTo;
+            }
+        }
+    }

Tranga/MangaConnectors/MangaDex.cs

@@ -0,0 +1,280 @@
+using System.Globalization;
+using System.Net;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace Tranga.MangaConnectors;
+public class MangaDex : Connector
+{
+    public override string name { get; }
+
+    private enum RequestType : byte
+    {
+        Manga,
+        Feed,
+        AtHomeServer,
+        CoverUrl,
+        Author,
+    }
+
+    public MangaDex(TBaseObject clone) : base(clone)
+    {
+        name = "MangaDex";
+        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
+        {
+            {(byte)RequestType.Manga, 250},
+            {(byte)RequestType.Feed, 250},
+            {(byte)RequestType.AtHomeServer, 40},
+            {(byte)RequestType.CoverUrl, 250},
+            {(byte)RequestType.Author, 250}
+        }, clone);
+    }
+
+    protected override Publication[] GetPublications(string publicationTitle = "")
+    {
+        Log($"Searching Publications. Term=\"{publicationTitle}\"");
+        const int limit = 100; //How many values we want returned at once
+        int offset = 0; //"Page"
+        int total = int.MaxValue; //How many total results are there, is updated on first request
+        HashSet<Publication> publications = new();
+        int loadedPublicationData = 0;
+        while (offset < total) //As long as we haven't requested all "Pages"
+        {
+            //Request next Page
+            DownloadClient.RequestResult requestResult =
+                downloadClient.MakeRequest(
+                    $"https://api.mangadex.org/manga?limit={limit}&title={publicationTitle}&offset={offset}", (byte)RequestType.Manga);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+                break;
+            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+            
+            offset += limit;
+            if (result is null)
+                break;
+            
+            total = result["total"]!.GetValue<int>(); //Update the total number of Publications
+            
+            JsonArray mangaInResult = result["data"]!.AsArray(); //Manga-data-Array
+            //Loop each Manga and extract information from JSON
+            foreach (JsonNode? mangeNode in mangaInResult)
+            {
+                Log($"Getting publication data. {++loadedPublicationData}/{total}");
+                JsonObject manga = (JsonObject)mangeNode!;
+                JsonObject attributes = manga["attributes"]!.AsObject();
+                
+                string publicationId = manga["id"]!.GetValue<string>();
+                
+                string title = attributes["title"]!.AsObject().ContainsKey("en") && attributes["title"]!["en"] is not null
+                    ? attributes["title"]!["en"]!.GetValue<string>()
+                    : attributes["title"]![((IDictionary<string, JsonNode?>)attributes["title"]!.AsObject()).Keys.First()]!.GetValue<string>();
+
+                string? description = attributes["description"]!.AsObject().ContainsKey("en") && attributes["description"]!["en"] is not null
+                    ? attributes["description"]!["en"]!.GetValue<string?>()
+                    : null;
+
+                JsonArray altTitlesObject = attributes["altTitles"]!.AsArray();
+                Dictionary<string, string> altTitlesDict = new();
+                foreach (JsonNode? altTitleNode in altTitlesObject)
+                {
+                    JsonObject altTitleObject = (JsonObject)altTitleNode!;
+                    string key = ((IDictionary<string, JsonNode?>)altTitleObject).Keys.ToArray()[0];
+                    altTitlesDict.TryAdd(key, altTitleObject[key]!.GetValue<string>());
+                }
+
+                JsonArray tagsObject = attributes["tags"]!.AsArray();
+                HashSet<string> tags = new();
+                foreach (JsonNode? tagNode in tagsObject)
+                {
+                    JsonObject tagObject = (JsonObject)tagNode!;
+                    if(tagObject["attributes"]!["name"]!.AsObject().ContainsKey("en"))
+                        tags.Add(tagObject["attributes"]!["name"]!["en"]!.GetValue<string>());
+                }
+
+                string? posterId = null;
+                HashSet<string> authorIds = new();
+                if (manga.ContainsKey("relationships") && manga["relationships"] is not null)
+                {
+                    JsonArray relationships = manga["relationships"]!.AsArray();
+                    posterId = relationships.FirstOrDefault(relationship => relationship!["type"]!.GetValue<string>() == "cover_art")!["id"]!.GetValue<string>();
+                    foreach (JsonNode? node in relationships.Where(relationship =>
+                                 relationship!["type"]!.GetValue<string>() == "author"))
+                        authorIds.Add(node!["id"]!.GetValue<string>());
+                }
+                string? coverUrl = GetCoverUrl(publicationId, posterId);
+                string? coverCacheName = null;
+                if (coverUrl is not null)
+                    coverCacheName = SaveCoverImageToCache(coverUrl, (byte)RequestType.AtHomeServer);
+
+                List<string> authors = GetAuthors(authorIds);
+
+                Dictionary<string, string> linksDict = new();
+                if (attributes.ContainsKey("links") && attributes["links"] is not null)
+                {
+                    JsonObject linksObject = attributes["links"]!.AsObject();
+                    foreach (string key in ((IDictionary<string, JsonNode?>)linksObject).Keys)
+                    {
+                        linksDict.Add(key, linksObject[key]!.GetValue<string>());
+                    }
+                }
+                
+                int? year = attributes.ContainsKey("year") && attributes["year"] is not null
+                    ? attributes["year"]!.GetValue<int?>()
+                    : null;
+
+                string? originalLanguage = attributes.ContainsKey("originalLanguage") && attributes["originalLanguage"] is not null
+                    ? attributes["originalLanguage"]!.GetValue<string?>()
+                    : null;
+                
+                string status = attributes["status"]!.GetValue<string>();
+
+                Publication pub = new (
+                    title,
+                    authors,
+                    description,
+                    altTitlesDict,
+                    tags.ToArray(),
+                    coverUrl,
+                    coverCacheName,
+                    linksDict,
+                    year,
+                    originalLanguage,
+                    status,
+                    publicationId
+                );
+                publications.Add(pub); //Add Publication (Manga) to result
+            }
+        }
+
+        Log($"Retrieved {publications.Count} publications.");
+        return publications.ToArray();
+    }
+
+    public override Chapter[] GetChapters(Publication publication, string language = "")
+    {
+        Log($"Getting chapters {publication}");
+        const int limit = 100; //How many values we want returned at once
+        int offset = 0; //"Page"
+        int total = int.MaxValue; //How many total results are there, is updated on first request
+        List<Chapter> chapters = new();
+        //As long as we haven't requested all "Pages"
+        while (offset < total)
+        {
+            //Request next "Page"
+            DownloadClient.RequestResult requestResult =
+                downloadClient.MakeRequest(
+                    $"https://api.mangadex.org/manga/{publication.publicationId}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}", (byte)RequestType.Feed);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+                break;
+            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+            
+            offset += limit;
+            if (result is null)
+                break;
+            
+            total = result["total"]!.GetValue<int>();
+            JsonArray chaptersInResult = result["data"]!.AsArray();
+            //Loop through all Chapters in result and extract information from JSON
+            foreach (JsonNode? jsonNode in chaptersInResult)
+            {
+                JsonObject chapter = (JsonObject)jsonNode!;
+                JsonObject attributes = chapter["attributes"]!.AsObject();
+                string chapterId = chapter["id"]!.GetValue<string>();
+                
+                string? title = attributes.ContainsKey("title") && attributes["title"] is not null
+                    ? attributes["title"]!.GetValue<string>()
+                    : null;
+                
+                string? volume = attributes.ContainsKey("volume") && attributes["volume"] is not null
+                    ? attributes["volume"]!.GetValue<string>()
+                    : null;
+                
+                string chapterNum = attributes.ContainsKey("chapter") && attributes["chapter"] is not null
+                    ? attributes["chapter"]!.GetValue<string>()
+                    : "null";
+                
+                if(chapterNum is not "null")
+                    chapters.Add(new Chapter(publication, title, volume, chapterNum, chapterId));
+            }
+        }
+
+        //Return Chapters ordered by Chapter-Number
+        NumberFormatInfo chapterNumberFormatInfo = new() { NumberDecimalSeparator = "." };
+        Log($"Got {chapters.Count} chapters. {publication}");
+        return chapters.OrderBy(chapter => Convert.ToSingle(chapter.chapterNumber, chapterNumberFormatInfo)).ToArray();
+    }
+
+    public override HttpStatusCode DownloadChapter(Publication publication, Chapter chapter, CancellationToken? cancellationToken = null)
+    {
+        if (cancellationToken?.IsCancellationRequested ?? false)
+            return HttpStatusCode.RequestTimeout;
+        Log($"Retrieving chapter-info {chapter} {publication}");
+        //Request URLs for Chapter-Images
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.url}?forcePort443=false'", (byte)RequestType.AtHomeServer);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return requestResult.statusCode;
+        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+        if (result is null)
+            return HttpStatusCode.NoContent;
+
+        string baseUrl = result["baseUrl"]!.GetValue<string>();
+        string hash = result["chapter"]!["hash"]!.GetValue<string>();
+        JsonArray imageFileNames = result["chapter"]!["data"]!.AsArray();
+        //Loop through all imageNames and construct urls (imageUrl)
+        HashSet<string> imageUrls = new();
+        foreach (JsonNode? image in imageFileNames)
+            imageUrls.Add($"{baseUrl}/data/{hash}/{image!.GetValue<string>()}");
+
+        string comicInfoPath = Path.GetTempFileName();
+        File.WriteAllText(comicInfoPath, chapter.GetComicInfoXmlString());
+        
+        //Download Chapter-Images
+        return DownloadChapterImages(imageUrls.ToArray(), chapter.GetArchiveFilePath(settings.downloadLocation), (byte)RequestType.AtHomeServer, comicInfoPath, cancellationToken:cancellationToken);
+    }
+
+    private string? GetCoverUrl(string publicationId, string? posterId)
+    {
+        Log($"Getting CoverUrl for Publication {publicationId}");
+        if (posterId is null)
+        {
+            Log("No cover.");
+            return null;
+        }
+        
+        //Request information where to download Cover
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest($"https://api.mangadex.org/cover/{posterId}", (byte)RequestType.CoverUrl);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return null;
+        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+        if (result is null)
+            return null;
+
+        string fileName = result["data"]!["attributes"]!["fileName"]!.GetValue<string>();
+
+        string coverUrl = $"https://uploads.mangadex.org/covers/{publicationId}/{fileName}";
+        Log($"Cover-Url {publicationId} -> {coverUrl}");
+        return coverUrl;
+    }
+
+    private List<string> GetAuthors(IEnumerable<string> authorIds)
+    {
+        Log("Retrieving authors.");
+        List<string> ret = new();
+        foreach (string authorId in authorIds)
+        {
+            DownloadClient.RequestResult requestResult =
+                downloadClient.MakeRequest($"https://api.mangadex.org/author/{authorId}", (byte)RequestType.Author);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+                return ret;
+            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+            if (result is null)
+                return ret;
+
+            string authorName = result["data"]!["attributes"]!["name"]!.GetValue<string>();
+            ret.Add(authorName);
+            Log($"Got author {authorId} -> {authorName}");
+        }
+        return ret;
+    }
+}

Tranga/MangaConnectors/MangaKatana.cs

@@ -0,0 +1,222 @@
+using System.Globalization;
+using System.Net;
+using System.Text.RegularExpressions;
+using HtmlAgilityPack;
+
+namespace Tranga.MangaConnectors;
+
+public class MangaKatana : Connector
+{
+	public override string name { get; }
+
+	public MangaKatana(TBaseObject clone) : base(clone)
+	{
+		this.name = "MangaKatana";
+		this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
+		{
+			{1, 60}
+		}, clone);
+	}
+
+	protected override Publication[] GetPublications(string publicationTitle = "")
+	{
+		Log($"Searching Publications. Term=\"{publicationTitle}\"");
+		string sanitizedTitle = string.Join('_', Regex.Matches(publicationTitle, "[A-z]*").Where(m => m.Value.Length > 0)).ToLower();
+		string requestUrl = $"https://mangakatana.com/?search={sanitizedTitle}&search_by=book_name";
+		DownloadClient.RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, 1);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return Array.Empty<Publication>();
+
+		// ReSharper disable once MergeIntoPattern
+		// If a single result is found, the user will be redirected to the results directly instead of a result page
+		if(requestResult.hasBeenRedirected
+		    && requestResult.redirectedToUrl is not null
+			&& requestResult.redirectedToUrl.Contains("mangakatana.com/manga"))
+		{
+			return new [] { ParseSinglePublicationFromHtml(requestResult.result, requestResult.redirectedToUrl.Split('/')[^1]) };
+		}
+
+		Publication[] publications = ParsePublicationsFromHtml(requestResult.result);
+		Log($"Retrieved {publications.Length} publications.");
+		return publications;
+	}
+
+	private Publication[] ParsePublicationsFromHtml(Stream html)
+	{
+		StreamReader reader = new(html);
+		string htmlString = reader.ReadToEnd();
+		HtmlDocument document = new();
+		document.LoadHtml(htmlString);
+		IEnumerable<HtmlNode> searchResults = document.DocumentNode.SelectNodes("//*[@id='book_list']/div");
+		if (searchResults is null || !searchResults.Any())
+			return Array.Empty<Publication>();
+		List<string> urls = new();
+		foreach (HtmlNode mangaResult in searchResults)
+		{
+			urls.Add(mangaResult.Descendants("a").First().GetAttributes()
+				.First(a => a.Name == "href").Value);
+		}
+
+		HashSet<Publication> ret = new();
+		foreach (string url in urls)
+		{
+			DownloadClient.RequestResult requestResult =
+				downloadClient.MakeRequest(url, 1);
+			if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+				return Array.Empty<Publication>();
+
+			ret.Add(ParseSinglePublicationFromHtml(requestResult.result, url.Split('/')[^1]));
+		}
+
+		return ret.ToArray();
+	}
+
+	private Publication ParseSinglePublicationFromHtml(Stream html, string publicationId)
+	{
+		StreamReader reader = new(html);
+		string htmlString = reader.ReadToEnd();
+		HtmlDocument document = new();
+		document.LoadHtml(htmlString);
+		string status = "";
+		Dictionary<string, string> altTitles = new();
+		Dictionary<string, string>? links = null;
+		HashSet<string> tags = new();
+		string[] authors = Array.Empty<string>();
+		string originalLanguage = "";
+
+		HtmlNode infoNode = document.DocumentNode.SelectSingleNode("//*[@id='single_book']");
+		string sortName = infoNode.Descendants("h1").First(n => n.HasClass("heading")).InnerText;
+		HtmlNode infoTable = infoNode.SelectSingleNode("//*[@id='single_book']/div[2]/div/ul");
+
+		foreach (HtmlNode row in infoTable.Descendants("li"))
+		{
+			string key = row.SelectNodes("div").First().InnerText.ToLower();
+			string value = row.SelectNodes("div").Last().InnerText;
+			string keySanitized = string.Concat(Regex.Matches(key, "[a-z]"));
+
+			switch (keySanitized)
+			{
+				case "altnames":
+					string[] alts = value.Split(" ; ");
+					for (int i = 0; i < alts.Length; i++)
+						altTitles.Add(i.ToString(), alts[i]);
+					break;
+				case "authorsartists":
+					authors = value.Split(',');
+					break;
+				case "status":
+					status = value;
+					break;
+				case "genres":
+					tags = row.SelectNodes("div").Last().Descendants("a").Select(a => a.InnerText).ToHashSet();
+					break;
+			}
+		}
+
+		string posterUrl = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[1]/div").Descendants("img").First()
+			.GetAttributes().First(a => a.Name == "src").Value;
+
+		string coverFileNameInCache = SaveCoverImageToCache(posterUrl, 1);
+
+		string description = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[3]/p").InnerText;
+		while (description.StartsWith('\n'))
+			description = description.Substring(1);
+
+		int year = DateTime.Now.Year;
+		string yearString = infoTable.Descendants("div").First(d => d.HasClass("updateAt"))
+			.InnerText.Split('-')[^1];
+
+		if(yearString.Contains("ago") == false)
+		{
+			year = Convert.ToInt32(yearString);
+		}
+
+		return new Publication(sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
+			year, originalLanguage, status, publicationId);
+	}
+
+	public override Chapter[] GetChapters(Publication publication, string language = "")
+	{
+		Log($"Getting chapters {publication}");
+		string requestUrl = $"https://mangakatana.com/manga/{publication.publicationId}";
+		// Leaving this in for verification if the page exists
+		DownloadClient.RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, 1);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return Array.Empty<Chapter>();
+
+		//Return Chapters ordered by Chapter-Number
+		NumberFormatInfo chapterNumberFormatInfo = new()
+		{
+			NumberDecimalSeparator = "."
+		};
+		List<Chapter> chapters = ParseChaptersFromHtml(publication, requestUrl);
+		Log($"Got {chapters.Count} chapters. {publication}");
+		return chapters.OrderBy(chapter => Convert.ToSingle(chapter.chapterNumber, chapterNumberFormatInfo)).ToArray();
+	}
+
+	private List<Chapter> ParseChaptersFromHtml(Publication publication, string mangaUrl)
+	{
+		// Using HtmlWeb will include the chapters since they are loaded with js 
+		HtmlWeb web = new();
+		HtmlDocument document = web.Load(mangaUrl);
+
+		List<Chapter> ret = new();
+
+		HtmlNode chapterList = document.DocumentNode.SelectSingleNode("//div[contains(@class, 'chapters')]/table/tbody");
+
+		foreach (HtmlNode chapterInfo in chapterList.Descendants("tr"))
+		{
+			string fullString = chapterInfo.Descendants("a").First().InnerText;
+
+			string? volumeNumber = fullString.Contains("Vol.") ? fullString.Replace("Vol.", "").Split(' ')[0] : null;
+			string chapterNumber = fullString.Split(':')[0].Split("Chapter ")[1].Split(" ")[0].Replace('-', '.');
+			string chapterName = string.Concat(fullString.Split(':')[1..]);
+			string url = chapterInfo.Descendants("a").First()
+				.GetAttributeValue("href", "");
+			ret.Add(new Chapter(publication, chapterName, volumeNumber, chapterNumber, url));
+		}
+		
+		return ret;
+	}
+
+	public override HttpStatusCode DownloadChapter(Publication publication, Chapter chapter, CancellationToken? cancellationToken = null)
+	{
+		if (cancellationToken?.IsCancellationRequested ?? false)
+			return HttpStatusCode.RequestTimeout;
+		Log($"Retrieving chapter-info {chapter} {publication}");
+		string requestUrl = chapter.url;
+		// Leaving this in to check if the page exists
+		DownloadClient.RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, 1);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return requestResult.statusCode;
+
+		string[] imageUrls = ParseImageUrlsFromHtml(requestUrl);
+
+		string comicInfoPath = Path.GetTempFileName();
+		File.WriteAllText(comicInfoPath, chapter.GetComicInfoXmlString());
+
+		return DownloadChapterImages(imageUrls, chapter.GetArchiveFilePath(settings.downloadLocation), 1, comicInfoPath, "https://mangakatana.com/", cancellationToken);
+	}
+
+	private string[] ParseImageUrlsFromHtml(string mangaUrl)
+	{
+		HtmlWeb web = new();
+		HtmlDocument document = web.Load(mangaUrl);
+
+		// Images are loaded dynamically, but the urls are present in a piece of js code on the page
+		string js = document.DocumentNode.SelectSingleNode("//script[contains(., 'data-src')]").InnerText
+			.Replace("\r", "")
+			.Replace("\n", "")
+			.Replace("\t", "");
+		
+		// ReSharper disable once StringLiteralTypo
+		string regexPat = @"(var thzq=\[')(.*)(,];function)";
+		var group = Regex.Matches(js, regexPat).First().Groups[2].Value.Replace("'", "");
+		var urls = group.Split(',');
+		
+		return urls;
+	}
+}

Tranga/MangaConnectors/Manganato.cs

@@ -0,0 +1,205 @@
+using System.Globalization;
+using System.Net;
+using System.Text.RegularExpressions;
+using HtmlAgilityPack;
+
+namespace Tranga.MangaConnectors;
+
+public class Manganato : Connector
+{
+    public override string name { get; }
+
+    public Manganato(TBaseObject clone) : base(clone)
+    {
+        this.name = "Manganato";
+        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
+        {
+            {1, 60}
+        }, clone);
+    }
+
+    protected override Publication[] GetPublications(string publicationTitle = "")
+    {
+        Log($"Searching Publications. Term=\"{publicationTitle}\"");
+        string sanitizedTitle = string.Join('_', Regex.Matches(publicationTitle, "[A-z]*")).ToLower();
+        string requestUrl = $"https://manganato.com/search/story/{sanitizedTitle}";
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, 1);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return Array.Empty<Publication>();
+
+        Publication[] publications = ParsePublicationsFromHtml(requestResult.result);
+        Log($"Retrieved {publications.Length} publications.");
+        return publications;
+    }
+
+    private Publication[] ParsePublicationsFromHtml(Stream html)
+    {
+        StreamReader reader = new (html);
+        string htmlString = reader.ReadToEnd();
+        HtmlDocument document = new ();
+        document.LoadHtml(htmlString);
+        IEnumerable<HtmlNode> searchResults = document.DocumentNode.Descendants("div").Where(n => n.HasClass("search-story-item"));
+        List<string> urls = new();
+        foreach (HtmlNode mangaResult in searchResults)
+        {
+            urls.Add(mangaResult.Descendants("a").First(n => n.HasClass("item-title")).GetAttributes()
+                .First(a => a.Name == "href").Value);
+        }
+
+        HashSet<Publication> ret = new();
+        foreach (string url in urls)
+        {
+            DownloadClient.RequestResult requestResult =
+                downloadClient.MakeRequest(url, 1);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+                return Array.Empty<Publication>();
+
+            ret.Add(ParseSinglePublicationFromHtml(requestResult.result, url.Split('/')[^1]));
+        }
+
+        return ret.ToArray();
+    }
+
+    private Publication ParseSinglePublicationFromHtml(Stream html, string publicationId)
+    {
+        StreamReader reader = new (html);
+        string htmlString = reader.ReadToEnd();
+        HtmlDocument document = new ();
+        document.LoadHtml(htmlString);
+        string status = "";
+        Dictionary<string, string> altTitles = new();
+        Dictionary<string, string>? links = null;
+        HashSet<string> tags = new();
+        string[] authors = Array.Empty<string>();
+        string originalLanguage = "";
+
+        HtmlNode infoNode = document.DocumentNode.Descendants("div").First(d => d.HasClass("story-info-right"));
+
+        string sortName = infoNode.Descendants("h1").First().InnerText;
+
+        HtmlNode infoTable = infoNode.Descendants().First(d => d.Name == "table");
+        
+        foreach (HtmlNode row in infoTable.Descendants("tr"))
+        {
+            string key = row.SelectNodes("td").First().InnerText.ToLower();
+            string value = row.SelectNodes("td").Last().InnerText;
+            string keySanitized = string.Concat(Regex.Matches(key, "[a-z]"));
+
+            switch (keySanitized)
+            {
+                case "alternative":
+                    string[] alts = value.Split(" ; ");
+                    for(int i = 0; i < alts.Length; i++)
+                        altTitles.Add(i.ToString(), alts[i]);
+                    break;
+                case "authors":
+                    authors = value.Split('-');
+                    break;
+                case "status":
+                    status = value;
+                    break;
+                case "genres":
+                    string[] genres = value.Split(" - ");
+                    tags = genres.ToHashSet();
+                    break;
+            }
+        }
+
+        string posterUrl = document.DocumentNode.Descendants("span").First(s => s.HasClass("info-image")).Descendants("img").First()
+            .GetAttributes().First(a => a.Name == "src").Value;
+
+        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, 1);
+
+        string description = document.DocumentNode.Descendants("div").First(d => d.HasClass("panel-story-info-description"))
+            .InnerText.Replace("Description :", "");
+        while (description.StartsWith('\n'))
+            description = description.Substring(1);
+
+        string yearString = document.DocumentNode.Descendants("li").Last(li => li.HasClass("a-h")).Descendants("span")
+            .First(s => s.HasClass("chapter-time")).InnerText;
+        int year = Convert.ToInt32(yearString.Split(',')[^1]) + 2000;
+        
+        return new Publication(sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
+            year, originalLanguage, status, publicationId);
+    }
+
+    public override Chapter[] GetChapters(Publication publication, string language = "")
+    {
+        Log($"Getting chapters {publication}");
+        string requestUrl = $"https://chapmanganato.com/{publication.publicationId}";
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, 1);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return Array.Empty<Chapter>();
+        
+        //Return Chapters ordered by Chapter-Number
+        NumberFormatInfo chapterNumberFormatInfo = new()
+        {
+            NumberDecimalSeparator = "."
+        };
+        List<Chapter> chapters = ParseChaptersFromHtml(publication, requestResult.result);
+        Log($"Got {chapters.Count} chapters. {publication}");
+        return chapters.OrderBy(chapter => Convert.ToSingle(chapter.chapterNumber, chapterNumberFormatInfo)).ToArray();
+    }
+
+    private List<Chapter> ParseChaptersFromHtml(Publication publication, Stream html)
+    {
+        StreamReader reader = new (html);
+        string htmlString = reader.ReadToEnd();
+        HtmlDocument document = new ();
+        document.LoadHtml(htmlString);
+        List<Chapter> ret = new();
+
+        HtmlNode chapterList = document.DocumentNode.Descendants("ul").First(l => l.HasClass("row-content-chapter"));
+
+        foreach (HtmlNode chapterInfo in chapterList.Descendants("li"))
+        {
+            string fullString = chapterInfo.Descendants("a").First(d => d.HasClass("chapter-name")).InnerText;
+
+            string? volumeNumber = fullString.Contains("Vol.") ? fullString.Replace("Vol.", "").Split(' ')[0] : null;
+            string chapterNumber = fullString.Split(':')[0].Split("Chapter ")[1].Replace('-','.');
+            string chapterName = string.Concat(fullString.Split(':')[1..]);
+            string url = chapterInfo.Descendants("a").First(d => d.HasClass("chapter-name"))
+                .GetAttributeValue("href", "");
+            ret.Add(new Chapter(publication, chapterName, volumeNumber, chapterNumber, url));
+        }
+        ret.Reverse();
+        return ret;
+    }
+
+    public override HttpStatusCode DownloadChapter(Publication publication, Chapter chapter, CancellationToken? cancellationToken = null)
+    {
+        if (cancellationToken?.IsCancellationRequested ?? false)
+            return HttpStatusCode.RequestTimeout;
+        Log($"Retrieving chapter-info {chapter} {publication}");
+        string requestUrl = chapter.url;
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, 1);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return requestResult.statusCode;
+
+        string[] imageUrls = ParseImageUrlsFromHtml(requestResult.result);
+        
+        string comicInfoPath = Path.GetTempFileName();
+        File.WriteAllText(comicInfoPath, chapter.GetComicInfoXmlString());
+        
+        return DownloadChapterImages(imageUrls, chapter.GetArchiveFilePath(settings.downloadLocation), 1, comicInfoPath, "https://chapmanganato.com/", cancellationToken);
+    }
+
+    private string[] ParseImageUrlsFromHtml(Stream html)
+    {
+        StreamReader reader = new (html);
+        string htmlString = reader.ReadToEnd();
+        HtmlDocument document = new ();
+        document.LoadHtml(htmlString);
+        List<string> ret = new();
+
+        HtmlNode imageContainer =
+            document.DocumentNode.Descendants("div").First(i => i.HasClass("container-chapter-reader"));
+        foreach(HtmlNode imageNode in imageContainer.Descendants("img"))
+            ret.Add(imageNode.GetAttributeValue("src", ""));
+
+        return ret.ToArray();
+    }
+}

Tranga/MangaConnectors/Mangasee.cs

@@ -0,0 +1,273 @@
+using System.Globalization;
+using System.Net;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using HtmlAgilityPack;
+using Newtonsoft.Json;
+using PuppeteerSharp;
+
+namespace Tranga.MangaConnectors;
+
+public class Mangasee : Connector
+{
+    public override string name { get; }
+    private IBrowser? _browser;
+    private const string ChromiumVersion = "1154303";
+
+    public Mangasee(TBaseObject clone) : base(clone)
+    {
+        this.name = "Mangasee";
+        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
+        {
+            { 1, 60 }
+        }, clone);
+
+        Task d = new Task(DownloadBrowser);
+        d.Start();
+    }
+
+    private async void DownloadBrowser()
+    {
+        BrowserFetcher browserFetcher = new BrowserFetcher();
+        foreach(string rev in browserFetcher.LocalRevisions().Where(rev => rev != ChromiumVersion))
+            browserFetcher.Remove(rev);
+        if (!browserFetcher.LocalRevisions().Contains(ChromiumVersion))
+        {
+            Log("Downloading headless browser");
+            DateTime last = DateTime.Now.Subtract(TimeSpan.FromSeconds(5));
+            browserFetcher.DownloadProgressChanged += (_, args) =>
+            {
+                double currentBytes = Convert.ToDouble(args.BytesReceived) / Convert.ToDouble(args.TotalBytesToReceive);
+                if (args.TotalBytesToReceive == args.BytesReceived)
+                    Log("Browser downloaded.");
+                else if (DateTime.Now > last.AddSeconds(1))
+                {
+                    Log($"Browser download progress: {currentBytes:P2}");
+                    last = DateTime.Now;
+                }
+
+            };
+            if (!browserFetcher.CanDownloadAsync(ChromiumVersion).Result)
+            {
+                Log($"Can't download browser version {ChromiumVersion}");
+                throw new Exception();
+            }
+            await browserFetcher.DownloadAsync(ChromiumVersion);
+        }
+        
+        Log("Starting Browser.");
+        this._browser = await Puppeteer.LaunchAsync(new LaunchOptions
+        {
+            Headless = true,
+            ExecutablePath = browserFetcher.GetExecutablePath(ChromiumVersion),
+            Args = new [] {
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+                "--disable-setuid-sandbox",
+                "--no-sandbox"}
+        });
+    }
+
+    protected override Publication[] GetPublications(string publicationTitle = "")
+    {
+        Log($"Searching Publications. Term=\"{publicationTitle}\"");
+        string requestUrl = $"https://mangasee123.com/_search.php";
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, 1);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return Array.Empty<Publication>();
+
+        return ParsePublicationsFromHtml(requestResult.result, publicationTitle);
+    }
+
+    private Publication[] ParsePublicationsFromHtml(Stream html, string publicationTitle)
+    {
+        string jsonString = new StreamReader(html).ReadToEnd();
+        List<SearchResultItem> result = JsonConvert.DeserializeObject<List<SearchResultItem>>(jsonString)!;
+        Dictionary<SearchResultItem, int> queryFiltered = new();
+        foreach (SearchResultItem resultItem in result)
+        {
+            int matches = resultItem.GetMatches(publicationTitle);
+            if (matches > 0)
+                queryFiltered.TryAdd(resultItem, matches);
+        }
+
+        queryFiltered = queryFiltered.Where(item => item.Value >= publicationTitle.Split(' ').Length - 1)
+            .ToDictionary(item => item.Key, item => item.Value);
+        
+        Log($"Retrieved {queryFiltered.Count} publications.");
+
+        HashSet<Publication> ret = new();
+        List<SearchResultItem> orderedFiltered =
+            queryFiltered.OrderBy(item => item.Value).ToDictionary(item => item.Key, item => item.Value).Keys.ToList();
+
+        uint index = 1;
+        foreach (SearchResultItem orderedItem in orderedFiltered)
+        {
+            DownloadClient.RequestResult requestResult =
+                downloadClient.MakeRequest($"https://mangasee123.com/manga/{orderedItem.i}", 1);
+            if ((int)requestResult.statusCode >= 200 || (int)requestResult.statusCode < 300)
+            {
+                Log($"Retrieving Publication info: {orderedItem.s} {index++}/{orderedFiltered.Count}");
+                ret.Add(ParseSinglePublicationFromHtml(requestResult.result, orderedItem.s, orderedItem.i, orderedItem.a));
+            }
+        }
+        return ret.ToArray();
+    }
+
+    
+    private Publication ParseSinglePublicationFromHtml(Stream html, string sortName, string publicationId, string[] a)
+    {
+        StreamReader reader = new (html);
+        HtmlDocument document = new ();
+        document.LoadHtml(reader.ReadToEnd());
+
+        string originalLanguage = "", status = "";
+        Dictionary<string, string> altTitles = new(), links = new();
+        HashSet<string> tags = new();
+
+        HtmlNode posterNode =
+            document.DocumentNode.Descendants("img").First(img => img.HasClass("img-fluid") && img.HasClass("bottom-5"));
+        string posterUrl = posterNode.GetAttributeValue("src", "");
+        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, 1);
+
+        HtmlNode attributes = document.DocumentNode.Descendants("div")
+            .First(div => div.HasClass("col-md-9") && div.HasClass("col-sm-8") && div.HasClass("top-5"))
+            .Descendants("ul").First();
+
+        HtmlNode[] authorsNodes = attributes.Descendants("li")
+            .First(node => node.InnerText.Contains("author(s):", StringComparison.CurrentCultureIgnoreCase))
+            .Descendants("a").ToArray();
+        List<string> authors = new();
+        foreach(HtmlNode authorNode in authorsNodes)
+            authors.Add(authorNode.InnerText);
+
+        HtmlNode[] genreNodes = attributes.Descendants("li")
+            .First(node => node.InnerText.Contains("genre(s):", StringComparison.CurrentCultureIgnoreCase))
+            .Descendants("a").ToArray();
+        foreach (HtmlNode genreNode in genreNodes)
+            tags.Add(genreNode.InnerText);
+
+        HtmlNode yearNode = attributes.Descendants("li")
+            .First(node => node.InnerText.Contains("released:", StringComparison.CurrentCultureIgnoreCase))
+            .Descendants("a").First();
+        int year = Convert.ToInt32(yearNode.InnerText);
+
+        HtmlNode[] statusNodes = attributes.Descendants("li")
+            .First(node => node.InnerText.Contains("status:", StringComparison.CurrentCultureIgnoreCase))
+            .Descendants("a").ToArray();
+        foreach(HtmlNode statusNode in statusNodes)
+            if (statusNode.InnerText.Contains("publish", StringComparison.CurrentCultureIgnoreCase))
+                status = statusNode.InnerText.Split(' ')[0];
+        
+        HtmlNode descriptionNode = attributes.Descendants("li").First(node => node.InnerText.Contains("description:", StringComparison.CurrentCultureIgnoreCase)).Descendants("div").First();
+        string description = descriptionNode.InnerText;
+        
+        int i = 0;
+        foreach(string at in a)
+            altTitles.Add((i++).ToString(), at);
+        
+        return new Publication(sortName, authors, description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
+            year, originalLanguage, status, publicationId);
+    }
+    
+    // ReSharper disable once ClassNeverInstantiated.Local Will be instantiated during deserialization
+    private class SearchResultItem
+    {
+        public string i { get; init; }
+        public string s { get; init; }
+        public string[] a { get; init; }
+
+        [JsonConstructor]
+        public SearchResultItem(string i, string s, string[] a)
+        {
+            this.i = i;
+            this.s = s;
+            this.a = a;
+        }
+
+        public int GetMatches(string title)
+        {
+            int ret = 0;
+            Regex cleanRex = new("[A-z0-9]*");
+            string[] badWords = { "a", "an", "no", "ni", "so", "as", "and", "the", "of", "that", "in", "is", "for" };
+
+            string[] titleTerms = title.Split(new[] { ' ', '-' }).Where(str => !badWords.Contains(str)).ToArray();
+
+            foreach (Match matchTerm in cleanRex.Matches(this.i))
+                ret += titleTerms.Count(titleTerm =>
+                    titleTerm.Equals(matchTerm.Value, StringComparison.OrdinalIgnoreCase));
+            
+            foreach (Match matchTerm in cleanRex.Matches(this.s))
+                ret += titleTerms.Count(titleTerm =>
+                    titleTerm.Equals(matchTerm.Value, StringComparison.OrdinalIgnoreCase));
+            
+            foreach(string alt in this.a)
+                foreach (Match matchTerm in cleanRex.Matches(alt))
+                    ret += titleTerms.Count(titleTerm =>
+                        titleTerm.Equals(matchTerm.Value, StringComparison.OrdinalIgnoreCase));
+            
+            return ret;
+        }
+    }
+
+    public override Chapter[] GetChapters(Publication publication, string language = "")
+    {
+        Log($"Getting chapters {publication}");
+        XDocument doc = XDocument.Load($"https://mangasee123.com/rss/{publication.publicationId}.xml");
+        XElement[] chapterItems = doc.Descendants("item").ToArray();
+        List<Chapter> chapters = new();
+        foreach (XElement chapter in chapterItems)
+        {
+            string volumeNumber = "1";
+            string chapterName = chapter.Descendants("title").First().Value;
+            string chapterNumber = Regex.Matches(chapterName, "[0-9]+")[^1].ToString();
+
+            string url = chapter.Descendants("link").First().Value;
+            url = url.Replace(Regex.Matches(url,"(-page-[0-9])")[0].ToString(),"");
+            chapters.Add(new Chapter(publication, "", volumeNumber, chapterNumber, url));
+        }
+
+        //Return Chapters ordered by Chapter-Number
+        NumberFormatInfo chapterNumberFormatInfo = new()
+        {
+            NumberDecimalSeparator = "."
+        };
+        Log($"Got {chapters.Count} chapters. {publication}");
+        return chapters.OrderBy(chapter => Convert.ToSingle(chapter.chapterNumber, chapterNumberFormatInfo)).ToArray();
+    }
+
+    public override HttpStatusCode DownloadChapter(Publication publication, Chapter chapter, CancellationToken? cancellationToken = null)
+    {
+        if (cancellationToken?.IsCancellationRequested ?? false)
+            return HttpStatusCode.RequestTimeout;
+        while (this._browser is null && !(cancellationToken?.IsCancellationRequested??false))
+        {
+            Log("Waiting for headless browser to download...");
+            Thread.Sleep(1000);
+        }
+        if (cancellationToken?.IsCancellationRequested??false)
+            return HttpStatusCode.RequestTimeout;
+        
+        Log($"Retrieving chapter-info {chapter} {publication}");
+        IPage page = _browser!.NewPageAsync().Result;
+        IResponse response = page.GoToAsync(chapter.url).Result;
+        if (response.Ok)
+        {
+            HtmlDocument document = new ();
+            document.LoadHtml(page.GetContentAsync().Result);
+
+            HtmlNode gallery = document.DocumentNode.Descendants("div").First(div => div.HasClass("ImageGallery"));
+            HtmlNode[] images = gallery.Descendants("img").Where(img => img.HasClass("img-fluid")).ToArray();
+            List<string> urls = new();
+            foreach(HtmlNode galleryImage in images)
+                urls.Add(galleryImage.GetAttributeValue("src", ""));
+            
+            string comicInfoPath = Path.GetTempFileName();
+            File.WriteAllText(comicInfoPath, chapter.GetComicInfoXmlString());
+        
+            return DownloadChapterImages(urls.ToArray(), chapter.GetArchiveFilePath(settings.downloadLocation), 1, comicInfoPath, cancellationToken:cancellationToken);
+        }
+        return response.Status;
+    }
+}