[CHANGE] Reworked parsers/converters. Decipher operation from script do not work!

Manager.App/Components/Application/Dev/DevelopmentVideo.razor

@@ -0,0 +1,16 @@
+@using Manager.App.Models.System
+@using Manager.App.Services.System
+
+@inject ISnackbar Snackbar
+@inject ClientService ClientService
+
+<MudText>Video data</MudText>
+<MudStack Spacing="2">
+    <MudAutocomplete T="YouTubeClientItem" Label="Client" @bind-Value="@_selectedClient" SearchFunc="SearchClientsAsync" ToStringFunc="@(i => i == null ? "null?" : $"{i.Name} ({i.Handle})")"
+                     Variant="Variant.Outlined" ShowProgressIndicator ProgressIndicatorColor="Color.Primary">
+    </MudAutocomplete>
+    <MudTextField Label="Video id" @bind-Value="@_videoId"/>
+</MudStack>
+<MudStack>
+    <MudButton OnClick="GetDataAsync">Get data</MudButton>
+</MudStack>

Manager.App/Components/Application/Dev/DevelopmentVideo.razor.cs

@@ -0,0 +1,56 @@
+using Manager.App.Models.System;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using MudBlazor;
+
+namespace Manager.App.Components.Application.Dev;
+
+public partial class DevelopmentVideo : ComponentBase
+{
+    private YouTubeClientItem? _selectedClient;
+    private string _videoId = "";
+    
+    private async Task<IEnumerable<YouTubeClientItem>> SearchClientsAsync(string? search, CancellationToken cancellationToken)
+    {
+        var searchResults = await ClientService.GetClientsAsync(search, cancellationToken: cancellationToken);
+        return !searchResults.IsSuccess ? [] : searchResults.Value;
+    }
+    
+    private async Task GetDataAsync(MouseEventArgs obj)
+    {
+        if (_selectedClient == null)
+        {
+            Snackbar.Add("No client selected!", Severity.Warning);
+            return;
+        }
+
+        if (string.IsNullOrWhiteSpace(_videoId))
+        {
+            Snackbar.Add("No video ID set!", Severity.Warning);
+            return;
+        }
+
+        if (_videoId.Length != 11)
+        {
+            Snackbar.Add("Video ID needs to have an length of 11 chars!", Severity.Warning);
+        }
+
+        var clientResult = await ClientService.LoadClientByIdAsync(_selectedClient.Id);
+        if (!clientResult.IsSuccess)
+        {
+            Snackbar.Add(clientResult.Error?.Description ?? $"Failed to get client with id: {_selectedClient.Id}", Severity.Error);
+            return;
+        }
+
+        var ytClient = clientResult.Value;
+        var videoResult = await ytClient.GetVideoByIdAsync(_videoId);
+        if (!videoResult.IsSuccess)
+        {
+            Snackbar.Add(videoResult.Error?.Description ?? $"Failed to load video: {_videoId}", Severity.Error);
+            return;
+        }
+
+        var ytVideo = videoResult.Value;
+        Snackbar.Add($"Loaded video {ytVideo.Title}", Severity.Success);
+    }
+}

Manager.App/Components/Layout/NavMenu.razor

@@ -2,9 +2,10 @@
 <MudNavMenu>
     <MudNavLink Href="/" Icon="@Icons.Material.Filled.Home" Match="NavLinkMatch.All">Home</MudNavLink>
     <MudNavGroup Title="Library" Expanded Icon="@Icons.Custom.Brands.YouTube" IconColor="Color.Error">
+        <MudNavLink Href="/Search" Icon="@Icons.Material.Filled.Search" Match="NavLinkMatch.All" Disabled>Search</MudNavLink>
         <MudNavLink Href="/Accounts" Icon="@Icons.Material.Filled.AccountBox" Match="NavLinkMatch.All">Accounts</MudNavLink>
         <MudNavLink Href="/Channels" Icon="@Icons.Material.Filled.AccountCircle" Match="NavLinkMatch.All">Channels</MudNavLink>
-        <MudNavLink Href="/Playlists" Icon="@Icons.Material.Filled.ViewList" Match="NavLinkMatch.All">Playlists</MudNavLink>
+        <MudNavLink Href="/Playlists" Icon="@Icons.Material.Filled.ViewList" Match="NavLinkMatch.All" Disabled>Playlists</MudNavLink>
         <MudNavLink Href="/Library" Icon="@Icons.Material.Filled.Info" Match="NavLinkMatch.All" IconColor="Color.Info">Info</MudNavLink>
     </MudNavGroup>
     <MudNavGroup Title="Application" Expanded Icon="@Icons.Material.Filled.SettingsSystemDaydream" IconColor="Color.Primary">

Manager.App/Components/Pages/Development.razor

@@ -6,4 +6,7 @@
     <MudTabPanel Text="Authentication">
         <AuthenticationHasher />
     </MudTabPanel>
+    <MudTabPanel Text="Video">
+        <DevelopmentVideo />
+    </MudTabPanel>
 </MudTabs>

Manager.App/Services/LibraryService.cs

@@ -16,7 +16,6 @@ namespace Manager.App.Services;
 public class LibraryService : ILibraryService
 {
     private readonly ILogger<LibraryService> _logger;
-    private readonly LibrarySettings _librarySettings;
     private readonly IDbContextFactory<LibraryDbContext> _dbContextFactory;
     private readonly DirectoryInfo _libraryDirectory;
     private readonly CacheService _cacheService;
@@ -24,13 +23,13 @@ public class LibraryService : ILibraryService
     public LibraryService(ILogger<LibraryService> logger, IOptions<LibrarySettings> librarySettings, IDbContextFactory<LibraryDbContext> contextFactory, CacheService cacheService)
     {
         _logger = logger;
-        _librarySettings = librarySettings.Value;
+        var librarySettings1 = librarySettings.Value;
         _dbContextFactory = contextFactory;
         _cacheService = cacheService;
-        _libraryDirectory = Directory.CreateDirectory(_librarySettings.Path);
+        _libraryDirectory = Directory.CreateDirectory(librarySettings1.Path);
         logger.LogDebug("Library directory: {LibraryWorkingDir}", _libraryDirectory.FullName);
-        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirMedia));
-        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirChannels));
+        Directory.CreateDirectory(Path.Combine(librarySettings1.Path, LibraryConstants.Directories.SubDirMedia));
+        Directory.CreateDirectory(Path.Combine(librarySettings1.Path, LibraryConstants.Directories.SubDirChannels));
     }
 
     private async Task AddWebImagesAsync(LibraryDbContext context, List<WebImage> images, string foreignKey, string libSubDir, string fileType, string subDir)
@@ -102,6 +101,7 @@ public class LibraryService : ILibraryService
             }
             else
             {
+                context.HttpCookies.RemoveRange(context.HttpCookies.Where(x => x.ClientId == client.Id));
                 context.ClientAccounts.Add(dbClient);
             }
 

Manager.App/Services/System/ClientService.cs

@@ -40,7 +40,7 @@ public class ClientService(IServiceScopeFactory scopeFactory, ILogger<ClientServ
         }
     }
 
-    public async Task<ListResult<YouTubeClientItem>> GetClientsAsync(string search, int offset = 0, int limit = 10, CancellationToken cancellationToken = default)
+    public async Task<ListResult<YouTubeClientItem>> GetClientsAsync(string? search, int offset = 0, int limit = 10, CancellationToken cancellationToken = default)
     {
         if (_libraryService == null)
         {

Manager.YouTube/Models/Innertube/ColorInfo.cs

@@ -1,8 +1,13 @@
+using System.Text.Json.Serialization;
+
 namespace Manager.YouTube.Models.Innertube;
 
 public class ColorInfo
 {
+    [JsonPropertyName("primaries")]
     public string Primaries { get; set; } = "";
+    [JsonPropertyName("transferCharacteristics")]
     public string TransferCharacteristics { get; set; } = "";
+    [JsonPropertyName("matrixCoefficients")]
     public string MatrixCoefficients { get; set; } = "";
 }

Manager.YouTube/Models/Innertube/Range.cs

@@ -1,7 +1,11 @@
+using System.Text.Json.Serialization;
+
 namespace Manager.YouTube.Models.Innertube;
 
 public class Range
 {
+    [JsonPropertyName("start")]
     public uint Start { get; set; }
+    [JsonPropertyName("end")]
     public uint End { get; set; }
 }

Manager.YouTube/Models/Innertube/StreamingData.cs

@@ -1,10 +1,16 @@
+using System.Text.Json.Serialization;
+
 namespace Manager.YouTube.Models.Innertube;
 
 public class StreamingData
 {
     public DateTime FetchedUtc { get; set; } = DateTime.UtcNow;
+    [JsonPropertyName("expiresInSeconds")]
     public int ExpiresInSeconds { get; set; }
+    [JsonPropertyName("serverAbrStreamingUrl")]
     public string ServerAbrStreamingUrl { get; set; } = "";
+    [JsonPropertyName("formats")]
     public List<StreamingFormat> Formats { get; set; } = [];
+    [JsonPropertyName("adaptiveFormats")]
     public List<StreamingFormat> AdaptiveFormats { get; set; } = [];
 }

Manager.YouTube/Models/Innertube/StreamingFormat.cs

@@ -1,31 +1,59 @@
+using System.Text.Json.Serialization;
+
 namespace Manager.YouTube.Models.Innertube;
 
 public class StreamingFormat
 {
+    [JsonPropertyName("itag")]
     public int Itag { get; set; }
+    [JsonPropertyName("url")]
     public string? Url { get; set; }
+    [JsonPropertyName("mimeType")]
     public string MimeType { get; set; } = "";
+    [JsonPropertyName("bitrate")]
     public uint Bitrate { get; set; }
+    [JsonPropertyName("width")]
     public uint? Width { get; set; }
+    [JsonPropertyName("height")]
     public uint? Height { get; set; }
+    [JsonPropertyName("initRange")]
     public Range? InitRange { get; set; }
+    [JsonPropertyName("indexRange")]
     public Range? IndexRange { get; set; }
+    [JsonPropertyName("lastModified")]
     public long LastModified { get; set; }
+    [JsonPropertyName("contentLength")]
     public long ContentLength { get; set; }
+    [JsonPropertyName("quality")]
     public string Quality { get; set; } = "";
+    [JsonPropertyName("xtags")]
     public string? Xtags { get; set; }
+    [JsonPropertyName("fps")]
     public uint Fps { get; set; }
+    [JsonPropertyName("qualityLabel")]
     public string QualityLabel { get; set; } = "";
+    [JsonPropertyName("projectionType")]
     public string ProjectionType { get; set; } = "";
+    [JsonPropertyName("averagebitrate")]
     public uint? AverageBitrate { get; set; }
+    [JsonPropertyName("highReplication")]
     public bool? HighReplication { get; set; }
+    [JsonPropertyName("colorInfo")]
     public ColorInfo? ColorInfo { get; set; }
+    [JsonPropertyName("audioQuality")]
     public string? AudioQuality { get; set; } = "";
+    [JsonPropertyName("approxDurationMs")]
     public long ApproxDurationMs { get; set; }
+    [JsonPropertyName("audioSampleRate")]
     public int? AudioSampleRate { get; set; }
+    [JsonPropertyName("audioChannels")]
     public int? AudioChannels { get; set; }
+    [JsonPropertyName("loudnessDb")]
     public double? LoudnessDb { get; set; }
+    [JsonPropertyName("isDrc")]
     public bool? IsDrc { get; set; }
+    [JsonPropertyName("signatureCipher")]
     public string? SignatureCipher { get; set; }
+    [JsonPropertyName("qualityOrdinal")]
     public string QualityOrdinal { get; set; } = "";
 }

Manager.YouTube/Models/Innertube/WebImage.cs

@@ -1,8 +1,13 @@
+using System.Text.Json.Serialization;
+
 namespace Manager.YouTube.Models.Innertube;
 
 public class WebImage
 {
+    [JsonPropertyName("width")]
     public int Width { get; set; }
+    [JsonPropertyName("height")]
     public int Height { get; set; }
+    [JsonPropertyName("url")]
     public string Url { get; set; } = "";
 }

Manager.YouTube/Models/Parser/YouTubeVideoData.cs

@@ -4,6 +4,6 @@ namespace Manager.YouTube.Models.Parser;
 
 public class YouTubeVideoData
 {
-    public JsonObject? YouTubePlayerData { get; set; }
-    public JsonObject? YouTubeInitialData { get; set; }
+    public JsonNode? YouTubePlayerData { get; set; }
+    public JsonNode? YouTubeInitialData { get; set; }
 }

Manager.YouTube/NetworkService.cs

@@ -8,7 +8,7 @@ public static class NetworkService
     public const string Origin = "https://www.youtube.com";
     private static readonly HttpClient HttpClient = new();
 
-    public static async Task<Result<string>> MakeRequestAsync(HttpRequestMessage request, YouTubeClient client, bool skipAuthenticationHeader = false)
+    public static async Task<Result<string>> MakeRequestAsync(HttpRequestMessage request, YouTubeClient client, bool skipAuthenticationHeader = false, CancellationToken cancellationToken = default)
     {
         request.Headers.Add("Origin", Origin);
         request.Headers.UserAgent.ParseAdd(client.UserAgent);
@@ -19,8 +19,8 @@ public static class NetworkService
 
         try
         {
-            var response = await client.HttpClient.SendAsync(request);
-            var contentString = await response.Content.ReadAsStringAsync();
+            var response = await client.HttpClient.SendAsync(request, cancellationToken);
+            var contentString = await response.Content.ReadAsStringAsync(cancellationToken);
             if (!response.IsSuccessStatusCode)
             {
                 return ResultError.Fail(contentString);

Manager.YouTube/Parsers/HtmlParser.cs

@@ -74,8 +74,8 @@ public static class HtmlParser
         {
             return new YouTubeVideoData
             {
-                YouTubePlayerData = parsedPlayerInitialData?.AsObject(),
-                YouTubeInitialData = parsedInitialData?.AsObject()
+                YouTubePlayerData = parsedPlayerInitialData,
+                YouTubeInitialData = parsedInitialData
             };
         }
         catch (Exception e)

Manager.YouTube/Parsers/Json/JsonParser.cs

@@ -12,45 +12,58 @@ public static class JsonParser
             .Select(image => new WebImage { Width = image.GetProperty("width").GetInt32(), Height = image.GetProperty("height").GetInt32(), Url = image.GetProperty("url").GetString() ?? "" })
             .ToList();
     
-    public static string ExtractTextOrHtml(JsonElement element)
+    public static string ExtractTextOrHtml(JsonNode? node)
     {
+        if (node is not JsonObject nodeObj)
+        {
+            return "";
+        }
+
         // Case 1: Simple text (no formatting)
-        if (element.TryGetProperty("simpleText", out var simpleText))
-            return simpleText.GetString() ?? string.Empty;
+        if (nodeObj.TryGetPropertyValue("simpleText", out var simpleText))
+            return simpleText?.GetValue<string>() ?? string.Empty;
 
         // Case 2: Runs (formatted text segments)
-        if (element.TryGetProperty("runs", out var runs) && runs.ValueKind == JsonValueKind.Array)
+        if (nodeObj.TryGetPropertyValue("runs", out var runs) && runs != null && runs.GetValueKind() == JsonValueKind.Array)
         {
             var sb = new StringBuilder();
 
-            foreach (var run in runs.EnumerateArray())
+            foreach (var runNode in runs.AsArray())
             {
-                var text = run.GetProperty("text").GetString() ?? string.Empty;
+                if (runNode is not JsonObject run)
+                {
+                    continue;
+                }
+
+                var text = runNode["text"]?.GetValue<string>() ?? string.Empty;
                 var formatted = System.Net.WebUtility.HtmlEncode(text);
 
-                var bold = run.TryGetProperty("bold", out var boldProp) && boldProp.GetBoolean();
-                var italic = run.TryGetProperty("italic", out var italicProp) && italicProp.GetBoolean();
-                var underline = run.TryGetProperty("underline", out var underlineProp) && underlineProp.GetBoolean();
-                var strikethrough = run.TryGetProperty("strikethrough", out var strikeProp) && strikeProp.GetBoolean();
+                var bold = run.TryGetPropertyValue("bold", out var boldNode) && boldNode is JsonValue bv && bv.GetValue<bool>();
+
+                var italic = run.TryGetPropertyValue("italic", out var italicNode) && italicNode is JsonValue iv && iv.GetValue<bool>();
+
+                var underline = run.TryGetPropertyValue("underline", out var underlineNode) && underlineNode is JsonValue uv && uv.GetValue<bool>();
+
+                var strikethrough = run.TryGetPropertyValue("strikethrough", out var strikeNode) && strikeNode is JsonValue sv && sv.GetValue<bool>();
 
                 if (bold) formatted = $"<b>{formatted}</b>";
                 if (italic) formatted = $"<i>{formatted}</i>";
                 if (underline) formatted = $"<u>{formatted}</u>";
                 if (strikethrough) formatted = $"<s>{formatted}</s>";
 
-                if (run.TryGetProperty("navigationEndpoint", out var nav) &&
-                    nav.TryGetProperty("url", out var urlProp))
+                if (run.TryGetPropertyValue("navigationEndpoint", out var nav) && nav is JsonObject navObj &&
+                    navObj.TryGetPropertyValue("url", out var urlProp))
                 {
-                    var url = urlProp.GetString();
+                    var url = urlProp?.GetValue<string>();
                     if (!string.IsNullOrEmpty(url))
                         formatted = $"<a href=\"{url}\">{formatted}</a>";
                 }
 
-                if (run.TryGetProperty("emoji", out var emoji) && emoji.ValueKind == JsonValueKind.Object)
+                if (run.TryGetPropertyValue("emoji", out var emoji) && emoji is JsonObject emojiObj)
                 {
-                    if (emoji.TryGetProperty("url", out var emojiUrl))
+                    if (emojiObj.TryGetPropertyValue("url", out var emojiUrl))
                     {
-                        var src = emojiUrl.GetString();
+                        var src = emojiUrl?.GetValue<string>();
                         if (!string.IsNullOrEmpty(src))
                             formatted = $"<img src=\"{src}\" alt=\"{text}\" class=\"emoji\" />";
                     }
@@ -65,9 +78,14 @@ public static class JsonParser
         return string.Empty;
     }
 
-    public static List<WebImage> ExtractWebImages(JsonElement element)
+    public static List<WebImage> ExtractWebImages(JsonNode? node)
     {
-        var thumbnailsArray = element.GetProperty("thumbnail").GetProperty("thumbnails");
-        return thumbnailsArray.Deserialize<List<WebImage>>() ?? [];
+        if (node == null)
+        {
+            return [];
+        }
+
+        var thumbnailsArray = node["thumbnails"];
+        return thumbnailsArray?.Deserialize<List<WebImage>>() ?? [];
     }
 }

Manager.YouTube/Parsers/Json/VideoJsonParser.cs

@@ -14,7 +14,7 @@ public static class VideoJsonParser
     
     public static Result<YouTubeVideo> ParseVideoData(YouTubeVideoData videoData)
     {
-        if (videoData.YouTubeInitialData == null || videoData.YouTubeInitialData.Count == 0)
+        if (videoData.YouTubePlayerData == null)
         {
             return ResultError.Fail("No initial video data found!");
         }
@@ -22,7 +22,7 @@ public static class VideoJsonParser
         YouTubeVideo? video;
         try
         {
-            video = videoData.YouTubeInitialData.Deserialize<YouTubeVideo>(VideoParserOptions);
+            video = videoData.YouTubePlayerData.Deserialize<YouTubeVideo>(VideoParserOptions);
         }
         catch (Exception e)
         {

Manager.YouTube/Util/Cipher/CipherDecoder.cs

@@ -8,7 +8,6 @@ namespace Manager.YouTube.Util.Cipher;
 public partial class CipherDecoder
 {
     public required string Version { get; init; }
-    public required string OriginalRelativeUrl { get; init; }
     public readonly IReadOnlySet<ICipherOperation> Operations;
 
     private CipherDecoder(IEnumerable<ICipherOperation> operations)
@@ -25,7 +24,6 @@ public partial class CipherDecoder
         var operations = await GetCipherOperations(relativeUrl, client);
         var decoder = new CipherDecoder(operations)
         {
-            OriginalRelativeUrl = relativeUrl,
             Version = version
         };
         return decoder;

Manager.YouTube/Util/Cipher/CipherManager.cs

@@ -1,5 +1,6 @@
 using DotBased.Logging;
 using DotBased.Monads;
+using Manager.YouTube.Models.Innertube;
 
 namespace Manager.YouTube.Util.Cipher;
 
@@ -8,9 +9,9 @@ public static class CipherManager
     private static readonly CipherDecoderCollection LoadedCiphers = [];
     private static readonly ILogger Logger = LogService.RegisterLogger(typeof(CipherManager));
 
-    public static async Task<Result<CipherDecoder>> GetDecoderAsync(YouTubeClient client)
+    public static async Task<Result<CipherDecoder>> GetDecoderAsync(ClientState clientState, YouTubeClient? client = null)
     {
-        var relativePlayerJsUrl = client.State?.PlayerJsUrl;
+        var relativePlayerJsUrl = clientState.PlayerJsUrl;
         if (string.IsNullOrEmpty(relativePlayerJsUrl))
         {
             return ResultError.Fail("Could not get player js url.");
@@ -25,7 +26,7 @@ public static class CipherManager
         
         try
         {
-            var decoder = await CipherDecoder.CreateAsync(relativePlayerJsUrl, version);
+            var decoder = await CipherDecoder.CreateAsync(relativePlayerJsUrl, version, client);
             LoadedCiphers.Add(decoder);
         }
         catch (Exception e)
@@ -38,7 +39,7 @@ public static class CipherManager
 
     private static string GetCipherVersion(string relativePlayerUrl)
     {
-        var split = relativePlayerUrl.Split('/');
+        var split = relativePlayerUrl.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
         var v = split[2];
         var lang = split[4];
         return $"{v}_{lang}";

Manager.YouTube/Util/Converters/NumericJsonConverter.cs

@@ -0,0 +1,39 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Manager.YouTube.Util.Converters;
+
+public class NumericJsonConverter<T> : JsonConverter<T> where T : struct, IConvertible
+{
+    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        try
+        {
+            if (reader.TokenType == JsonTokenType.Number)
+            {
+                // Direct numeric value
+                return (T)Convert.ChangeType(reader.GetDouble(), typeof(T));
+            }
+
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                var str = reader.GetString();
+                if (string.IsNullOrWhiteSpace(str))
+                    throw new JsonException("Empty string cannot be converted to a number.");
+
+                return (T)Convert.ChangeType(str, typeof(T));
+            }
+
+            throw new JsonException($"Unexpected token {reader.TokenType} for type {typeof(T)}.");
+        }
+        catch (Exception ex)
+        {
+            throw new JsonException($"Error converting value to {typeof(T)}.", ex);
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+    {
+        writer.WriteNumberValue(Convert.ToDouble(value));
+    }
+}

Manager.YouTube/Util/Converters/YouTubeVideoJsonConverter.cs

@@ -1,5 +1,6 @@
 using System.Runtime.Serialization;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 using DotBased.Logging;
 using Manager.YouTube.Models;
@@ -11,56 +12,74 @@ namespace Manager.YouTube.Util.Converters;
 public class YouTubeVideoJsonConverter : JsonConverter<YouTubeVideo>
 {
     private readonly ILogger _logger = LogService.RegisterLogger<YouTubeVideoJsonConverter>();
+    private readonly JsonSerializerOptions _serializerOptions = new()
+    {
+        Converters = {
+            new NumericJsonConverter<int>(),
+            new NumericJsonConverter<uint>(),
+            new NumericJsonConverter<long>(),
+            new NumericJsonConverter<double>(),
+            new NumericJsonConverter<decimal>() },
+        PropertyNameCaseInsensitive = true
+    };
 
     public override YouTubeVideo Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
-        using var document = JsonDocument.ParseValue(ref reader);
-        var root = document.RootElement;
+        var node = JsonNode.Parse(ref reader);
+        if (node == null)
+        {
+            throw new SerializationException("Failed to parse JSON reader.");
+        }
         
-        var playabilityStatus = root.GetProperty("playabilityStatus");
-        var streamingData = root.GetProperty("streamingData");
-        var videoDetails = root.GetProperty("videoDetails");
-        var playerConfigJson = root.GetProperty("playerConfig");
-        var microformat = root.GetProperty("microformat").GetProperty("playerMicroformatRenderer");
+        var rootObject = node.AsObject();
         
-        var videoId = videoDetails.GetProperty("videoId").GetString() ?? microformat.GetProperty("externalVideoId").GetString();
+        var playabilityStatus = rootObject["playabilityStatus"];
+        var streamingDataJson = rootObject["streamingData"];
+        var videoDetails = rootObject["videoDetails"];
+        var playerConfigJson = rootObject["playerConfig"];
+        var microformat = rootObject["microformat"]?["playerMicroformatRenderer"];
+        
+        var videoId = videoDetails?["videoId"]?.GetValue<string>() ?? microformat?["externalVideoId"]?.GetValue<string>();
         if (string.IsNullOrEmpty(videoId))
         {
             throw new SerializationException("Failed to get videoId");
         }
         
-        var thumbnails = JsonParser.ExtractWebImages(videoDetails.GetProperty("thumbnail"));
-        thumbnails.AddRange(JsonParser.ExtractWebImages(microformat.GetProperty("thumbnail")));
+        var thumbnails = JsonParser.ExtractWebImages(videoDetails?["thumbnail"]);
+        thumbnails.AddRange(JsonParser.ExtractWebImages(microformat?["thumbnail"]));
+
+        var streamingData = streamingDataJson.Deserialize<StreamingData>(_serializerOptions);
+        var playerConfig = ExtractPlayerConfig(playerConfigJson);
         
         var video = new YouTubeVideo
         {
             VideoId = videoId,
-            Title = JsonParser.ExtractTextOrHtml(microformat.GetProperty("title")),
-            Description = JsonParser.ExtractTextOrHtml(microformat.GetProperty("description")),
-            ViewCount = videoDetails.GetProperty("viewCount").GetInt32(),
-            LikeCount = videoDetails.GetProperty("likeCount").GetInt32(),
-            ChannelId = videoDetails.GetProperty("channelId").GetString() ?? "",
-            Author = JsonParser.ExtractTextOrHtml(videoDetails.GetProperty("author")),
-            PlayabilityStatus = playabilityStatus.GetProperty("status").GetString() ?? "",
-            LengthSeconds = videoDetails.GetProperty("lengthSeconds").GetInt32(),
-            Keywords = videoDetails.GetProperty("keywords").EnumerateArray().Select(v => v.GetString()).Cast<string>().ToArray(),
-            IsOwnerViewing = videoDetails.GetProperty("isOwnerViewing").GetBoolean(),
-            AllowRating = videoDetails.GetProperty("allowRating").GetBoolean(),
-            IsCrawlable = videoDetails.GetProperty("isCrawlable").GetBoolean(),
-            IsPrivate = videoDetails.GetProperty("isPrivate").GetBoolean(),
-            IsUnpluggedCorpus = videoDetails.GetProperty("isUnpluggedCorpus").GetBoolean(),
-            IsLive = videoDetails.GetProperty("isLiveContent").GetBoolean(),
-            IsFamilySave = microformat.GetProperty("isFamilySave").GetBoolean(),
-            AvailableCountries = microformat.GetProperty("availableCountries").EnumerateArray().Select(v => v.GetString()).Cast<string>().ToArray(),
-            IsUnlisted = microformat.GetProperty("isUnlisted").GetBoolean(),
-            HasYpcMetadata = microformat.GetProperty("hasYpcMetadata").GetBoolean(),
-            PublishDate = microformat.GetProperty("publishDate").GetDateTime(),
-            UploadDate = microformat.GetProperty("uploadDate").GetDateTime(),
-            IsShortsEligible = microformat.GetProperty("isShortsEligible").GetBoolean(),
-            Category = microformat.GetProperty("category").GetString() ?? "",
-            StreamingData = streamingData.Deserialize<StreamingData>(),
+            Title = JsonParser.ExtractTextOrHtml(microformat?["title"]),
+            Description = JsonParser.ExtractTextOrHtml(microformat?["description"]),
+            ViewCount = long.TryParse(microformat?["viewCount"]?.GetValue<string>(), out var viewCountParsed) ? viewCountParsed : -1,
+            LikeCount = long.TryParse(microformat?["likeCount"]?.GetValue<string>(), out var likeCountParsed) ? likeCountParsed : -1,
+            ChannelId = videoDetails?["channelId"]?.GetValue<string>() ?? "",
+            Author = videoDetails?["author"]?.GetValue<string>() ?? "",
+            PlayabilityStatus = playabilityStatus?["status"]?.GetValue<string>() ?? "",
+            LengthSeconds = long.TryParse(videoDetails?["lengthSeconds"]?.GetValue<string>(), out var lengthSecondsParsed) ? lengthSecondsParsed : -1,
+            Keywords = videoDetails?["keywords"]?.AsArray().Select(v => v?.GetValue<string>() ?? "").ToArray() ?? [],
+            IsOwnerViewing = videoDetails?["isOwnerViewing"]?.GetValue<bool>() ?? false,
+            AllowRating = videoDetails?["allowRating"]?.GetValue<bool>() ?? false,
+            IsCrawlable = videoDetails?["isCrawlable"]?.GetValue<bool>() ?? false,
+            IsPrivate = videoDetails?["isPrivate"]?.GetValue<bool>() ?? false,
+            IsUnpluggedCorpus = videoDetails?["isUnpluggedCorpus"]?.GetValue<bool>() ?? false,
+            IsLive = videoDetails?["isLiveContent"]?.GetValue<bool>() ?? false,
+            IsFamilySave = microformat?["isFamilySave"]?.GetValue<bool>() ?? false,
+            AvailableCountries = microformat?["availableCountries"]?.AsArray().Select(v => v?.GetValue<string>() ?? "").ToArray() ?? [],
+            IsUnlisted = microformat?["isUnlisted"]?.GetValue<bool>() ?? false,
+            HasYpcMetadata = microformat?["hasYpcMetadata"]?.GetValue<bool>() ?? false,
+            PublishDate = DateTime.TryParse(microformat?["publishDate"]?.GetValue<string>(), out var parsedPublishDate) ? parsedPublishDate : DateTime.MinValue,
+            UploadDate = DateTime.TryParse(microformat?["uploadDate"]?.GetValue<string>(), out var parsedUploadDate) ? parsedUploadDate : DateTime.MinValue,
+            IsShortsEligible = microformat?["isShortsEligible"]?.GetValue<bool>() ?? false,
+            Category = microformat?["category"]?.GetValue<string>() ?? "",
+            StreamingData = streamingData,
             Thumbnails = thumbnails,
-            PlayerConfig = ExtractPlayerConfig(playerConfigJson)
+            PlayerConfig = playerConfig
         };
         
         return video;
@@ -71,23 +90,25 @@ public class YouTubeVideoJsonConverter : JsonConverter<YouTubeVideo>
         throw new NotImplementedException("Converter only supports reading.");
     }
 
-    private PlayerConfig? ExtractPlayerConfig(JsonElement element)
+    private PlayerConfig? ExtractPlayerConfig(JsonNode? playerConfigNode)
     {
+        if (playerConfigNode == null)
+        {
+            return null;
+        }
+
         try
         {
+            var playerConfigObj = playerConfigNode.AsObject();
             var playerConfig = new PlayerConfig
             {
-                AudioLoudnessDb = element.GetProperty("audioConfig").GetProperty("loudnessDb").GetDouble(),
-                AudioPerceptualLoudnessDb = element.GetProperty("audioConfig").GetProperty("perceptualLoudnessDb").GetDouble(),
-                AudioEnablePerFormatLoudness = element.GetProperty("audioConfig").GetProperty("enablePerFormatLoudness")
-                    .GetBoolean(),
-                MaxBitrate = element.GetProperty("streamSelectionConfig").GetProperty("maxBitrate").GetUInt32(),
-                MaxReadAheadMediaTimeMs = element.GetProperty("mediaCommonConfig").GetProperty("dynamicReadaheadConfig")
-                    .GetProperty("maxReadAheadMediaTimeMs").GetUInt32(),
-                MinReadAheadMediaTimeMs = element.GetProperty("mediaCommonConfig").GetProperty("dynamicReadaheadConfig")
-                    .GetProperty("minReadAheadMediaTimeMs").GetUInt32(),
-                ReadAheadGrowthRateMs = element.GetProperty("mediaCommonConfig").GetProperty("dynamicReadaheadConfig")
-                    .GetProperty("readAheadGrowthRateMs").GetUInt32(),
+                AudioLoudnessDb = playerConfigObj["audioConfig"]?["loudnessDb"]?.GetValue<double>() ?? 0,
+                AudioPerceptualLoudnessDb = playerConfigObj["audioConfig"]?["perceptualLoudnessDb"]?.GetValue<double>() ?? 0,
+                AudioEnablePerFormatLoudness = playerConfigObj["audioConfig"]?["enablePerFormatLoudness"]?.GetValue<bool>() ?? false,
+                MaxBitrate = uint.TryParse(playerConfigObj["streamSelectionConfig"]?["maxBitrate"]?.GetValue<string>(), out var parsedMaxBitrate) ? parsedMaxBitrate : 0,
+                MaxReadAheadMediaTimeMs = playerConfigObj["mediaCommonConfig"]?["dynamicReadaheadConfig"]?["maxReadAheadMediaTimeMs"]?.GetValue<uint>() ?? 0,
+                MinReadAheadMediaTimeMs = playerConfigObj["mediaCommonConfig"]?["dynamicReadaheadConfig"]?["minReadAheadMediaTimeMs"]?.GetValue<uint>() ?? 0,
+                ReadAheadGrowthRateMs = playerConfigObj["mediaCommonConfig"]?["dynamicReadaheadConfig"]?["readAheadGrowthRateMs"]?.GetValue<uint>() ?? 0,
             };
             return playerConfig;
         }

Manager.YouTube/YouTubeClient.cs

@@ -16,8 +16,8 @@ namespace Manager.YouTube;
 public sealed class YouTubeClient : IDisposable
 {
     public string Id { get; private set; } = "";
-    public string? UserAgent { get; set; }
-    public bool IsAnonymous { get; }
+    public string UserAgent { get; private set; }
+    public bool IsAnonymous { get; private set; }
     public CookieContainer CookieContainer { get; } = new() { PerDomainCapacity = 50 };
     public ClientState? State { get; private set; }
     public List<string> DatasyncIds { get; } = [];
@@ -52,7 +52,7 @@ public sealed class YouTubeClient : IDisposable
     /// </summary>
     /// <param name="cookies">The cookies to use for making requests. Empty collection or null for anonymous requests.</param>
     /// <param name="userAgent">The user agent to use for the requests. Only WEB client is supported.</param>
-    /// <param name="logger">The logger that the client is going to use, if null will create a new logger.</param>
+    /// <param name="logger">The logger that the client is going to use, null will create a new logger.</param>
     /// <returns></returns>
     public static async Task<Result<YouTubeClient>> CreateAsync(CookieCollection? cookies, string userAgent, ILogger? logger = null)
     {
@@ -68,112 +68,55 @@ public sealed class YouTubeClient : IDisposable
         return client;
     }
 
-    private HttpClientHandler GetHttpClientHandler()
+    public void SetUserAgent(string userAgent)
     {
-        var clientHandler = new HttpClientHandler
+        if (string.IsNullOrWhiteSpace(userAgent))
         {
-            AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
-            UseCookies = true,
-            CookieContainer = CookieContainer
-        };
-        return clientHandler;
+            _logger.Warning("UserAgent cannot be null or empty!");
+            return;
+        }
+        UserAgent = userAgent;
     }
 
-    internal async Task<Result> FetchClientDataAsync()
+    public async Task<Result<YouTubeVideo>> GetVideoByIdAsync(string videoId, CancellationToken cancellationToken = default)
     {
-        if (State is not { LoggedIn: true })
+        if (string.IsNullOrWhiteSpace(videoId))
         {
-            var state = await GetClientStateAsync();
-            if (!state.IsSuccess)
-            {
-                return state;
-            }
+            return ResultError.Fail("Video id is empty!");
         }
 
-        if (string.IsNullOrWhiteSpace(State?.WebPlayerContextConfig?.WebPlayerContext?.DatasyncId))
-        {
-            var datasyncResult = await GetDatasyncIdsAsync();
-            if (!datasyncResult.IsSuccess)
-            {
-                return datasyncResult;
-            }
+        var request = new HttpRequestMessage(HttpMethod.Get, new Uri($"{NetworkService.Origin}/watch?v={videoId}"));
         
-            foreach (var id in datasyncResult.Value)
-            {
-                if (DatasyncIds.Contains(id))
-                    continue;
-                DatasyncIds.Add(id);
-            }
+        var videoResponse = await NetworkService.MakeRequestAsync(request, this, true, cancellationToken);
+        if (!videoResponse.IsSuccess && !string.IsNullOrWhiteSpace(videoResponse.Value))
+        {
+            return videoResponse.Error ?? ResultError.Fail("Request failed!");
         }
 
-        if (string.IsNullOrWhiteSpace(Id))
-        {
-            var accountInfoResult = await GetCurrentAccountIdAsync();
-            if (!accountInfoResult.IsSuccess)
-            {
-                return accountInfoResult;
-            }
+        var html = videoResponse.Value;
         
-            Id = accountInfoResult.Value;
+        var stateResult = GetClientStateFromHtml(html);
+        var state = stateResult.Value;
+        if (!stateResult.IsSuccess && State != null)
+        {
+            state = State;
         }
         
-        return Result.Success();
-    }
-    
-    private async Task<Result> GetClientStateAsync()
-    {
-        var httpRequest = new HttpRequestMessage
+        var htmlParseResult = HtmlParser.GetVideoDataFromHtml(html);
+        if (!htmlParseResult.IsSuccess)
         {
-            Method = HttpMethod.Get,
-            RequestUri = new Uri(NetworkService.Origin)
-        };
-        
-        var result = await NetworkService.MakeRequestAsync(httpRequest, this, true);
-        if (!result.IsSuccess)
-        {
-            return result.Error ?? ResultError.Fail("Request failed!");
+            return htmlParseResult.Error ?? ResultError.Fail("Failed to parse HTML video data!");
         }
         
-        var stateResult = SetClientStateFromHtml(result.Value);
-        if (!stateResult.IsSuccess)
+        var videoParseResult = VideoJsonParser.ParseVideoData(htmlParseResult.Value);
+        if (!videoParseResult.IsSuccess)
         {
-            return stateResult;
+            return videoParseResult;
         }
         
-        var cookieRotationResult = await RotateCookiesPageAsync();
-        return !cookieRotationResult.IsSuccess ? cookieRotationResult : Result.Success();
-    }
+        await DecipherSignatures(videoParseResult.Value, state);
 
-    private Result SetClientStateFromHtml(string html)
-    {
-        if (string.IsNullOrWhiteSpace(html))
-        {
-            return ResultError.Fail("HTML is empty!!");
-        }
-        
-        var clientStateResult = HtmlParser.GetStateJson(html);
-        if (clientStateResult is { IsSuccess: false, Error: not null })
-        {
-            return clientStateResult.Error;
-        }
-
-        try
-        {
-            State = JsonSerializer.Deserialize<ClientState>(clientStateResult.Value.Item1);
-        }
-        catch (Exception e)
-        {
-            return ResultError.Error(e, "Error while parsing JSON!");
-        }
-
-        if (State == null)
-        {
-            return ResultError.Fail("Unable to parse client state!");
-        }
-
-        State.IsPremiumUser = clientStateResult.Value.Item2;
-        
-        return Result.Success();
+        return videoParseResult.Value;
     }
     
     public async Task<Result<InnertubeChannel>> GetChannelByIdAsync(string channelId)
@@ -232,10 +175,10 @@ public sealed class YouTubeClient : IDisposable
 
     public async Task<Result> RotateCookiesPageAsync(string origin = NetworkService.Origin, int ytPid = 1)
     {
-        if (IsAnonymous)
+        /*if (IsAnonymous)
         {
             return ResultError.Fail("Anonymous clients cannot rotate cookies!");
-        }
+        }*/
 
         if (string.IsNullOrWhiteSpace(origin))
         {
@@ -262,6 +205,132 @@ public sealed class YouTubeClient : IDisposable
         HttpClient.Dispose();
     }
 
+    private async Task<Result> FetchClientDataAsync()
+    {
+        if (State is not { LoggedIn: true })
+        {
+            var stateResult = await GetClientStateAsync();
+            if (!stateResult.IsSuccess)
+            {
+                return stateResult;
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(State?.WebPlayerContextConfig?.WebPlayerContext?.DatasyncId))
+        {
+            var datasyncResult = await GetDatasyncIdsAsync();
+            if (!datasyncResult.IsSuccess)
+            {
+                return datasyncResult;
+            }
+
+            foreach (var id in datasyncResult.Value)
+            {
+                if (DatasyncIds.Contains(id))
+                    continue;
+                DatasyncIds.Add(id);
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(Id))
+        {
+            var accountInfoResult = await GetCurrentAccountIdAsync();
+            if (!accountInfoResult.IsSuccess)
+            {
+                return accountInfoResult;
+            }
+
+            Id = accountInfoResult.Value;
+        }
+
+        return Result.Success();
+    }
+    
+    private HttpClientHandler GetHttpClientHandler()
+    {
+        var clientHandler = new HttpClientHandler
+        {
+            AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
+            UseCookies = true,
+            CookieContainer = CookieContainer
+        };
+        return clientHandler;
+    }
+    
+    private async Task<Result> GetClientStateAsync()
+    {
+        var httpRequest = new HttpRequestMessage
+        {
+            Method = HttpMethod.Get,
+            RequestUri = new Uri(NetworkService.Origin)
+        };
+        
+        var result = await NetworkService.MakeRequestAsync(httpRequest, this, true);
+        if (!result.IsSuccess)
+        {
+            return result.Error ?? ResultError.Fail("Request failed!");
+        }
+
+        var stateResult = SetClientStateFromHtml(result.Value);
+        if (!stateResult.IsSuccess)
+        {
+            return stateResult;
+        }
+
+        if (State is { LoggedIn: false })
+        {
+            _logger.Warning("Client is not logged in!");
+            return ResultError.Fail("Client login failed!");
+        }
+
+        var cookieRotationResult = await RotateCookiesPageAsync();
+        return !cookieRotationResult.IsSuccess ? cookieRotationResult : Result.Success();
+    }
+
+    private Result SetClientStateFromHtml(string html)
+    {
+        if (string.IsNullOrWhiteSpace(html))
+        {
+            return ResultError.Fail("HTML is empty!!");
+        }
+
+        var clientStateResult = GetClientStateFromHtml(html);
+        if (clientStateResult is { IsSuccess: false, Error: not null })
+        {
+            return clientStateResult.Error;
+        }
+        
+        State = clientStateResult.Value;
+        IsAnonymous = !State.LoggedIn;
+        
+        return Result.Success();
+    }
+
+    private Result<ClientState> GetClientStateFromHtml(string html)
+    {
+        var clientStateResult = HtmlParser.GetStateJson(html);
+        if (clientStateResult is { IsSuccess: false, Error: not null })
+        {
+            return clientStateResult.Error;
+        }
+        
+        ClientState? state;
+        try
+        {
+            state = JsonSerializer.Deserialize<ClientState>(clientStateResult.Value.Item1);
+            if (state != null)
+            {
+                state.IsPremiumUser = clientStateResult.Value.Item2;
+            }
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e, "Error while parsing JSON!");
+        }
+        
+        return state == null ? ResultError.Fail("Unable to parse client state!") : state;
+    }
+    
     private async Task<Result<string>> GetCurrentAccountIdAsync()
     {
         if (State is not { LoggedIn: true })
@@ -317,47 +386,7 @@ public sealed class YouTubeClient : IDisposable
         return ResultError.Fail("Failed to get datasyncIds! Client not logged in.");
     }
 
-    public async Task<Result<YouTubeVideo>> GetVideoByIdAsync(string videoId, CancellationToken cancellationToken = default)
-    {
-        if (string.IsNullOrWhiteSpace(videoId))
-        {
-            return ResultError.Fail("Video id is empty!");
-        }
-
-        var request = new HttpRequestMessage(HttpMethod.Get, new Uri($"{NetworkService.Origin}/watch?v={videoId}"));
-        
-        var response = await NetworkService.MakeRequestAsync(request, this);
-        if (!response.IsSuccess && !string.IsNullOrWhiteSpace(response.Value))
-        {
-            return response.Error ?? ResultError.Fail("Request failed!");
-        }
-
-        var html = response.Value;
-        
-        var stateResult = SetClientStateFromHtml(html);
-        if (!stateResult.IsSuccess)
-        {
-            _logger.Warning("Failed to update client state.");
-        }
-        
-        var htmlParseResult = HtmlParser.GetVideoDataFromHtml(html);
-        if (!htmlParseResult.IsSuccess)
-        {
-            return htmlParseResult.Error ?? ResultError.Fail("Failed to parse HTML video data!");
-        }
-        
-        var videoParseResult = VideoJsonParser.ParseVideoData(htmlParseResult.Value);
-        if (!videoParseResult.IsSuccess)
-        {
-            return videoParseResult;
-        }
-        
-        await DecipherSignatures(videoParseResult.Value);
-
-        return videoParseResult.Value;
-    }
-
-    private async Task DecipherSignatures(YouTubeVideo video)
+    private async Task DecipherSignatures(YouTubeVideo video, ClientState state)
     {
         var streamingData = video.StreamingData;
         if (streamingData == null)
@@ -373,7 +402,7 @@ public sealed class YouTubeClient : IDisposable
             return;
         }
 
-        var decipherDecoderResult = await CipherManager.GetDecoderAsync(this);
+        var decipherDecoderResult = await CipherManager.GetDecoderAsync(state, this);
         if (!decipherDecoderResult.IsSuccess)
         {
             _logger.Warning(decipherDecoderResult.Error?.Description ?? "Failed to get the cipher decoder!");