[CHANGE] Adding playlist functionality

.gitignore

@@ -307,10 +307,6 @@ node_modules/
 *.dsw
 *.dsp
 
-# Visual Studio 6 technical files
-*.ncb
-*.aps
-
 # Visual Studio LightSwitch build output
 **/*.HTMLClient/GeneratedArtifacts
 **/*.DesktopClient/GeneratedArtifacts
@@ -404,14 +400,8 @@ FodyWeavers.xsd
 *.sln.iml
 .idea
 
-##
-## Visual studio for Mac
-##
-
-
 # globs
 Makefile.in
-*.userprefs
 *.usertasks
 config.make
 config.status
@@ -470,16 +460,12 @@ ehthumbs_vista.db
 # Recycle Bin used on file shares
 $RECYCLE.BIN/
 
-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
 # Windows shortcuts
 *.lnk
 
 # Vim temporary swap files
 *.swp
-/Manager.App/Library/
+
+# Manager.App
+[Ll]ibrary/
+[Cc]ache/

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

@@ -0,0 +1,13 @@
+@using Manager.App.Models.System
+@using Manager.App.Services.System
+
+@inject ISnackbar Snackbar
+@inject ClientService ClientService
+
+<MudText>Cipher manager</MudText>
+<MudStack Row 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>
+    <MudButton OnClick="ExecCipher">Exec</MudButton>
+</MudStack>

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

@@ -0,0 +1,43 @@
+using Manager.App.Models.System;
+using Manager.YouTube.Util.Cipher;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using MudBlazor;
+
+namespace Manager.App.Components.Application.Dev;
+
+public partial class CipherDev : ComponentBase
+{
+    private YouTubeClientItem? _selectedClient;
+    
+    private async Task ExecCipher(MouseEventArgs obj)
+    {
+        if (_selectedClient == null)
+        {
+            Snackbar.Add("No client selected", Severity.Warning);
+            return;
+        }
+
+        var ytClientResult = await ClientService.LoadClientByIdAsync(_selectedClient.Id);
+        if (!ytClientResult.IsSuccess)
+        {
+            Snackbar.Add(ytClientResult.Error?.Description ?? "Failed to get the client!", Severity.Error);
+            return;
+        }
+
+        var ytClient = ytClientResult.Value;
+        if (ytClient.State == null)
+        {
+            Snackbar.Add("Client state is null!", Severity.Warning);
+            return;
+        }
+
+        var decoder = await CipherManager.GetDecoderAsync(ytClient.State, ytClient);
+    }
+    
+    private async Task<IEnumerable<YouTubeClientItem>> SearchClientsAsync(string? search, CancellationToken cancellationToken)
+    {
+        var searchResults = await ClientService.GetClientsAsync(search, cancellationToken: cancellationToken);
+        return !searchResults.IsSuccess ? [] : searchResults.Value;
+    }
+}

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

@@ -0,0 +1,17 @@
+@using Manager.App.Models.System
+@using Manager.App.Services.System
+
+@inject ISnackbar Snackbar
+@inject ClientService ClientService
+@inject NavigationManager NavigationManager
+
+<MudText>Video data</MudText>
+<MudStack Row 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="NavigateToVideo">Get data</MudButton>
+</MudStack>

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

@@ -0,0 +1,40 @@
+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 void NavigateToVideo(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);
+        }
+
+        NavigationManager.NavigateTo($"/video/{_videoId}?clientId={_selectedClient.Id}");
+    }
+}

Manager.App/Components/Application/System/EventConsole.razor.cs

@@ -107,7 +107,7 @@ public partial class EventConsole : ComponentBase
                 _batchLock.Release();
             }
 
-            foreach (var serviceEvent in _batchBuffer.Where(serviceEvent => !_serviceEvents.Contains(serviceEvent)))
+            foreach (var serviceEvent in batch.Where(serviceEvent => !_serviceEvents.Contains(serviceEvent)))
             {
                 _serviceEvents.Add(serviceEvent);
             }

Manager.App/Components/Dialogs/AccountDialog.razor

@@ -1,11 +1,13 @@
+@using Manager.App.Services.System
 @inject ISnackbar SnackbarService
+@inject CacheService Cache
 
 <ForcedLoadingOverlay Visible="_isLoading"/>
 
 @{
-    var client = PreparingClient?.YouTubeClient;
+    var client = ClientChannel?.YouTubeClient;
     var clientState = client?.State;
-    var channel = PreparingClient?.Channel;
+    var channel = ClientChannel?.Channel;
     var avatar = channel?.AvatarImages.FirstOrDefault();
     var banner = channel?.BannerImages.FirstOrDefault();
 }
@@ -19,51 +21,72 @@
             case AccountImportSteps.Authenticate:
                 <MudStack Spacing="2">
                     <MudPaper Elevation="0" Outlined Class="pa-2">
-                        <MudSwitch @bind-Value="@IsAnonymous" Color="Color.Info">Anonymous client</MudSwitch>
                         <MudTextField @bind-Value="@DefaultUserAgent" Required Label="User agent"
-                                      HelperText="Use an WEB client user agent."/>
+                                      HelperText="Use an WEB user agent."/>
                     </MudPaper>
 
                     <MudStack Row Spacing="2" Style="height: 100%">
                         <MudPaper Elevation="0" Outlined Class="pa-2" Style="width: 50%;">
-                            <MudText>Import cookies</MudText>
-                            <MudText Typo="Typo.caption">@($"{ImportCookies.Count} cookie(s) imported")</MudText>
-                            <MudForm @bind-IsValid="@_cookieImportTextValid" Disabled="@(IsAnonymous)">
-                                <MudTextField @bind-Value="@_cookieDomain" Immediate Required Label="Domain"
-                                              RequiredError="Domain is required."/>
-                                <MudTextField Class="my-2" Lines="4" AutoGrow @bind-Value="@_cookieText" Immediate
-                                              Required Label="Cookies" Variant="Variant.Outlined"
-                                              Placeholder="EXAMPLE: Cookie1=Value1; Cookie2=Value2;"
-                                              Validation="@(new Func<string, string?>(ValidateCookieText))"/>
-                                <MudButton Variant="Variant.Outlined" Disabled="@(!_cookieImportTextValid)"
-                                           OnClick="ParseCookies">Import
+                            <MudText>Import cookies (Netscape Cookie format)</MudText>
+                            <MudStack Spacing="2">
+                                <MudStack Row Spacing="2">
+                                    <MudFileUpload T="IBrowserFile" Accept=".txt" FilesChanged="UploadFiles">
+                                        <ActivatorContent>
+                                            <MudButton Variant="Variant.Filled"
+                                                       Color="Color.Primary"
+                                                       StartIcon="@Icons.Material.Filled.CloudUpload">
+                                                Upload cookie txt
                                             </MudButton>
-                            </MudForm>
+                                        </ActivatorContent>
+                                    </MudFileUpload>
+                                    <MudButton Variant="Variant.Outlined"
+                                               OnClick="ParseCookies" Disabled="@(string.IsNullOrWhiteSpace(_cookieText))">Import
+                                    </MudButton>
+                                </MudStack>
+                                @if (MissingCookies.Any())
+                                {
+                                    <MudPaper Class="pa-2" Elevation="0" Outlined>
+                                        <MudAlert Severity="Severity.Warning" Square Class="mb-2 mt-3">Some required cookies are not found, add the following cookie(s) to continue.</MudAlert>
+                                        <MudChipSet T="string" ReadOnly>
+                                            @foreach (var missingCookieName in MissingCookies)
+                                            {
+                                                <MudChip Variant="Variant.Text" Color="Color.Info">@missingCookieName</MudChip>
+                                            }
+                                        </MudChipSet>
+                                    </MudPaper>
+                                }
+                                <MudTextField Class="my-2" Lines="4" AutoGrow @bind-Value="@_cookieText" Immediate
+                                              Required Label="Cookies" Variant="Variant.Outlined"/>
+                            </MudStack>
                         </MudPaper>
 
                         <MudDataGrid Items="ImportCookies" Dense Elevation="0" Outlined Style="width: 50%;">
-                            <Header>
-                                <MudStack Class="ma-2">
+                            <ToolBarContent>
                                 <MudText>Cookies</MudText>
-                                </MudStack>
-                            </Header>
+                                <MudSpacer />
+                                <MudText Typo="Typo.caption">@($"{ImportCookies.Count} cookie(s)")</MudText>
+                            </ToolBarContent>
                             <Columns>
                                 <TemplateColumn Title="Name">
                                     <CellTemplate>
-                                        <MudTextField Variant="Variant.Text" @bind-Value="@context.Item.Name"
-                                                      Immediate/>
+                                        <MudText>@context.Item.Name</MudText>
                                     </CellTemplate>
                                 </TemplateColumn>
                                 <TemplateColumn Title="Domain">
                                     <CellTemplate>
-                                        <MudTextField Variant="Variant.Text" @bind-Value="@context.Item.Domain"
-                                                      Immediate/>
+                                        <MudText>@context.Item.Domain</MudText>
+                                    </CellTemplate>
+                                </TemplateColumn>
+                                <TemplateColumn Title="Expires">
+                                    <CellTemplate>
+                                        <MudText>@context.Item.Expires</MudText>
                                     </CellTemplate>
                                 </TemplateColumn>
                                 <TemplateColumn Title="Value">
                                     <CellTemplate>
-                                        <MudTextField Variant="Variant.Text" @bind-Value="@context.Item.Value"
-                                                      Immediate/>
+                                        <MudTooltip Text="@context.Item.Value">
+                                            <MudText Style="white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 250px;">@context.Item.Value</MudText>
+                                        </MudTooltip>
                                     </CellTemplate>
                                 </TemplateColumn>
                             </Columns>
@@ -76,7 +99,7 @@
                     <MudPaper Elevation="0">
                         @if (banner != null)
                         {
-                            <MudImage Src="@banner.Url" Height="250" Style="width: 100%;"/>
+                            <MudImage Src="@Cache.CreateCacheUrl(banner.Url)" Height="250" Style="width: 100%;"/>
                         }
                         else
                         {
@@ -85,7 +108,7 @@
                         <MudStack Row Spacing="3" Class="px-4">
                             @if (avatar != null)
                             {
-                                <MudImage Src="@avatar.Url" Class="mt-n5" Height="100" Width="100"/>
+                                <MudImage Src="@Cache.CreateCacheUrl(avatar.Url)" Class="mt-n5" Height="100" Width="100"/>
                             }
                             else
                             {

Manager.App/Components/Dialogs/AccountDialog.razor.cs

@@ -1,7 +1,12 @@
 using System.Net;
+using System.Net.Mime;
+using System.Text;
 using Manager.App.Models.Library;
 using Manager.YouTube;
+using Manager.YouTube.Constants;
+using Manager.YouTube.Parsers;
 using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
 using MudBlazor;
 
 namespace Manager.App.Components.Dialogs
@@ -10,24 +15,17 @@ namespace Manager.App.Components.Dialogs
     {
         [CascadingParameter] private IMudDialogInstance? MudDialog { get; set; }
         [Parameter] public string DefaultUserAgent { get; set; } = "";
-        private bool IsAnonymous { get; set; }
-        private ClientPrep? PreparingClient { get; set; }
+        private ClientChannel? ClientChannel { get; set; }
         private CookieCollection ImportCookies { get; set; } = [];
+        private IEnumerable<string> MissingCookies => CookieConstants.RequiredCookiesNames.Where(req => !ImportCookies.Select(c => c.Name).ToHashSet().Contains(req)).ToList();
         private bool _isLoading;
         private AccountImportSteps _steps = AccountImportSteps.Authenticate;
 
-        private bool _cookieImportTextValid;
         private string _cookieText = "";
-        private string _cookieDomain = ".youtube.com";
         
         private bool CanSave()
         {
-            if (IsAnonymous || PreparingClient?.YouTubeClient?.State?.LoggedIn == true)
-            {
-                return true;
-            }
-            
-            return false;
+            return ClientChannel?.YouTubeClient?.State?.LoggedIn == true;
         }
 
         private bool CanContinue()
@@ -35,13 +33,13 @@ namespace Manager.App.Components.Dialogs
             switch (_steps)
             {
                 case AccountImportSteps.Authenticate:
-                    if (IsAnonymous || ImportCookies.Count != 0)
+                    if (ImportCookies.Count != 0)
                     {
                         return true;
                     }
                     break;
                 case AccountImportSteps.Validate:
-                    if (IsAnonymous || PreparingClient?.YouTubeClient?.State?.LoggedIn == true)
+                    if (ClientChannel?.YouTubeClient?.State?.LoggedIn == true)
                     {
                         return true;
                     }
@@ -67,7 +65,7 @@ namespace Manager.App.Components.Dialogs
                 case AccountImportSteps.Validate:
                     if (CanSave())
                     {
-                        MudDialog?.Close(DialogResult.Ok(PreparingClient));
+                        MudDialog?.Close(DialogResult.Ok(ClientChannel));
                         await InvokeAsync(StateHasChanged);
                         return;
                     }
@@ -77,12 +75,39 @@ namespace Manager.App.Components.Dialogs
             await InvokeAsync(StateHasChanged);
         }
         
-        private void ParseCookies()
+        private async Task UploadFiles(IBrowserFile? file)
         {
+            if (file == null)
+            {
+                SnackbarService.Add("File is null!", Severity.Error);
+                return;
+            }
+
+            if (file.ContentType != MediaTypeNames.Text.Plain)
+            {
+                SnackbarService.Add($"File uploaded with unsupported content type: {file.ContentType}", Severity.Warning);
+                return;
+            }
+            
+            _isLoading = true;
+            var streamReader = new StreamReader(file.OpenReadStream(), Encoding.UTF8);
+            _cookieText = await streamReader.ReadToEndAsync();
+            _isLoading = false;
+            await InvokeAsync(StateHasChanged);
+        }
+
+        private async Task ParseCookies()
+        {
+            if (string.IsNullOrEmpty(_cookieText))
+            {
+                return;
+            }
+
             try
             {
                 ImportCookies.Clear();
-                ImportCookies.Add(ParseCookieHeader(_cookieText, _cookieDomain));
+                var parsedCookies = await CookieTxtParser.ParseAsync(new MemoryStream(Encoding.UTF8.GetBytes(_cookieText)), CookieConstants.RequiredCookiesNames.ToHashSet());
+                ImportCookies.Add(parsedCookies);
                 _cookieText = string.Empty;
             }
             catch (Exception e)
@@ -94,83 +119,34 @@ namespace Manager.App.Components.Dialogs
 
         private void ClearPreparedClient()
         {
-            PreparingClient?.YouTubeClient?.Dispose();
-            PreparingClient = null;
-            IsAnonymous = false;
+            ClientChannel?.YouTubeClient?.Dispose();
+            ClientChannel = null;
             ImportCookies.Clear();
             _steps = AccountImportSteps.Authenticate;
             StateHasChanged();
         }
         
-        private static string? ValidateCookieText(string text)
-        {
-            if (string.IsNullOrWhiteSpace(text))
-                return "Cookies are required";
-
-            var pairs = text.Split(';', StringSplitOptions.RemoveEmptyEntries);
-            foreach (var pair in pairs)
-            {
-                if (!pair.Contains('=')) return "Invalid.";
-                var key = pair[..pair.IndexOf('=')].Trim();
-                if (string.IsNullOrEmpty(key)) return "Invalid.";
-            }
-
-            return null;
-        }
-
-        public static CookieCollection ParseCookieHeader(string cookieHeader, string domain = "")
-        {
-            var collection = new CookieCollection();
-
-            if (string.IsNullOrWhiteSpace(cookieHeader))
-                return collection;
-
-            var cookies = cookieHeader.Split(';', StringSplitOptions.RemoveEmptyEntries);
-
-            foreach (var cookieStr in cookies)
-            {
-                var parts = cookieStr.Split('=', 2);
-                if (parts.Length != 2) continue;
-                
-                var name = parts[0].Trim();
-                var value = parts[1].Trim();
-
-                var cookie = new Cookie(name, value)
-                {
-                    Path = "/",
-                    Domain = domain
-                };
-                collection.Add(cookie);
-            }
-
-            return collection;
-        }
-        
         private async Task BuildClient()
         {
             _isLoading = true;
-            PreparingClient = new ClientPrep();
-            if (IsAnonymous)
-            {
-                ImportCookies.Clear();
-            }
+            ClientChannel = new ClientChannel();
             var clientResult = await YouTubeClient.CreateAsync(ImportCookies, DefaultUserAgent);
             if (clientResult.IsSuccess)
             {
-                PreparingClient.YouTubeClient = clientResult.Value;
+                ClientChannel.YouTubeClient = clientResult.Value;
             }
 
-            if (PreparingClient.YouTubeClient == null)
+            if (ClientChannel.YouTubeClient == null)
             {
                 SnackbarService.Add("Failed to get client!", Severity.Error);
                 _isLoading = false;
                 return;
             }
 
-            var accountResult = await PreparingClient.YouTubeClient.GetChannelByIdAsync(PreparingClient.YouTubeClient.Id);
+            var accountResult = await ClientChannel.YouTubeClient.GetChannelByIdAsync(ClientChannel.YouTubeClient.Id);
             if (accountResult.IsSuccess)
             {
-                PreparingClient.Channel = accountResult.Value;
+                ClientChannel.Channel = accountResult.Value;
             }
             _isLoading = false;
             await InvokeAsync(StateHasChanged);

Manager.App/Components/Layout/NavMenu.razor

@@ -1,9 +1,15 @@
 
 <MudNavMenu>
     <MudNavLink Href="/" Icon="@Icons.Material.Filled.Home" Match="NavLinkMatch.All">Home</MudNavLink>
-    <MudNavLink Href="/Channels" Icon="@Icons.Material.Filled.SupervisorAccount" Match="NavLinkMatch.All">Channels</MudNavLink>
-    <MudNavLink Href="/Library" Icon="@Icons.Material.Filled.LocalLibrary" Match="NavLinkMatch.All">Library</MudNavLink>
-    <MudNavLink Href="/Playlists" Icon="@Icons.Material.Filled.ViewList" Match="NavLinkMatch.All">Playlists</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" 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">
         <MudNavLink Href="/Development" Icon="@Icons.Material.Filled.DeveloperMode" Match="NavLinkMatch.All">Development</MudNavLink>
         <MudNavLink Href="/Services" Icon="@Icons.Material.Filled.MiscellaneousServices" Match="NavLinkMatch.All">Services</MudNavLink>
+    </MudNavGroup>
 </MudNavMenu>

Manager.App/Components/Pages/Accounts.razor

@@ -0,0 +1,53 @@
+@page "/Accounts"
+@using Manager.App.Controllers
+@using Manager.App.Models.Settings
+@using Manager.App.Services.System
+@using Microsoft.Extensions.Options
+
+@inject ILibraryService LibraryService
+@inject IDialogService DialogService
+@inject IOptions<LibrarySettings> LibraryOptions
+@inject ClientService ClientService
+@inject ISnackbar Snackbar
+
+<PageTitle>Accounts</PageTitle>
+
+<MudStack Spacing="2">
+    <MudPaper Elevation="0" Outlined>
+        <MudStack Row Class="ma-2">
+            <MudButton IconSize="Size.Small" StartIcon="@Icons.Material.Filled.Add" Variant="Variant.Outlined" OnClick="OnAddAccountDialogAsync">Add account</MudButton>
+        </MudStack>
+    </MudPaper>
+    
+    <MudTable @ref="@_table" ServerData="ServerReload">
+        <ToolBarContent>
+            <MudText Typo="Typo.h6">Accounts</MudText>
+            <MudSpacer />
+            <MudTextField T="string" ValueChanged="@(s=>OnSearch(s))" Placeholder="Search" Adornment="Adornment.Start" DebounceInterval="300"
+                          AdornmentIcon="@Icons.Material.Filled.Search" IconSize="Size.Medium" Class="mt-0"></MudTextField>
+        </ToolBarContent>
+        <HeaderContent>
+            <MudTh></MudTh>
+            <MudTh>Name</MudTh>
+            <MudTh>Handle</MudTh>
+            <MudTh>ID</MudTh>
+            <MudTh>Cookies</MudTh>
+        </HeaderContent>
+        <RowTemplate>
+            <MudTd><MudImage Src="@(FileController.CreateProvideUrl(context.AvatarFileId))" Height="40"/></MudTd>
+            <MudTd>@context.Name</MudTd>
+            <MudTd>@context.Handle</MudTd>
+            <MudTd>@context.Id</MudTd>
+            <MudTd>@context.HasCookies</MudTd>
+        </RowTemplate>
+        <NoRecordsContent>
+            <MudText>No channels found</MudText>
+        </NoRecordsContent>
+        <LoadingContent>
+            <MudText>Loading...</MudText>
+        </LoadingContent>
+        <PagerContent>
+            <MudTablePager/>
+        </PagerContent>
+    </MudTable>
+</MudStack>

Manager.App/Components/Pages/Accounts.razor.cs

@@ -0,0 +1,72 @@
+using Manager.App.Components.Dialogs;
+using Manager.App.Models.Library;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+
+namespace Manager.App.Components.Pages;
+
+public partial class Accounts : ComponentBase
+{
+    private MudTable<AccountListView>? _table;
+    private readonly DialogOptions _dialogOptions = new() { BackdropClick = false, CloseButton = true, FullWidth = true, MaxWidth = MaxWidth.ExtraLarge };
+    private string _search = "";
+    
+    private async Task<TableData<AccountListView>> ServerReload(TableState state, CancellationToken token)
+    {
+        var results = await LibraryService.GetAccountsAsync(_search, state.Page * state.PageSize, state.PageSize, token);
+        return !results.IsSuccess ? new TableData<AccountListView>() : new TableData<AccountListView> { Items = results.Value, TotalItems = results.Total };
+    }
+    
+    private void OnSearch(string text)
+    {
+        _search = text;
+        _table?.ReloadServerData();
+    }
+
+    private async Task OnAddAccountDialogAsync()
+    {
+        var libSettings = LibraryOptions.Value;
+        var parameters = new DialogParameters<AccountDialog> { { x => x.DefaultUserAgent, libSettings.DefaultUserAgent } };
+        var dialog = await DialogService.ShowAsync<AccountDialog>("Add account", parameters, _dialogOptions);
+        var result = await dialog.Result;
+
+        if (result == null || result.Canceled || result.Data == null)
+        {
+            return;
+        }
+        
+        var clientChannel = (ClientChannel)result.Data;
+        if (clientChannel?.YouTubeClient == null)
+        {
+            Snackbar.Add("No YouTube client received.", Severity.Error);
+            return;
+        }
+
+        var savedClientResult = await ClientService.SaveClientAsync(clientChannel.YouTubeClient);
+        if (savedClientResult.IsSuccess)
+        {
+            if (_table != null)
+            {
+                await _table.ReloadServerData();
+            }
+            Snackbar.Add($"Client {clientChannel.Channel?.Handle ?? clientChannel.YouTubeClient.Id} saved!", Severity.Success);
+        }
+        else
+        {
+            Snackbar.Add($"Failed to store client: {savedClientResult.Error?.Description ?? "Unknown!"}", Severity.Error);
+        }
+
+        if (clientChannel.Channel == null)
+        {
+            Snackbar.Add("No channel information received!", Severity.Warning);
+        }
+        else
+        {
+            var saveChannelResult = await LibraryService.SaveChannelAsync(clientChannel.Channel);
+            if (!saveChannelResult.IsSuccess)
+            {
+                Snackbar.Add("Failed to save channel information", Severity.Warning);
+            }
+        }
+    }
+}

Manager.App/Components/Pages/Channels.razor

@@ -1,37 +1,29 @@
 @page "/Channels"
-@using Manager.App.Models.Settings
-@using Manager.App.Services.System
-@using Microsoft.Extensions.Options
+@using Manager.App.Controllers
 
 @inject ILibraryService LibraryService
-@inject IDialogService DialogService
-@inject IOptions<LibrarySettings> LibraryOptions
-@inject ClientService ClientService
-@inject ISnackbar Snackbar
 
 <PageTitle>Channels</PageTitle>
 
-
 <MudStack Spacing="2">
-    <MudPaper Elevation="0" Outlined>
-        <MudStack Row Class="ma-2">
-            <MudButton IconSize="Size.Small" StartIcon="@Icons.Material.Filled.Add" Variant="Variant.Outlined" OnClick="OnAddAccountDialogAsync">Add account</MudButton>
-        </MudStack>
-    </MudPaper>
-    
     <MudTable @ref="@_table" ServerData="ServerReload">
         <ToolBarContent>
             <MudText Typo="Typo.h6">Channels</MudText>
+            <MudSpacer />
+            <MudTextField T="string" ValueChanged="@(s=>OnSearch(s))" Placeholder="Search" Adornment="Adornment.Start" DebounceInterval="300"
+                          AdornmentIcon="@Icons.Material.Filled.Search" IconSize="Size.Medium" Class="mt-0"></MudTextField>
         </ToolBarContent>
         <HeaderContent>
+            <MudTh></MudTh>
             <MudTh>Name</MudTh>
+            <MudTh>Handle</MudTh>
             <MudTh>Channel id</MudTh>
-            <MudTh>Has login</MudTh>
         </HeaderContent>
         <RowTemplate>
+            <MudTd><MudImage Src="@(FileController.CreateProvideUrl(context.AvatarFileId))" Height="40"/></MudTd>
             <MudTd>@context.Name</MudTd>
+            <MudTd>@context.Handle</MudTd>
             <MudTd>@context.Id</MudTd>
-            <MudTd>@(context.ClientAccount != null)</MudTd>
         </RowTemplate>
         <NoRecordsContent>
             <MudText>No channels found</MudText>

Manager.App/Components/Pages/Channels.razor.cs

@@ -1,6 +1,4 @@
-using Manager.App.Components.Dialogs;
 using Manager.App.Models.Library;
-using Manager.Data.Entities.LibraryContext;
 using Microsoft.AspNetCore.Components;
 using MudBlazor;
 
@@ -8,46 +6,18 @@ namespace Manager.App.Components.Pages;
 
 public partial class Channels : ComponentBase
 {
-    private readonly DialogOptions _dialogOptions = new() { BackdropClick = false, CloseButton = true, FullWidth = true, MaxWidth = MaxWidth.ExtraLarge };
-    private MudTable<ChannelEntity>? _table;
+    private MudTable<ChannelListView>? _table;
+    private string _search = "";
     
-    private async Task<TableData<ChannelEntity>> ServerReload(TableState state, CancellationToken token)
+    private async Task<TableData<ChannelListView>> ServerReload(TableState state, CancellationToken token)
     {
-        var results = await LibraryService.GetChannelAccountsAsync(state.PageSize, state.Page * state.PageSize, token);
-        return !results.IsSuccess ? new TableData<ChannelEntity>() : new TableData<ChannelEntity> { Items = results.Value, TotalItems = results.Total };
+        var results = await LibraryService.GetChannelsAsync(_search, state.Page * state.PageSize, state.PageSize, token);
+        return !results.IsSuccess ? new TableData<ChannelListView>() : new TableData<ChannelListView> { Items = results.Value, TotalItems = results.Total };
     }
     
-    private async Task OnAddAccountDialogAsync()
+    private void OnSearch(string text)
     {
-        var libSettings = LibraryOptions.Value;
-        var parameters = new DialogParameters<AccountDialog> { { x => x.DefaultUserAgent, libSettings.DefaultUserAgent } };
-        var dialog = await DialogService.ShowAsync<AccountDialog>("Add account", parameters, _dialogOptions);
-        var result = await dialog.Result;
-
-        if (result == null || result.Canceled || result.Data == null)
-        {
-            return;
-        }
-        
-        var clientPrep = (ClientPrep)result.Data;
-        if (clientPrep?.YouTubeClient == null)
-        {
-            return;
-        }
-        
-        var savedResult = await ClientService.SaveClientAsync(clientPrep.YouTubeClient, clientPrep.Channel);
-        if (!savedResult.IsSuccess)
-        {
-            Snackbar.Add($"Failed to store client: {savedResult.Error?.Description ?? "Unknown!"}", Severity.Error);
-        }
-        else
-        {
-            Snackbar.Add($"Client {clientPrep.Channel?.Handle ?? clientPrep.YouTubeClient.Id} saved!", Severity.Success);
-        }
-
-        if (_table != null)
-        {
-            await _table.ReloadServerData();
-        }
+        _search = text;
+        _table?.ReloadServerData();
     }
 }

Manager.App/Components/Pages/Development.razor

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

Manager.App/Components/Pages/Library.razor

@@ -26,6 +26,18 @@
             <td>Library size:</td>
             <td>@($"{Suffix.BytesToSizeSuffix(_libraryInformation.TotalSizeBytes)} ({_libraryInformation.TotalSizeBytes} bytes)")</td>
         </tr>
+        <tr>
+            <td>Drive total size:</td>
+            <td>@($"{Suffix.BytesToSizeSuffix(_libraryInformation.DriveTotalSpaceBytes)} ({_libraryInformation.DriveTotalSpaceBytes} bytes)")</td>
+        </tr>
+        <tr>
+            <td>Drive used space:</td>
+            <td>@($"{Suffix.BytesToSizeSuffix(_libraryInformation.DriveUsedSpaceBytes)} ({_libraryInformation.DriveUsedSpaceBytes} bytes)")</td>
+        </tr>
+        <tr>
+            <td>Drive free space available:</td>
+            <td>@($"{Suffix.BytesToSizeSuffix(_libraryInformation.DriveFreeSpaceBytes)} ({_libraryInformation.DriveFreeSpaceBytes} bytes)")</td>
+        </tr>
         
         <tr>
             <td>Total media:</td>

Manager.App/Components/Pages/Services.razor

@@ -7,7 +7,7 @@
 
 <PageTitle>Services</PageTitle>
 
-<MudDataGrid T="ExtendedBackgroundService" Items="@_backgroundServices" Filterable QuickFilter="@QuickFilter">
+<MudDataGrid T="ExtendedBackgroundService" Items="@_backgroundServices" Filterable QuickFilter="@QuickFilter" Dense>
     <ToolBarContent>
         <MudText Typo="Typo.h6">Services</MudText>
         <MudSpacer/>
@@ -20,16 +20,19 @@
         <PropertyColumn Property="x => x.Description" Title="Description"/>
         <PropertyColumn Property="x => x.State" Title="Status"/>
         <PropertyColumn Property="x => x.ExecuteInterval" Title="Execute interval"/>
-        <TemplateColumn>
+        <TemplateColumn Title="Actions">
             <CellTemplate>
-                <MudStack Row Spacing="2">
-                    <MudButton Disabled="@(context.Item?.State == ServiceState.Paused)"
-                               OnClick="@(() => { context.Item?.Pause(); })" Variant="Variant.Outlined">Pause
-                    </MudButton>
-                    <MudButton Disabled="@(context.Item?.State == ServiceState.Running)"
-                               OnClick="@(() => { context.Item?.Resume(); })" Variant="Variant.Outlined">Resume
-                    </MudButton>
-                </MudStack>
+                <MudMenu Icon="@Icons.Material.Filled.MoreVert"
+                         AriaLabel="Actions">
+                    @foreach (var action in context.Item?.Actions ?? [])
+                    {
+                        <MudMenuItem OnClick="@action.Action" Disabled="@(!action.IsEnabled())">
+                            <MudTooltip Text="@action.Description">
+                                <span>@action.Id</span>
+                            </MudTooltip>
+                        </MudMenuItem>
+                    }
+                </MudMenu>
             </CellTemplate>
         </TemplateColumn>
     </Columns>

Manager.App/Components/Pages/Services.razor.cs

@@ -27,7 +27,9 @@ public partial class Services : ComponentBase
     private List<ServiceEvent> GetInitialEvents()
     {
         var totalToGet = 1000 / _backgroundServices.Count;
-        var initial = _backgroundServices.SelectMany(x => x.ProgressEvents.Items.TakeLast(totalToGet));
+        var initial = _backgroundServices
+            .SelectMany(x => x.ProgressEvents.Items.TakeLast(totalToGet))
+            .OrderBy(x => x.DateUtc);
         return initial.ToList();
     }
 

Manager.App/Components/Pages/Video.razor

@@ -0,0 +1,244 @@
+@page "/Video/{VideoId}"
+@using Manager.App.Services.System
+
+@inject ISnackbar Snackbar
+@inject ClientService ClientService
+@inject CacheService Cache
+
+<ForcedLoadingOverlay Visible="_loading"/>
+@if (!_loading && _video != null)
+{
+    <MudStack Spacing="2">
+        <MudCard>
+            @{
+                var thumbnailUrl = _video.Thumbnails.OrderByDescending(t => t.Width).FirstOrDefault()?.Url;
+            }
+            @if (!string.IsNullOrWhiteSpace(thumbnailUrl))
+            {
+                <MudCardMedia Image="@Cache.CreateCacheUrl(thumbnailUrl)" Height="500"/>
+            }
+            <MudCardContent>
+                <MudText Typo="Typo.h5">@_video.Title</MudText>
+                <MudText Typo="Typo.body2">@_video.Description</MudText>
+            </MudCardContent>
+        </MudCard>
+        <MudExpansionPanels MultiExpansion>
+            <MudExpansionPanel Text="Info" Expanded>
+                <MudStack Spacing="2" Row Wrap="Wrap.Wrap">
+                    @* Info *@
+                    <MudSimpleTable Bordered Dense Elevation="0" Outlined Square Hover>
+                        <tbody>
+                        <tr>
+                            <td>Video ID:</td>
+                            <td>@_video.VideoId</td>
+                        </tr>
+                        <tr>
+                            <td>Title:</td>
+                            <td>@_video.Title</td>
+                        </tr>
+                        <tr>
+                            <td>Description:</td>
+                            <td>@_video.Description</td>
+                        </tr>
+                        <tr>
+                            <td>HashTags:</td>
+                            <td>@foreach (var hashtag in _video.HashTags)
+                                {
+                                    <MudChip T="string" Variant="Variant.Text" Color="Color.Info">@hashtag</MudChip>
+                                }
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>View count:</td>
+                            <td>@_video.ViewCount</td>
+                        </tr>
+                        <tr>
+                            <td>Like count:</td>
+                            <td>@_video.LikeCount</td>
+                        </tr>
+                        <tr>
+                            <td>Channel ID:</td>
+                            <td>@_video.ChannelId</td>
+                        </tr>
+                        <tr>
+                            <td>Author:</td>
+                            <td>@_video.Author</td>
+                        </tr>
+                        <tr>
+                            <td>Playability status:</td>
+                            <td>@_video.PlayabilityStatus</td>
+                        </tr>
+                        <tr>
+                            <td>Length seconds:</td>
+                            <td>@_video.LengthSeconds</td>
+                        </tr>
+                        <tr>
+                            <td>Keywords:</td>
+                            <td>@foreach (var keyword in _video.Keywords)
+                                {
+                                    <MudChip T="string" Variant="Variant.Text">@keyword</MudChip>
+                                }
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>Publish date:</td>
+                            <td>@_video.PublishDate</td>
+                        </tr>
+                        <tr>
+                            <td>Upload date:</td>
+                            <td>@_video.UploadDate</td>
+                        </tr>
+                        <tr>
+                            <td>Category:</td>
+                            <td>@_video.Category</td>
+                        </tr>
+                        </tbody>
+                    </MudSimpleTable>
+                    @* Boolean values *@
+                    <MudSimpleTable Bordered Dense Elevation="0" Outlined Square Hover>
+                        <tbody>
+                        <tr>
+                            <td>Is owner viewing:</td>
+                            <td>@_video.IsOwnerViewing</td>
+                        </tr>
+                        <tr>
+                            <td>Allow rating:</td>
+                            <td>@_video.AllowRating</td>
+                        </tr>
+                        <tr>
+                            <td>Is crawlable:</td>
+                            <td>@_video.IsCrawlable</td>
+                        </tr>
+                        <tr>
+                            <td>Is private:</td>
+                            <td>@_video.IsPrivate</td>
+                        </tr>
+                        <tr>
+                            <td>Is unplugged corpus:</td>
+                            <td>@_video.IsUnpluggedCorpus</td>
+                        </tr>
+                        <tr>
+                            <td>Is live:</td>
+                            <td>@_video.IsLive</td>
+                        </tr>
+                        <tr>
+                            <td>Is family save:</td>
+                            <td>@_video.IsFamilySave</td>
+                        </tr>
+                        <tr>
+                            <td>Is unlisted:</td>
+                            <td>@_video.IsUnlisted</td>
+                        </tr>
+                        <tr>
+                            <td>Has Ypc metadata:</td>
+                            <td>@_video.HasYpcMetadata</td>
+                        </tr>
+                        <tr>
+                            <td>Is shorts eligible:</td>
+                            <td>@_video.IsShortsEligible</td>
+                        </tr>
+                        </tbody>
+                    </MudSimpleTable>
+                </MudStack>
+            </MudExpansionPanel>
+            <MudExpansionPanel Text="Streaming data">
+                @if (_video.StreamingData == null)
+                {
+                    <MudAlert Severity="Severity.Info">No streaming data available!</MudAlert>
+                }
+                else
+                {
+                    <MudStack Spacing="2" Row Wrap="Wrap.Wrap">
+                        <MudStack>
+                            <MudText Typo="Typo.h5">Adaptive Formats</MudText>
+                            <MudTable Items="@_video.StreamingData.AdaptiveFormats">
+                                <HeaderContent>
+                                    <MudTh>Id</MudTh>
+                                    <MudTh>Mime type</MudTh>
+                                    <MudTh>Bitrate</MudTh>
+                                    <MudTh>Resolution</MudTh>
+                                    <MudTh>Last modified (UNIX epoch)</MudTh>
+                                    <MudTh>Quality</MudTh>
+                                    <MudTh>FPS</MudTh>
+                                </HeaderContent>
+                                <RowTemplate>
+                                    <MudTd>@context.Itag</MudTd>
+                                    <MudTd>@context.MimeType</MudTd>
+                                    <MudTd>@context.Bitrate</MudTd>
+                                    <MudTd>@($"{context.Width}x{context.Height}")</MudTd>
+                                    <MudTd>@context.LastModified</MudTd>
+                                    <MudTd>@context.Quality</MudTd>
+                                    <MudTd>@context.Fps</MudTd>
+                                </RowTemplate>
+                            </MudTable>
+                        </MudStack>
+                        <MudStack>
+                            <MudText Typo="Typo.h5">Formats</MudText>
+                            <MudTable Items="@_video.StreamingData.Formats">
+                                <HeaderContent>
+                                    <MudTh>Id</MudTh>
+                                    <MudTh>Mime type</MudTh>
+                                    <MudTh>Bitrate</MudTh>
+                                    <MudTh>Resolution</MudTh>
+                                    <MudTh>Last modified (UNIX epoch)</MudTh>
+                                    <MudTh>Quality</MudTh>
+                                    <MudTh>FPS</MudTh>
+                                </HeaderContent>
+                                <RowTemplate>
+                                    <MudTd>@context.Itag</MudTd>
+                                    <MudTd>@context.MimeType</MudTd>
+                                    <MudTd>@context.Bitrate</MudTd>
+                                    <MudTd>@($"{context.Width}x{context.Height}")</MudTd>
+                                    <MudTd>@context.LastModified</MudTd>
+                                    <MudTd>@context.Quality</MudTd>
+                                    <MudTd>@context.Fps</MudTd>
+                                </RowTemplate>
+                            </MudTable>
+                        </MudStack>
+                    </MudStack>
+                }
+            </MudExpansionPanel>
+            <MudExpansionPanel Text="Player config">
+                @if (_video.PlayerConfig == null)
+                {
+                    <MudAlert Severity="Severity.Info">No player config available!</MudAlert>
+                }
+                else
+                {
+                    <MudSimpleTable Bordered Dense Elevation="0" Outlined Square Hover>
+                        <tbody>
+                        <tr>
+                            <td>Audio loudness DB:</td>
+                            <td>@_video.PlayerConfig.AudioLoudnessDb</td>
+                        </tr>
+                        <tr>
+                            <td>Audio perceptual loudness DB:</td>
+                            <td>@_video.PlayerConfig.AudioPerceptualLoudnessDb</td>
+                        </tr>
+                        <tr>
+                            <td>Audio enable per format loudness:</td>
+                            <td>@_video.PlayerConfig.AudioLoudnessDb</td>
+                        </tr>
+                        <tr>
+                            <td>Max bitrate:</td>
+                            <td>@_video.PlayerConfig.MaxBitrate</td>
+                        </tr>
+                        <tr>
+                            <td>Max read ahead time MS:</td>
+                            <td>@_video.PlayerConfig.MaxReadAheadMediaTimeMs</td>
+                        </tr>
+                        <tr>
+                            <td>Min read ahead time MS:</td>
+                            <td>@_video.PlayerConfig.MinReadAheadMediaTimeMs</td>
+                        </tr>
+                        <tr>
+                            <td>Read ahead growth rate MS:</td>
+                            <td>@_video.PlayerConfig.ReadAheadGrowthRateMs</td>
+                        </tr>
+                        </tbody>
+                    </MudSimpleTable>
+                }
+            </MudExpansionPanel>
+        </MudExpansionPanels>
+    </MudStack>
+}

Manager.App/Components/Pages/Video.razor.cs

@@ -0,0 +1,48 @@
+using Manager.YouTube.Models;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+
+namespace Manager.App.Components.Pages;
+
+public partial class Video : ComponentBase
+{
+    [Parameter]
+    public required string VideoId { get; set; }
+
+    [SupplyParameterFromQuery(Name = "clientId")]
+    public string ClientId { get; set; } = "";
+
+    private bool _loading = true;
+    private YouTubeVideo? _video;
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (string.IsNullOrEmpty(VideoId))
+        {
+            Snackbar.Add("Video id is null or empty!", Severity.Error);
+            _loading = false;
+            return;
+        }
+
+        var clientResult = await ClientService.LoadClientByIdAsync(ClientId);
+        if (!clientResult.IsSuccess)
+        {
+            Snackbar.Add(clientResult.Error?.Description ?? "Failed to load client!", Severity.Error);
+            _loading = false;
+            return;
+        }
+
+        var client = clientResult.Value;
+        
+        var videoResult = await client.GetVideoByIdAsync(VideoId);
+        if (!videoResult.IsSuccess)
+        {
+            Snackbar.Add(videoResult.Error?.Description ?? "Failed to get video.", Severity.Error);
+            _loading = false;
+            return;
+        }
+
+        _video = videoResult.Value;
+        _loading = false;
+    }
+}

Manager.App/Controllers/CacheController.cs

@@ -0,0 +1,27 @@
+using Manager.App.Services.System;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Manager.App.Controllers;
+
+[ApiController]
+[Route("api/v1/[controller]")]
+public class CacheController(ILogger<CacheController> logger, CacheService cacheService) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> Cache([FromQuery(Name = "url")] string url, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return BadRequest("No url given.");
+        }
+
+        var cacheResult = await cacheService.CacheFromUrl(url, cancellationToken);
+        if (!cacheResult.IsSuccess)
+        {
+            logger.LogError("Cache request failed. {ErrorMessage}", cacheResult.Error?.Description);
+            return StatusCode(500, cacheResult.Error?.Description);
+        }
+
+        return File(cacheResult.Value.Data, cacheResult.Value.ContentType ?? string.Empty, cacheResult.Value.OriginalFileName);
+    }
+}

Manager.App/Controllers/FileController.cs

@@ -0,0 +1,24 @@
+using Manager.App.Services;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Manager.App.Controllers;
+
+[ApiController]
+[Route("api/v1/[controller]")]
+public class FileController(ILibraryService libraryService) : ControllerBase
+{
+    public static string CreateProvideUrl(Guid? id) => id == null ? "" : $"/api/v1/file/provide?id={id}";
+
+    [HttpGet("provide")]
+    public async Task<IActionResult> ProvideFile([FromQuery(Name = "id")] Guid id, CancellationToken cancellationToken)
+    {
+        var fileResult = await libraryService.GetFileByIdAsync(id, cancellationToken);
+        if (!fileResult.IsSuccess)
+        {
+            return BadRequest(fileResult.Error);
+        }
+
+        var libFile = fileResult.Value;
+        return File(libFile.DataStream, libFile.MimeType, libFile.FileName);
+    }
+}

Manager.App/Manager.App.csproj

@@ -32,6 +32,7 @@
     </ItemGroup>
 
     <ItemGroup>
+      <Folder Include="cache\" />
       <Folder Include="Library\" />
       <Folder Include="Logs\Debug\" />
     </ItemGroup>

Manager.App/Models/Library/ClientPrep.cs

@@ -1,10 +0,0 @@
-using Manager.YouTube;
-using Manager.YouTube.Models.Innertube;
-
-namespace Manager.App.Models.Library;
-
-public class ClientPrep
-{
-    public YouTubeClient? YouTubeClient { get; set; }
-    public Channel? Channel { get; set; }
-}

Manager.App/Models/Library/LibraryInformation.cs

@@ -8,4 +8,7 @@ public record LibraryInformation
     public long TotalMedia { get; set; }
     public long TotalChannels { get; set; }
     public long TotalSizeBytes { get; set; }
+    public long DriveTotalSpaceBytes { get; set; }
+    public long DriveFreeSpaceBytes { get; set; }
+    public long DriveUsedSpaceBytes { get; set; }
 }

Manager.App/Models/System/YouTubeClientItem.cs

@@ -0,0 +1,16 @@
+using Manager.App.Models.Library;
+
+namespace Manager.App.Models.System;
+
+public class YouTubeClientItem : AccountListView
+{
+    public YouTubeClientItem(AccountListView accountListView)
+    {
+        Id = accountListView.Id;
+        Name = accountListView.Name;
+        Handle = accountListView.Handle;
+        HasCookies = accountListView.HasCookies;
+        AvatarFileId = accountListView.AvatarFileId;
+    }
+    public bool IsLoaded { get; set; }
+}

Manager.App/Program.cs

@@ -10,6 +10,8 @@ builder.Services.AddRazorComponents()
 
 AppContext.SetSwitch("System.Net.Http.EnableActivityPropagation", false);
 
+builder.Services.AddControllers();
+
 /* Manager */
 builder.SetupLogging();
 builder.SetupSettings();
@@ -32,6 +34,7 @@ app.UseHttpsRedirection();
 
 app.UseStaticFiles();
 app.UseAntiforgery();
+app.MapControllers();
 
 app.MapRazorComponents<App>()
     .AddInteractiveServerRenderMode();

Manager.App/Services/ExtendedBackgroundService.cs

@@ -7,21 +7,43 @@ public abstract class ExtendedBackgroundService(string name, string description,
     : BackgroundService
 {
     private TaskCompletionSource _resumeSignal = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private readonly List<ServiceAction> _actions = [];
+    private TaskCompletionSource? _manualContinue;
+    
     public ServiceState State { get; private set; } = ServiceState.Stopped;
     public CircularBuffer<ServiceEvent> ProgressEvents { get; } = new(500);
     public string Name { get; } = name;
-    public string Description { get; set; } = description;
-    public TimeSpan ExecuteInterval { get; set; } = executeInterval ?? TimeSpan.FromMinutes(1);
+    public string Description { get; } = description;
+    public TimeSpan ExecuteInterval { get; } = executeInterval ?? TimeSpan.FromSeconds(5);
+
+    public IReadOnlyList<ServiceAction> Actions => _actions;
+
+    protected void AddActions(IEnumerable<ServiceAction> actions)
+    {
+        _actions.AddRange(actions);
+    }
 
     protected sealed override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         State = ServiceState.Running;
         logger.LogInformation("Initializing background service: {ServiceName}", Name);
+        
+        _actions.AddRange(
+        [
+            new ServiceAction("Start", "Start the service (after the service is stopped of faulted.)", Start, () => State is ServiceState.Stopped or ServiceState.Faulted),
+            new ServiceAction("Pause", "Pause the service", Pause, () => State != ServiceState.Paused),
+            new ServiceAction("Resume", "Resume the service", Resume, () => State != ServiceState.Running)
+        ]);
+        
         await InitializeAsync(stoppingToken);
         
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            if (State == ServiceState.Running)
+            {
                 try
                 {
-            logger.LogInformation("Running background service: {ServiceName}", Name);
+                    logger.LogInformation("Started running background service: {ServiceName}", Name);
                     while (!stoppingToken.IsCancellationRequested)
                     {
                         if (State == ServiceState.Paused)
@@ -30,19 +52,20 @@ public abstract class ExtendedBackgroundService(string name, string description,
                             await _resumeSignal.Task.WaitAsync(stoppingToken);
                         }
 
-                await Task.Delay(ExecuteInterval, stoppingToken);
                         await ExecuteServiceAsync(stoppingToken);
+
+                        await Task.Delay(ExecuteInterval, stoppingToken);
                     }
                 }
+                catch (OperationCanceledException e)
+                {
+                    logger.LogInformation(e, "Service {ServiceName} received cancellation", Name);
+                }
                 catch (Exception e)
-        {
-            if (e is not OperationCanceledException)
                 {
                     State = ServiceState.Faulted;
-                logger.LogError(e,"Background service {ServiceName} faulted!", Name);
-                throw;
-            }
-            logger.LogInformation(e,"Service {ServiceName} received cancellation", Name);
+                    logger.LogError(e, "Background service {ServiceName} faulted!", Name);
+                    LogEvent("Error executing background service.", LogSeverity.Error);
                 }
                 finally
                 {
@@ -50,14 +73,31 @@ public abstract class ExtendedBackgroundService(string name, string description,
                 }
             }
             
+            _manualContinue = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            var delayTask = Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
+            await Task.WhenAny(delayTask, _manualContinue.Task);
+            _manualContinue = null;
+        }
+    }
+
     protected void LogEvent(string message, LogSeverity severity = LogSeverity.Info) => ProgressEvents.Add(new ServiceEvent(string.Intern(Name), message, DateTime.UtcNow, severity));
 
+    public void Start()
+    {
+        if (State is ServiceState.Stopped or ServiceState.Faulted)
+        {
+            State = ServiceState.Running;
+            _manualContinue?.TrySetResult();
+            LogEvent("Started service.");
+        }
+    }
+
     public void Pause()
     {
         if (State == ServiceState.Running)
         {
             State = ServiceState.Paused;
-            logger.LogInformation("Pauses service: {ServiceName}", Name);
+            LogEvent("Service paused.");
         }
     }
 
@@ -67,7 +107,7 @@ public abstract class ExtendedBackgroundService(string name, string description,
         {
             State = ServiceState.Running;
             _resumeSignal.TrySetResult();
-            logger.LogInformation("Resumed service: {ServiceName}", Name);
+            LogEvent("Service resumed.");
         }
     }
 
@@ -94,3 +134,5 @@ public enum ServiceState
 }
 
 public record struct ServiceEvent(string Source, string Message, DateTime DateUtc, LogSeverity Severity);
+
+public record ServiceAction(string Id, string Description, Action Action, Func<bool> IsEnabled);

Manager.App/Services/ILibraryService.cs

@@ -8,10 +8,11 @@ namespace Manager.App.Services;
 
 public interface ILibraryService
 {
-    public Task<Result> FetchChannelImagesAsync(Channel channel);
+    public Task<Result> SaveClientAsync(ClientAccountEntity client, CancellationToken cancellationToken = default);
+    public Task<Result<LibraryFile>> GetFileByIdAsync(Guid id, CancellationToken cancellationToken = default);
     public Task<Result<ChannelEntity>> GetChannelByIdAsync(string id, CancellationToken cancellationToken = default);
-    public Task<Result> SaveChannelAsync(ChannelEntity channel, CancellationToken cancellationToken = default);
+    public Task<Result> SaveChannelAsync(InnertubeChannel innertubeChannel, CancellationToken cancellationToken = default);
     public Task<Result<LibraryInformation>> GetLibraryInfoAsync(CancellationToken cancellationToken = default);
-
-    public Task<ListResult<ChannelEntity>> GetChannelAccountsAsync(int total = 20, int offset = 0, CancellationToken cancellationToken = default);
+    public Task<ListResult<AccountListView>> GetAccountsAsync(string? search, int offset = 0, int total = 20, CancellationToken cancellationToken = default);
+    public Task<ListResult<ChannelListView>> GetChannelsAsync(string? search, int offset = 0, int total = 20, CancellationToken cancellationToken = default);
 }

Manager.App/Services/LibraryService.cs

@@ -1,11 +1,12 @@
+using System.Net.Mime;
 using DotBased.Monads;
 using Manager.App.Constants;
 using Manager.App.Models.Library;
 using Manager.App.Models.Settings;
 using Manager.App.Models.System;
+using Manager.App.Services.System;
 using Manager.Data.Contexts;
 using Manager.Data.Entities.LibraryContext;
-using Manager.YouTube;
 using Manager.YouTube.Models.Innertube;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
@@ -15,82 +16,58 @@ 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;
     
-
-    public LibraryService(ILogger<LibraryService> logger, IOptions<LibrarySettings> librarySettings, IDbContextFactory<LibraryDbContext> contextFactory)
+    public LibraryService(ILogger<LibraryService> logger, IOptions<LibrarySettings> librarySettings, IDbContextFactory<LibraryDbContext> contextFactory, CacheService cacheService)
     {
         _logger = logger;
-        _librarySettings = librarySettings.Value;
+        var librarySettings1 = librarySettings.Value;
         _dbContextFactory = contextFactory;
-        _libraryDirectory = Directory.CreateDirectory(_librarySettings.Path);
-        logger.LogDebug("Working dir for library: {LibraryWorkingDir}", _libraryDirectory.FullName);
-        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirMedia));
-        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirChannels));
-    }
-    
-    public async Task<Result> FetchChannelImagesAsync(Channel channel)
-    {
-        try
-        {
-            await using var context = await _dbContextFactory.CreateDbContextAsync();
-            
-            await AddWebImagesAsync(context, channel.AvatarImages, channel.Id, "avatars", LibraryConstants.FileTypes.ChannelAvatar, LibraryConstants.Directories.SubDirChannels);
-            await AddWebImagesAsync(context, channel.BannerImages, channel.Id, "banners", LibraryConstants.FileTypes.ChannelBanner, LibraryConstants.Directories.SubDirChannels);
-
-            if (!context.ChangeTracker.HasChanges())
-            {
-                _logger.LogInformation("No changes detected. Skipping.");
-                return Result.Success();
-            }
-
-            await context.SaveChangesAsync();
-        }
-        catch (Exception e)
-        {
-            return ResultError.Error(e);
-        }
-        
-        return Result.Success();
+        _cacheService = cacheService;
+        _libraryDirectory = Directory.CreateDirectory(librarySettings1.Path);
+        logger.LogDebug("Library directory: {LibraryWorkingDir}", _libraryDirectory.FullName);
+        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)
     {
         foreach (var image in images)
         {
-            if (context.Files.Any(f => image.Url.Equals(f.OriginalUrl, StringComparison.OrdinalIgnoreCase)))
+            if (context.Files.Any(f => image.Url.Equals(f.OriginalUrl)))
             {
                 continue;
             }
 
-            var downloadResult = await NetworkService.DownloadBytesAsync(new HttpRequestMessage(HttpMethod.Get, image.Url));
-            if (!downloadResult.IsSuccess)
+            var cacheResult = await _cacheService.CacheFromUrl(image.Url);
+            if (!cacheResult.IsSuccess)
             {
+                _logger.LogWarning("Failed to get image {ImageUrl}", image.Url);
                 continue;
             }
 
-            var download = downloadResult.Value;
+            var cachedFile = cacheResult.Value;
             
             var fileId = Guid.NewGuid();
-            var fileName = download.FileName ?? $"{fileId}.{download.ContentType?.Split('/').Last() ?? "unknown"}";
+            var fileName = cachedFile.OriginalFileName ?? $"{fileId}.{cachedFile.ContentType?.Split('/').Last() ?? "unknown"}";
             var relativePath = Path.Combine(foreignKey, libSubDir, $"{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}_{fileName}");
             var savePath = Path.Combine(_libraryDirectory.FullName, subDir, relativePath);
             Directory.CreateDirectory(Path.GetDirectoryName(savePath) ?? savePath);
             await using var fileStream = File.Create(savePath);
-            await fileStream.WriteAsync(download.Data.AsMemory(0, download.Data.Length));
+            await fileStream.WriteAsync(cachedFile.Data.AsMemory(0, cachedFile.Data.Length));
             
             var file = new FileEntity
             {
                 Id = fileId,
                 OriginalUrl = image.Url,
-                OriginalFileName = download.FileName,
+                OriginalFileName = cachedFile.OriginalFileName,
                 ForeignKey = foreignKey,
                 FileType = fileType,
                 RelativePath = relativePath.Replace('\\', '/'),
-                MimeType = download.ContentType,
-                SizeBytes = download.ContentLength,
+                MimeType = cachedFile.ContentType,
+                SizeBytes = cachedFile.Data.Length,
                 Height = image.Height,
                 Width = image.Width
             };
@@ -99,6 +76,64 @@ public class LibraryService : ILibraryService
         }
     }
 
+    public async Task<Result> SaveClientAsync(ClientAccountEntity client, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            var updateEntity = false;
+            var dbClient = context.ClientAccounts.Include(ca => ca.HttpCookies).FirstOrDefault(c => c.Id == client.Id);
+            if (dbClient == null)
+            {
+                dbClient = client;
+            }
+            else
+            {
+                updateEntity = true;
+                dbClient.HttpCookies = client.HttpCookies;
+                dbClient.UserAgent = client.UserAgent;
+            }
+
+            if (updateEntity)
+            {
+                context.ClientAccounts.Update(dbClient);
+            }
+            else
+            {
+                context.HttpCookies.RemoveRange(context.HttpCookies.Where(x => x.ClientId == client.Id));
+                context.ClientAccounts.Add(dbClient);
+            }
+
+            var savedResult= await context.SaveChangesAsync(cancellationToken);
+            return savedResult <= 0 ? ResultError.Fail("Could not save changes!") : Result.Success();
+        }
+        catch (Exception e)
+        {
+            return HandleException(e);
+        }
+    }
+
+    public async Task<Result<LibraryFile>> GetFileByIdAsync(Guid id, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            var file = context.Files.FirstOrDefault(f => f.Id == id);
+            if (file == null)
+            {
+                return ResultError.Fail($"File with id {id} not found.");
+            }
+            
+            var fs = new FileStream(Path.Combine(_libraryDirectory.FullName, LibraryConstants.Directories.SubDirChannels, file.RelativePath), FileMode.Open, FileAccess.Read, FileShare.Read);
+            return new LibraryFile { DataStream = fs, SizeBytes = file.SizeBytes, FileName = file.OriginalFileName ?? file.Id.ToString(), MimeType = file.MimeType ?? MediaTypeNames.Application.Octet };
+        }
+        catch (Exception e)
+        {
+            return HandleException(e);
+        }
+    }
+
     public async Task<Result<ChannelEntity>> GetChannelByIdAsync(string id, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(id))
@@ -109,7 +144,12 @@ public class LibraryService : ILibraryService
         try
         {
             await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            var channel = await context.Channels.Include(c => c.ClientAccount).FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
+            var channel = await context.Channels.AsSplitQuery()
+                .Include(c => c.ClientAccount)
+                    .ThenInclude(p => p!.HttpCookies)
+                .Include(f => f.Files)
+                .FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
+            
             if (channel == null)
             {
                 return ResultError.Fail("Channel not found!");
@@ -123,26 +163,58 @@ public class LibraryService : ILibraryService
         }
     }
 
-    public async Task<Result> SaveChannelAsync(ChannelEntity channel, CancellationToken cancellationToken = default)
+    public async Task<Result> SaveChannelAsync(InnertubeChannel innertubeChannel, CancellationToken cancellationToken = default)
     {
         try
         { 
             await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            if (context.Channels.Any(c => c.Id == channel.Id))
+            
+            var channelResult = await GetChannelByIdAsync(innertubeChannel.Id, cancellationToken);
+
+            ChannelEntity? channelEntity;
+            try
             {
-                context.Channels.Update(channel);
+                if (channelResult.IsSuccess)
+                {
+                    channelEntity = channelResult.Value;
+                    channelEntity.Name = innertubeChannel.ChannelName;
+                    channelEntity.Handle = innertubeChannel.Handle;
+                    channelEntity.Description = innertubeChannel.Description;
                 }
                 else
                 {
-                context.Channels.Add(channel);
+                    channelEntity = new ChannelEntity
+                    {
+                        Id = innertubeChannel.Id,
+                        Name = innertubeChannel.ChannelName,
+                        Handle = innertubeChannel.Handle,
+                        Description = innertubeChannel.Description
+                    };
                 }
+            }
+            catch (Exception e)
+            {
+                return ResultError.Error(e);
+            }
+            
+            if (channelResult.IsSuccess)
+            {
+                context.Channels.Update(channelEntity);
+            }
+            else
+            {
+                context.Channels.Add(channelEntity);
+            }
+            
+            await AddWebImagesAsync(context, innertubeChannel.AvatarImages, innertubeChannel.Id, "avatars", LibraryConstants.FileTypes.ChannelAvatar, LibraryConstants.Directories.SubDirChannels);
+            await AddWebImagesAsync(context, innertubeChannel.BannerImages, innertubeChannel.Id, "banners", LibraryConstants.FileTypes.ChannelBanner, LibraryConstants.Directories.SubDirChannels);
             
             var changed = await context.SaveChangesAsync(cancellationToken);
             return changed <= 0 ? ResultError.Fail("Failed to save channel!") : Result.Success();
         }
         catch (Exception e)
         {
-            return ResultError.Error(e);
+            return HandleException(e);
         }
     }
 
@@ -151,6 +223,7 @@ public class LibraryService : ILibraryService
         try
         {
             await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            var libraryDriveInfo = GetLibraryDriveInfo(_libraryDirectory);
             var libInfo = new LibraryInformation
             {
                 LibraryPath = _libraryDirectory.FullName,
@@ -158,7 +231,10 @@ public class LibraryService : ILibraryService
                 LastModifiedUtc = _libraryDirectory.LastWriteTimeUtc,
                 TotalChannels = await context.Channels.CountAsync(cancellationToken: cancellationToken),
                 TotalMedia = await context.Media.CountAsync(cancellationToken: cancellationToken),
-                TotalSizeBytes = GetDirectorySize(_libraryDirectory)
+                TotalSizeBytes = GetDirectorySize(_libraryDirectory),
+                DriveTotalSpaceBytes = libraryDriveInfo.totalSpace,
+                DriveFreeSpaceBytes = libraryDriveInfo.freeSpace,
+                DriveUsedSpaceBytes = libraryDriveInfo.usedSpace
             };
             return libInfo;
         }
@@ -168,13 +244,97 @@ public class LibraryService : ILibraryService
         }
     }
     
-    public async Task<ListResult<ChannelEntity>> GetChannelAccountsAsync(int total = 20, int offset = 0, CancellationToken cancellationToken = default)
+    public async Task<ListResult<AccountListView>> GetAccountsAsync(string? search, int offset = 0, int total = 20, CancellationToken cancellationToken = default)
     {
+        if (total == 0)
+        {
+            total = 20;
+        }
+
         try
         {
             await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            var orderedAccounts = context.Channels.Include(x => x.ClientAccount).Where(x => x.ClientAccount != null).OrderBy(x => x.Id);
-            return new ListResultReturn<ChannelEntity>(orderedAccounts.Skip(offset).Take(total).ToList(),orderedAccounts.Count());
+            var accountsQuery = context.ClientAccounts
+                .Include(ca => ca.Channel)
+                .Include(ca => ca.HttpCookies)
+                .OrderByDescending(ca => ca.Id).AsQueryable();
+            var totalAccounts = accountsQuery.Count();
+            
+            if (!string.IsNullOrWhiteSpace(search) && totalAccounts != 0)
+            {
+                var normalizedSearch = $"%{search.ToLower()}%";
+                accountsQuery = accountsQuery
+                    .Where(ca =>
+                        EF.Functions.Like(
+                            (
+                                ca.Id.ToString() + " " +
+                                (ca.Channel != null ? ca.Channel.Name : "") + " " +
+                                (ca.Channel != null ? ca.Channel.Handle : "")
+                            ).ToLower(),
+                            normalizedSearch
+                        )
+                    );
+                totalAccounts = accountsQuery.Count();
+            }
+
+            var accountViews = accountsQuery.Skip(offset).Take(total).Select(account => new AccountListView
+            {
+                Id = account.Id,
+                Name = account.Channel != null ? account.Channel.Name : "",
+                Handle = account.Channel != null ? account.Channel.Handle : "",
+                HasCookies = account.HttpCookies.Count != 0,
+                AvatarFileId = account.Files == null ? null
+                    : account.Files.Where(f => f.FileType == LibraryConstants.FileTypes.ChannelAvatar).OrderBy(x => x.Id).Select(f => f.Id).FirstOrDefault()
+            });
+
+            return new ListResultReturn<AccountListView>(totalAccounts == 0 ? [] : accountViews.ToList(), totalAccounts);
+        }
+        catch (Exception e)
+        {
+            return HandleException(e);
+        }
+    }
+
+    public async Task<ListResult<ChannelListView>> GetChannelsAsync(string? search, int offset = 0, int total = 20, CancellationToken cancellationToken = default)
+    {
+        if (total == 0)
+        {
+            total = 20;
+        }
+        
+        try
+        {
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            var channelQuery = context.Channels.OrderByDescending(c => c.Id).AsQueryable();
+            
+            var totalChannels = channelQuery.Count();
+            if (!string.IsNullOrWhiteSpace(search) && totalChannels != 0)
+            {
+                var normalizedSearch = $"%{search.ToLower()}%";
+                channelQuery = channelQuery
+                    .Where(ca =>
+                        EF.Functions.Like((
+                                ca.Id.ToString() + " " +
+                                ca.Name + " " +
+                                ca.Handle
+                            ).ToLower(),
+                            normalizedSearch
+                        )
+                    );
+                totalChannels = channelQuery.Count();
+            }
+            
+            var channelViews = channelQuery.Skip(offset).Take(total).Select(channel => new ChannelListView
+            {
+                Id = channel.Id,
+                Name = channel.Name,
+                Handle = channel.Handle,
+                AvatarFileId = channel.Files == null ? null
+                    : channel.Files.Where(f => f.FileType == LibraryConstants.FileTypes.ChannelAvatar).OrderBy(x => x.Id).Select(f => f.Id).FirstOrDefault()
+            });
+
+            return new ListResultReturn<ChannelListView>(totalChannels == 0 ? [] : channelViews.ToList(), totalChannels);
         }
         catch (Exception e)
         {
@@ -196,6 +356,20 @@ public class LibraryService : ILibraryService
         }
     }
 
+    private (long totalSpace, long freeSpace, long usedSpace) GetLibraryDriveInfo(DirectoryInfo dir)
+    {
+        try
+        {
+            var drive = new DriveInfo(dir.FullName);
+            return (drive.TotalSize, drive.AvailableFreeSpace, drive.TotalSize - drive.AvailableFreeSpace);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Error while getting directory free space.");
+            throw;
+        }
+    }
+
     private ResultError HandleException(Exception exception)
     {
         if (exception is OperationCanceledException)
@@ -203,7 +377,7 @@ public class LibraryService : ILibraryService
             return ResultError.Fail("Library service operation cancelled");
         }
 
-        _logger.LogError(exception, "Failed to get library information");
-        return ResultError.Fail("Failed to get library information");
+        _logger.LogError(exception, "Service error");
+        return ResultError.Error(exception);
     }
 }

Manager.App/Services/System/CacheService.cs

@@ -0,0 +1,224 @@
+using System.Security.Cryptography;
+using System.Text;
+using DotBased.Logging;
+using DotBased.Monads;
+using DotBased.Utilities;
+using Manager.Data.Contexts;
+using Manager.Data.Entities.Cache;
+using Manager.YouTube;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace Manager.App.Services.System;
+
+public class CacheService(ILogger<CacheService> logger, IHostEnvironment environment)
+    : ExtendedBackgroundService(nameof(CacheService), "Manages caching.", logger, TimeSpan.FromHours(5))
+{
+    private DirectoryInfo? _cacheDirectory;
+    private PooledDbContextFactory<CacheDbContext>? _dbContextFactory;
+    private const string DataSubDir = "data";
+    private const int CacheMaxAgeDays = 1;
+    private readonly SemaphoreSlim _cacheSemaphoreSlim = new(1, 1);
+
+    protected override Task InitializeAsync(CancellationToken stoppingToken)
+    {
+        _cacheDirectory = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "cache"));
+        _cacheDirectory.Create();
+        Directory.CreateDirectory(Path.Combine(_cacheDirectory.FullName, DataSubDir));
+        LogEvent($"Cache directory: {_cacheDirectory.FullName}");
+
+        AddActions([
+            new ServiceAction("Clear cache", "Manually clear cache", () =>
+            {
+                LogEvent("Manual cache clear requested.");
+                _ = Task.Run(async () =>
+                {
+                    try
+                    {
+                        await ClearCacheAsync(stoppingToken);
+                    }
+                    catch (Exception e)
+                    {
+                        logger.LogError(e, "Error clearing cache manually!");
+                        LogEvent("Error manually clearing cache.", LogSeverity.Error);
+                    }
+                }, stoppingToken);
+            }, () => true)
+        ]);
+
+        var dbContextOptionsBuilder = new DbContextOptionsBuilder<CacheDbContext>();
+        dbContextOptionsBuilder.UseSqlite($"Data Source={Path.Combine(_cacheDirectory.FullName, "cache_index.db")}");
+        _dbContextFactory = new PooledDbContextFactory<CacheDbContext>(dbContextOptionsBuilder.Options);
+
+        return Task.CompletedTask;
+    }
+
+    protected override async Task ExecuteServiceAsync(CancellationToken stoppingToken)
+    {
+        if (environment.IsDevelopment())
+        {
+            LogEvent("Development mode detected, skipping cache cleaning...");
+            return;
+        }
+
+        try
+        {
+            await ClearCacheAsync(stoppingToken);
+        }
+        catch (Exception e)
+        {
+            logger.LogError(e, "Error in execution of service.");
+            LogEvent($"Service execution failed. {e.Message}", LogSeverity.Error);
+            throw;
+        }
+    }
+
+    public string CreateCacheUrl(string originalUrl) => $"/api/v1/cache?url={originalUrl}";
+
+    public async Task<Result<CacheFile>> CacheFromUrl(string url, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                return ResultError.Fail("Url is empty.");
+            }
+
+            if (_cacheDirectory == null)
+            {
+                return ResultError.Fail("Cache directory is not initialized.");
+            }
+
+            if (_dbContextFactory == null)
+            {
+                return ResultError.Fail("Context factory is not initialized.");
+            }
+
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            var urlKeyBytes = SHA1.HashData(Encoding.UTF8.GetBytes(url));
+            var urlKey = Convert.ToHexString(urlKeyBytes);
+            var cacheEntity =
+                await context.Cache.FirstOrDefaultAsync(c => c.Id == urlKey, cancellationToken: cancellationToken);
+            if (cacheEntity == null)
+            {
+                var downloadResult =
+                    await NetworkService.DownloadBytesAsync(new HttpRequestMessage(HttpMethod.Get, url));
+                if (!downloadResult.IsSuccess)
+                {
+                    LogEvent($"Failed to download from url: {url}");
+                    return ResultError.Fail("Download failed.");
+                }
+
+                var download = downloadResult.Value;
+                await using var downloadFile =
+                    File.Create(Path.Combine(_cacheDirectory.FullName, DataSubDir, $"{urlKey}.cache"));
+                await downloadFile.WriteAsync(download.Data.AsMemory(0, download.Data.Length), cancellationToken);
+
+                cacheEntity = new CacheEntity
+                {
+                    Id = urlKey,
+                    CachedAtUtc = DateTime.UtcNow,
+                    ContentLength = download.ContentLength,
+                    ContentType = download.ContentType,
+                    OriginalFileName = download.FileName,
+                };
+
+                context.Cache.Add(cacheEntity);
+                var saved = await context.SaveChangesAsync(cancellationToken);
+                if (saved <= 0)
+                {
+                    LogEvent($"Cache entity {cacheEntity.Id} could not be saved.", LogSeverity.Error);
+                    return ResultError.Fail("Failed to save to cache db.");
+                }
+
+                return new CacheFile(download.Data, download.ContentType, download.FileName);
+            }
+
+            var filePath = Path.Combine(_cacheDirectory.FullName, DataSubDir, $"{urlKey}.cache");
+            var buffer = await File.ReadAllBytesAsync(filePath, cancellationToken);
+            if (buffer.Length == 0)
+            {
+                LogEvent($"Failed to read data from disk. File: {filePath}", LogSeverity.Error);
+                return ResultError.Fail($"Error reading data from disk. File: {filePath}");
+            }
+
+            return new CacheFile(buffer.ToArray(), cacheEntity.ContentType, cacheEntity.OriginalFileName);
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e, "Cache error.");
+        }
+    }
+
+    private async Task ClearCacheAsync(CancellationToken cancellationToken)
+    {
+        if (!await _cacheSemaphoreSlim.WaitAsync(0, cancellationToken))
+        {
+            LogEvent("The cache cleaning task is already running. Skipping this call.", LogSeverity.Warning);
+            return;
+        }
+
+        try
+        {
+            if (_dbContextFactory == null)
+                throw new InvalidOperationException("No DbContext factory configured.");
+
+            if (_cacheDirectory == null)
+                throw new InvalidOperationException("No cache directory configured.");
+
+            await using var dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            var toRemove = dbContext.Cache.Where(c => c.CachedAtUtc < DateTime.UtcNow.AddDays(-CacheMaxAgeDays));
+            if (!toRemove.Any())
+            {
+                LogEvent($"No items older than {CacheMaxAgeDays} day(s) found to clear from cache.");
+                return;
+            }
+
+            var totalToRemove = toRemove.Count();
+            LogEvent($"Found {totalToRemove} cache items that are older than 1 day(s)");
+
+            var deleted = new List<CacheEntity>();
+            long totalBytesRemoved = 0;
+            foreach (var entity in toRemove)
+            {
+                var pathToFile = Path.Combine(_cacheDirectory.FullName, DataSubDir, $"{entity.Id}.cache");
+                if (!File.Exists(pathToFile))
+                {
+                    deleted.Add(entity);
+                    totalBytesRemoved += entity.ContentLength;
+                    continue;
+                }
+
+                try
+                {
+                    File.Delete(pathToFile);
+                }
+                catch (Exception e)
+                {
+                    logger.LogError(e, "Failed to delete cache entity with id: {EntityId}. Skipping cache entity...",
+                        entity.Id);
+                    continue;
+                }
+
+                totalBytesRemoved += entity.ContentLength;
+                deleted.Add(entity);
+            }
+
+            dbContext.RemoveRange(deleted);
+            var dbDeleted = await dbContext.SaveChangesAsync(cancellationToken);
+
+            if (dbDeleted < deleted.Count)
+                LogEvent("Could not delete all files from cache.", LogSeverity.Warning);
+
+            LogEvent($"Removed {dbDeleted}/{totalToRemove} items from cache. Total of {Suffix.BytesToSizeSuffix(totalBytesRemoved)} removed from disk.");
+        }
+        finally
+        {
+            _cacheSemaphoreSlim.Release();
+        }
+    }
+}
+
+public record CacheFile(byte[] Data, string? ContentType, string? OriginalFileName);

Manager.App/Services/System/ClientService.cs

@@ -1,22 +1,20 @@
 using System.Net;
 using DotBased.Logging;
 using DotBased.Monads;
+using Manager.App.Models.System;
 using Manager.Data.Entities.LibraryContext;
 using Manager.YouTube;
-using Manager.YouTube.Models.Innertube;
 
 namespace Manager.App.Services.System;
 
 public class ClientService(IServiceScopeFactory scopeFactory, ILogger<ClientService> logger)
     : ExtendedBackgroundService(nameof(ClientService), "Managing YouTube clients", logger, TimeSpan.FromMinutes(10))
 {
-    private readonly List<YouTubeClient> _clients = [];
-    private CancellationToken _cancellationToken;
+    private readonly YouTubeClientCollection _loadedClients = [];
     private ILibraryService? _libraryService;
 
     protected override Task InitializeAsync(CancellationToken stoppingToken)
     {
-        _cancellationToken = stoppingToken;
         stoppingToken.Register(CancellationRequested);
         using var scope = scopeFactory.CreateScope();
         _libraryService = scope.ServiceProvider.GetRequiredService<ILibraryService>();
@@ -24,17 +22,91 @@ public class ClientService(IServiceScopeFactory scopeFactory, ILogger<ClientServ
         return Task.CompletedTask;
     }
 
-    protected override Task ExecuteServiceAsync(CancellationToken stoppingToken)
+    protected override async Task ExecuteServiceAsync(CancellationToken stoppingToken)
     {
-        return Task.CompletedTask;
+        LogEvent($"Saving {_loadedClients.Count} loaded client(s)");
+        foreach (var client in _loadedClients)
+        {
+            await SaveClientAsync(client, cancellationToken: stoppingToken);
+        }
     }
     
     private void CancellationRequested()
     {
-        // Clear up
+        foreach (var client in _loadedClients)
+        {
+            client.Dispose();
+        }
     }
 
-    public async Task<Result> SaveClientAsync(YouTubeClient client, Channel? channelInfo = null, CancellationToken cancellationToken = default)
+    public async Task<ListResult<YouTubeClientItem>> GetClientsAsync(string? search, int offset = 0, int limit = 10, CancellationToken cancellationToken = default)
+    {
+        if (_libraryService == null)
+        {
+            return ResultError.Fail("Library service is not initialized!.");
+        }
+
+        var accountsResult = await _libraryService.GetAccountsAsync(search, offset, limit, cancellationToken);
+        if (!accountsResult.IsSuccess)
+        {
+            return accountsResult.Error ?? ResultError.Fail("Failed to get accounts!");
+        }
+
+        var comparedClients = accountsResult.Value.Select(x => new YouTubeClientItem(x)
+            { Id = x.Id, IsLoaded = _loadedClients.Contains(x.Id) }).ToList();
+        return new ListResultReturn<YouTubeClientItem>(comparedClients, accountsResult.Total);
+    }
+
+    public async Task<Result<YouTubeClient>> LoadClientByIdAsync(string id, CancellationToken cancellationToken = default)
+    {
+        if (_loadedClients.TryGetValue(id, out var client))
+        {
+            return client;
+        }
+        
+        if (_libraryService == null)
+        {
+            return ResultError.Fail("Library service is not initialized!.");
+        }
+
+        var clientResult = await _libraryService.GetChannelByIdAsync(id, cancellationToken);
+        if (!clientResult.IsSuccess)
+        {
+            return clientResult.Error ?? ResultError.Fail("Failed to load channel from database!");
+        }
+
+        var clientAcc = clientResult.Value.ClientAccount;
+        if (clientAcc == null)
+        {
+            return ResultError.Fail("Client account is not initialized!.");
+        }
+
+        var cookieCollection = new CookieCollection();
+        foreach (var httpCookie in clientAcc.HttpCookies)
+        {
+            var cookie = new Cookie
+            {
+                Name = httpCookie.Name,
+                Value = httpCookie.Value,
+                Domain = httpCookie.Domain,
+                Path = httpCookie.Path,
+                Secure = httpCookie.Secure,
+                HttpOnly = httpCookie.HttpOnly,
+                Expires = httpCookie.ExpiresUtc ?? DateTime.MinValue
+            };
+            cookieCollection.Add(cookie);
+        }
+        var ytClientResult = await YouTubeClient.CreateAsync(cookieCollection, clientAcc.UserAgent ?? "");
+        if (!ytClientResult.IsSuccess)
+        {
+            return ytClientResult;
+        }
+
+        _loadedClients.Add(ytClientResult.Value);
+        return ytClientResult.Value;
+    }
+
+    public async Task<Result> SaveClientAsync(YouTubeClient client, CancellationToken cancellationToken = default)
     {
         if (_libraryService == null)
         {
@@ -47,93 +119,12 @@ public class ClientService(IServiceScopeFactory scopeFactory, ILogger<ClientServ
             return ResultError.Fail("Client does not have an ID, cannot save to library database!");
         }
         
-        if (channelInfo != null)
-        {
-            var imagesResult = await _libraryService.FetchChannelImagesAsync(channelInfo);
-            if (!imagesResult.IsSuccess)
-            {
-                logger.LogWarning("Failed to fetch channel images!");
-            }
-        }
+        _loadedClients.Add(client);
 
-        var channelResult = await _libraryService.GetChannelByIdAsync(client.Id, cancellationToken);
-
-        ChannelEntity? channelEntity;
-        try
-        {
-            if (channelResult.IsSuccess)
-            {
-                channelEntity = channelResult.Value;
-                UpdateChannelEntity(client, channelEntity, channelInfo);
-            }
-            else
-            {
-                channelEntity = CreateNewChannelFromClient(client, channelInfo);
-            }
-        }
-        catch (Exception e)
-        {
-            LogEvent("Failed to save client: " + e.Message, LogSeverity.Warning);
-            return ResultError.Error(e);
-        }
-        
-        var saveResult = await _libraryService.SaveChannelAsync(channelEntity, cancellationToken);
-        return saveResult;
-    }
-
-    private void UpdateChannelEntity(YouTubeClient client, ChannelEntity entity, Channel? channelInfo)
-    {
-        if (channelInfo != null)
-        {
-            entity.Name = channelInfo.ChannelName;
-            entity.Handle = channelInfo.Handle;
-            entity.Description = channelInfo.Description;
-        }
-        
-        var clientAcc = entity.ClientAccount;
-        if (clientAcc != null)
-        {
-            clientAcc.UserAgent = clientAcc.UserAgent;
-            var currentCookies = client.CookieContainer.GetAllCookies();
-            foreach (var cookieEntity in clientAcc.HttpCookies.ToList())
-            {
-                var cookie = currentCookies[cookieEntity.Name];
-                if (cookie == null)
-                {
-                    clientAcc.HttpCookies.Remove(cookieEntity);
-                    continue;
-                }
-
-                if (!cookie.Domain.Equals(cookieEntity.Domain, StringComparison.InvariantCultureIgnoreCase))
-                {
-                    continue;
-                }
-
-                cookieEntity.Value = cookie.Value;
-                cookieEntity.Path = cookie.Path;
-                cookieEntity.Secure = cookie.Secure;
-                cookieEntity.HttpOnly = cookie.HttpOnly;
-                cookieEntity.ExpiresUtc = cookie.Expires == DateTime.MinValue ? null : cookie.Expires;
-            }
-        }
-    }
-
-    private ChannelEntity CreateNewChannelFromClient(YouTubeClient client, Channel? channelInfo)
-    {
-        if (channelInfo == null)
-        {
-            throw new ArgumentNullException(nameof(channelInfo), "Channel information is required to store new client/account.");
-        }
-
-        var cookies = new List<HttpCookieEntity>();
-        foreach (var cookieObj in client.CookieContainer.GetAllCookies())
-        {
-            if (cookieObj is not Cookie cookie)
-            {
-                continue;
-            }
-
-            var cookieEntity = new HttpCookieEntity
+        List<HttpCookieEntity> httpCookies = [];
+        httpCookies.AddRange(client.CookieContainer.GetAllCookies().Where(c => c.Expires != DateTime.MinValue)
+        .ToList()
+        .Select(cookie => new HttpCookieEntity
         {
             ClientId = client.Id,
             Name = cookie.Name,
@@ -142,26 +133,10 @@ public class ClientService(IServiceScopeFactory scopeFactory, ILogger<ClientServ
             Path = cookie.Path,
             Secure = cookie.Secure,
             HttpOnly = cookie.HttpOnly,
-                ExpiresUtc = cookie.Expires == DateTime.MinValue ? null : cookie.Expires
-            };
-            cookies.Add(cookieEntity);
-        }
+            ExpiresUtc = cookie.Expires
+        }));
         
-        var clientAcc = new ClientAccountEntity
-        {
-            Id = client.Id,
-            UserAgent = client.UserAgent,
-            HttpCookies = cookies
-        };
-        
-        var channel = new ChannelEntity
-        {
-            Id = channelInfo.Id,
-            Name = channelInfo.ChannelName,
-            Handle = channelInfo.Handle,
-            Description = channelInfo.Description,
-            ClientAccount = clientAcc
-        };
-        return channel;
+        var saveResult = await _libraryService.SaveClientAsync(new ClientAccountEntity { Id = client.Id, UserAgent = client.UserAgent, HttpCookies = httpCookies }, cancellationToken);
+        return saveResult;
     }
 }

Manager.Data/Contexts/AuditInterceptor.cs

@@ -56,7 +56,7 @@ public class AuditInterceptor : SaveChangesInterceptor
                     break;
                 case EntityState.Modified:
                     audits.AddRange(allowedProperties
-                            .Where(p => p.IsModified)
+                            .Where(p => p.IsModified && !Equals(p.OriginalValue, p.CurrentValue))
                             .Select(p => CreateAudit(entry, p, entry.State, primaryKey))
                     );
                     break;
@@ -82,7 +82,7 @@ public class AuditInterceptor : SaveChangesInterceptor
             EntityName = entry.Entity.GetType().Name,
             EntityId = primaryKey ?? "Unknown",
             PropertyName = prop.Metadata.Name,
-            OldValue = SerializeValue(prop.OriginalValue),
+            OldValue = changeType == EntityState.Added ? null : SerializeValue(prop.OriginalValue),
             NewValue = SerializeValue(prop.CurrentValue),
             ModifiedUtc = DateTime.UtcNow,
             ChangedBy = "SYSTEM",

Manager.Data/Contexts/CacheDbContext.cs

@@ -0,0 +1,25 @@
+using Manager.Data.Entities.Cache;
+using Microsoft.EntityFrameworkCore;
+
+namespace Manager.Data.Contexts;
+
+public sealed class CacheDbContext : DbContext
+{
+    public CacheDbContext(DbContextOptions<CacheDbContext> options) : base(options)
+    {
+        Database.EnsureCreated();
+    }
+
+    public DbSet<CacheEntity> Cache { get; set; }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<CacheEntity>(ce =>
+        {
+            ce.ToTable("cache");
+            ce.HasKey(x => x.Id);
+        });
+        
+        base.OnModelCreating(modelBuilder);
+    }
+}

Manager.Data/Contexts/LibraryDbContext.cs

@@ -18,7 +18,7 @@ public sealed class LibraryDbContext : DbContext
 
     public DbSet<CaptionEntity> Captions { get; set; }
     public DbSet<ChannelEntity> Channels { get; set; }
-    public DbSet<ClientAccountEntity> Accounts { get; set; }
+    public DbSet<ClientAccountEntity> ClientAccounts { get; set; }
     public DbSet<HttpCookieEntity> HttpCookies { get; set; }
     public DbSet<MediaEntity> Media { get; set; }
     public DbSet<MediaFormatEntity> MediaFormats { get; set; }
@@ -55,8 +55,12 @@ public sealed class LibraryDbContext : DbContext
                 .WithOne()
                 .HasForeignKey(x => x.ChannelId);
             channel.HasOne(x => x.ClientAccount)
+                .WithOne(x => x.Channel)
+                .HasForeignKey<ClientAccountEntity>(e => e.Id)
+                .IsRequired(false);
+            channel.HasMany(x => x.Files)
                 .WithOne()
-                .HasForeignKey<ClientAccountEntity>(e => e.Id);
+                .HasForeignKey(f => f.ForeignKey);
         });
 
         modelBuilder.Entity<ClientAccountEntity>(cae =>
@@ -66,6 +70,13 @@ public sealed class LibraryDbContext : DbContext
             cae.HasMany(x => x.HttpCookies)
                 .WithOne()
                 .HasForeignKey(x => x.ClientId);
+            cae.HasOne(x => x.Channel)
+                .WithOne(ca => ca.ClientAccount)
+                .HasForeignKey<ChannelEntity>(ce => ce.Id)
+                .IsRequired(false);
+            cae.HasMany(x => x.Files)
+                .WithOne()
+                .HasForeignKey(f => f.ForeignKey);
         });
 
         modelBuilder.Entity<HttpCookieEntity>(httpce =>

Manager.Data/Entities/LibraryContext/ChannelEntity.cs

@@ -17,4 +17,5 @@ public class ChannelEntity : DateTimeBase
     public List<MediaEntity> Media { get; set; } = [];
     public List<PlaylistEntity> Playlists { get; set; } = [];
     public ClientAccountEntity? ClientAccount { get; set; }
+    public List<FileEntity>? Files { get; set; }
 }

Manager.Data/Entities/LibraryContext/ClientAccountEntity.cs

@@ -11,4 +11,6 @@ public class ClientAccountEntity : DateTimeBase
     public List<HttpCookieEntity> HttpCookies { get; set; } = [];
     [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
     public string? UserAgent { get; set; }
+    public ChannelEntity? Channel { get; set; }
+    public List<FileEntity>? Files { get; set; }
 }

Manager.Data/Entities/LibraryContext/HttpCookieEntity.cs

@@ -16,7 +16,7 @@ public class HttpCookieEntity : DateTimeBase
     public string? Domain { get; set; }
     [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
     public string? Path { get; set; }
-    public DateTimeOffset? ExpiresUtc { get; set; }
+    public DateTime? ExpiresUtc { get; set; }
     public bool Secure { get; set; }
     public bool HttpOnly { get; set; }
 }

Manager.YouTube/Constants/CookieConstants.cs

@@ -0,0 +1,22 @@
+namespace Manager.YouTube.Constants;
+
+public static class CookieConstants
+{
+    public static readonly IReadOnlyCollection<string> RequiredCookiesNames = new HashSet<string>
+    {
+        "SID",
+        "SIDCC",
+        "HSID",
+        "SSID",
+        "APISID",
+        "SAPISID",
+        "__Secure-1PAPISID",
+        "__Secure-1PSID",
+        "__Secure-1PSIDCC",
+        "__Secure-1PSIDTS",
+        "__Secure-3PAPISID",
+        "__Secure-3PSID",
+        "__Secure-3PSIDCC",
+        "__Secure-3PSIDTS"
+    };
+}

Manager.YouTube/Interpreter/JavaScriptEngineManager.cs

@@ -0,0 +1,58 @@
+using System.Text;
+using DotBased.Monads;
+
+namespace Manager.YouTube.Interpreter;
+
+public static class JavaScriptEngineManager
+{
+    private static readonly PlayerEngineCollection Engines = [];
+    
+    public static async Task<Result<PlayerEngine>> GetPlayerEngine(string playerUrl)
+    {
+        if (string.IsNullOrEmpty(playerUrl))
+        {
+            return ResultError.Fail("player url is empty or null!");
+        }
+
+        var version = GetScriptVersion(playerUrl);
+        
+        if (Engines.TryGetValue(version, out var engine))
+        {
+            return engine;
+        }
+
+        var playerJsSourceResult = await DownloadPlayerScriptAsync(playerUrl);
+        if (!playerJsSourceResult.IsSuccess)
+        {
+            return playerJsSourceResult.Error ?? ResultError.Fail("Download player script failed!");
+        }
+
+        return new PlayerEngine(version, playerJsSourceResult.Value);
+    }
+    
+    private static string GetScriptVersion(string relativePlayerUrl)
+    {
+        var split = relativePlayerUrl.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var v = split[2];
+        var lang = split[4];
+        return $"{v}-{lang}";
+    }
+
+    private static async Task<Result<string>> DownloadPlayerScriptAsync(string relativeUrl, YouTubeClient? client = null)
+    {
+        var downloadRequest = new HttpRequestMessage(HttpMethod.Get, new Uri($"{NetworkService.Origin}/{relativeUrl}"));
+        var downloadResponse = await NetworkService.DownloadBytesAsync(downloadRequest, client);
+        if (!downloadResponse.IsSuccess)
+        {
+            return downloadResponse.Error ?? ResultError.Fail($"Failed to download script from url: {relativeUrl}");
+        }
+
+        var playerJs = Encoding.UTF8.GetString(downloadResponse.Value.Data);
+        if (string.IsNullOrWhiteSpace(playerJs))
+        {
+            return ResultError.Fail("Script value is empty!");
+        }
+        
+        return playerJs;
+    }
+}

Manager.YouTube/Interpreter/PlayerEngine.cs

@@ -0,0 +1,42 @@
+using DotBased.Logging;
+using Jint;
+
+namespace Manager.YouTube.Interpreter;
+
+public class PlayerEngine
+{
+    public string Version { get; set; }
+    public Engine JsEngine { get; set; }
+    private ILogger Logger { get; set; }
+
+    public PlayerEngine(string version, string script)
+    {
+        if (string.IsNullOrEmpty(version))
+        {
+            throw new ArgumentNullException(nameof(version));
+        }
+
+        if (string.IsNullOrEmpty(script))
+        {
+            throw new ArgumentNullException(nameof(script));
+        }
+
+        Logger = LogService.RegisterLogger(typeof(PlayerEngine), version);
+        Version = version;
+        JsEngine = new Engine().Execute(script).SetValue("log", new Action<object>(obj =>
+        {
+            var logStr = obj.ToString();
+            if (string.IsNullOrEmpty(logStr))
+            {
+                return;
+            }
+            Logger.Information(logStr);
+        }));
+        
+    }
+
+    public void InitializePlayer()
+    {
+        JsEngine.Execute("createPlayer");
+    }
+}

Manager.YouTube/Interpreter/PlayerEngineCollection.cs

@@ -0,0 +1,11 @@
+using System.Collections.ObjectModel;
+
+namespace Manager.YouTube.Interpreter;
+
+public class PlayerEngineCollection : KeyedCollection<string, PlayerEngine>
+{
+    protected override string GetKeyForItem(PlayerEngine item)
+    {
+        return item.Version;
+    }
+}

Manager.YouTube/Manager.YouTube.csproj

@@ -9,6 +9,7 @@
     <ItemGroup>
       <PackageReference Include="DotBased" Version="1.0.0" />
       <PackageReference Include="HtmlAgilityPack" Version="1.12.2" />
+      <PackageReference Include="Jint" Version="4.4.1" />
     </ItemGroup>
 
 </Project>

Manager.YouTube/Models/Innertube/ClientState.cs

@@ -35,6 +35,9 @@ public class ClientState : AdditionalJsonData
     [JsonPropertyName("SERVER_VERSION")]
     public string? ServerVersion { get; set; }
 
+    [JsonPropertyName("PLAYER_JS_URL")]
+    public string? PlayerJsUrl { get; set; }
+
     [JsonPropertyName("INNERTUBE_CONTEXT")]
     public InnerTubeContext? InnerTubeContext { get; set; }
 

Manager.YouTube/Models/Innertube/ColorInfo.cs

@@ -0,0 +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/InnertubeChannel.cs

@@ -1,6 +1,6 @@
 namespace Manager.YouTube.Models.Innertube;
 
-public class Channel
+public class InnertubeChannel
 {
     public required string Id { get; set; }
     public bool NoIndex { get; set; }

Manager.YouTube/Models/Innertube/Range.cs

@@ -0,0 +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/StoryBoard.cs

@@ -0,0 +1,8 @@
+namespace Manager.YouTube.Models.Innertube;
+
+public class StoryBoard
+{
+    public string Spec { get; set; } = "";
+    public int RecommendedLevel { get; set; }
+    public int HighResolutionRecommendedLevel { get; set; }
+}

Manager.YouTube/Models/Innertube/StreamingData.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+using Manager.YouTube.Util.Converters;
+
+namespace Manager.YouTube.Models.Innertube;
+
+public class StreamingData
+{
+    public DateTime FetchedUtc { get; set; } = DateTime.UtcNow;
+    [JsonPropertyName("expiresInSeconds")]
+    public int ExpiresInSeconds { get; set; }
+    [JsonPropertyName("serverAbrStreamingUrl")]
+    [JsonConverter(typeof(JsonUrlEscapeConverter))]
+    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

@@ -0,0 +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

@@ -0,0 +1,9 @@
+using System.Text.Json.Nodes;
+
+namespace Manager.YouTube.Models.Parser;
+
+public class YouTubeVideoData
+{
+    public JsonNode? YouTubePlayerData { get; set; }
+    public JsonNode? YouTubeInitialData { get; set; }
+}

Manager.YouTube/Models/PlayerConfig.cs

@@ -0,0 +1,12 @@
+namespace Manager.YouTube.Models;
+
+public class PlayerConfig
+{
+    public double AudioLoudnessDb { get; set; }
+    public double AudioPerceptualLoudnessDb { get; set; }
+    public bool AudioEnablePerFormatLoudness { get; set; }
+    public uint MaxBitrate { get; set; }
+    public uint MaxReadAheadMediaTimeMs { get; set; }
+    public uint MinReadAheadMediaTimeMs { get; set; }
+    public uint ReadAheadGrowthRateMs { get; set; }
+}

Manager.YouTube/Models/Playlist/PlaylistVideo.cs

@@ -0,0 +1,13 @@
+using Manager.YouTube.Models.Innertube;
+
+namespace Manager.YouTube.Models.Playlist;
+
+public class PlaylistVideo
+{
+    public required string VideoId { get; set; }
+    public List<WebImage> Thumbnails { get; set; } = [];
+    public required string Title { get; set; }
+    public required string Author { get; set; }
+    public long LengthSeconds { get; set; }
+    public bool IsPlayable { get; set; }
+}

Manager.YouTube/Models/YouTubePlaylist.cs

@@ -0,0 +1,19 @@
+using Manager.YouTube.Models.Playlist;
+
+namespace Manager.YouTube.Models;
+
+public class YouTubePlaylist
+{
+    public required string Id { get; set; }
+    public required string Title { get; set; }
+    public required string Description { get; set; }
+    public required string Owner { get; set; }
+    public required string OwnerId { get; set; }
+    public bool NoIndex { get; set; }
+    public bool Unlisted { get; set; }
+    public bool CanReorder { get; set; }
+    public bool IsEditable { get; set; }
+    public List<PlaylistVideo> Videos { get; set; } = [];
+
+    public string? ContinuationToken { get; set; }
+}

Manager.YouTube/Models/YouTubeVideo.cs

@@ -0,0 +1,38 @@
+using Manager.YouTube.Models.Innertube;
+
+namespace Manager.YouTube.Models;
+
+public class YouTubeVideo
+{
+    public required string VideoId { get; set; }
+    public string Title { get; set; } = "";
+    public string Description { get; set; } = "";
+    public string[] HashTags { get; set; } = [];
+    public long ViewCount { get; set; }
+    public long LikeCount { get; set; }
+    public string ChannelId { get; set; } = "";
+    public string Author { get; set; } = "";
+    public string PlayabilityStatus { get; set; } = "";
+    public long LengthSeconds { get; set; }
+    public string[] Keywords { get; set; } = [];
+    public bool IsOwnerViewing { get; set; }
+    public bool AllowRating { get; set; }
+    public bool IsCrawlable { get; set; }
+    public bool IsPrivate { get; set; }
+    public bool IsUnpluggedCorpus { get; set; }
+    public bool IsLive { get; set; }
+    public bool IsFamilySave { get; set; }
+    public string[] AvailableCountries { get; set; } = [];
+    public bool IsUnlisted { get; set; }
+    public bool HasYpcMetadata { get; set; }
+    public DateTime PublishDate { get; set; }
+    public DateTime UploadDate { get; set; }
+    public bool IsShortsEligible { get; set; }
+    public string Category { get; set; } = "";
+
+    public StreamingData? StreamingData { get; set; }
+    public List<WebImage> Thumbnails { get; set; } = [];
+
+    public PlayerConfig? PlayerConfig { get; set; }
+    public StoryBoard? StoryBoard { get; set; }
+}

Manager.YouTube/NetworkService.cs

@@ -6,9 +6,9 @@ namespace Manager.YouTube;
 public static class NetworkService
 {
     public const string Origin = "https://www.youtube.com";
-    private static readonly HttpClient HttpClient = new HttpClient();
+    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);
@@ -43,7 +43,7 @@ public static class NetworkService
                 return ResultError.Fail($"Failed to get file to download, response code: {response.StatusCode}.");
             }
             
-            var data = await response.Content.ReadAsByteArrayAsync();;
+            var data = await response.Content.ReadAsByteArrayAsync();
             
             return new DownloadResult(data, response.Content.Headers.ContentType?.MediaType, response.Content.Headers.ContentDisposition?.FileName?.Trim('"'), response.Content.Headers.ContentLength ?? 0);
         }

Manager.YouTube/Parsers/CookieTxtParser.cs

@@ -0,0 +1,53 @@
+using System.Net;
+
+namespace Manager.YouTube.Parsers;
+
+public static class CookieTxtParser
+{
+    public static async Task<CookieCollection> ParseAsync(Stream stream, HashSet<string>? allowedCookies = null)
+    {
+        var cookieCollection = new CookieCollection();
+        
+        using var reader = new StreamReader(stream);
+        while (await reader.ReadLineAsync() is { } line)
+        {
+            if (string.IsNullOrWhiteSpace(line) || line.StartsWith('#'))
+            {
+                continue;
+            }
+
+            var lineParts = line.Split('\t');
+            if (lineParts.Length < 7)
+            {
+                continue;
+            }
+
+            var domain = lineParts[0];
+            //var includeSubdomains = lineParts[1].Equals("TRUE", StringComparison.OrdinalIgnoreCase);
+            var path = lineParts[2];
+            var secure = lineParts[3].Equals("TRUE", StringComparison.OrdinalIgnoreCase);
+            var unixExpiry = long.TryParse(lineParts[4], out var exp) ? exp : 0;
+            var name = lineParts[5];
+            var value = lineParts[6];
+            
+            if (!allowedCookies?.Contains(name) ?? false)
+            {
+                continue;
+            }
+
+            var cookie = new Cookie(name, value, path, domain)
+            {
+                Secure = secure
+            };
+            
+            if (unixExpiry is > 0 and < int.MaxValue)
+            {
+                cookie.Expires = DateTimeOffset.FromUnixTimeSeconds(unixExpiry).DateTime;
+            }
+
+            cookieCollection.Add(cookie);
+        }
+
+        return cookieCollection;
+    }
+}

Manager.YouTube/Parsers/HtmlParser.cs

@@ -1,5 +1,7 @@
+using System.Text.Json.Nodes;
 using DotBased.Monads;
 using HtmlAgilityPack;
+using Manager.YouTube.Models.Parser;
 
 namespace Manager.YouTube.Parsers;
 
@@ -32,6 +34,56 @@ public static class HtmlParser
         return (json, isPremiumUser);
     }
 
+    public static Result<YouTubeVideoData> GetVideoDataFromHtml(string html)
+    {
+        if (string.IsNullOrWhiteSpace(html))
+        {
+            return ResultError.Fail("html cannot be empty!");
+        }
+        var htmlDocument = new HtmlDocument();
+        htmlDocument.LoadHtml(html);
+
+        const string initialYoutubeData = "var ytInitialPlayerResponse = {";
+        var initialPlayerDataNode = htmlDocument.DocumentNode.SelectSingleNode($"//script[contains(., '{initialYoutubeData}')]");
+        if (string.IsNullOrWhiteSpace(initialPlayerDataNode.InnerText))
+        {
+            return ResultError.Fail("Could not find {initialPlayerData} in html script nodes!");
+        }
+        var initialPlayerDataString = ExtractJson(initialPlayerDataNode.InnerText, "var ytInitialPlayerResponse = ");
+        if (string.IsNullOrWhiteSpace(initialPlayerDataString))
+        {
+            return ResultError.Fail("Failed to extract initial player date from JSON.");
+        }
+        var parsedPlayerInitialData = JsonNode.Parse(initialPlayerDataString);
+        
+        const string initialData = "var ytInitialData = {";
+        var initialDataNode = htmlDocument.DocumentNode.SelectSingleNode($"//script[contains(., '{initialData}')]");
+        if (string.IsNullOrWhiteSpace(initialDataNode.InnerText))
+        {
+            return ResultError.Fail("Could not find {initialData} in html script nodes!");
+        }
+        
+        var initialDataJsonString = ExtractJson(initialDataNode.InnerText, "var ytInitialData = ");
+        if (string.IsNullOrWhiteSpace(initialDataJsonString))
+        {
+            return ResultError.Fail("Failed to extract initial player date from JSON.");
+        }
+        var parsedInitialData = JsonNode.Parse(initialDataJsonString);
+
+        try
+        {
+            return new YouTubeVideoData
+            {
+                YouTubePlayerData = parsedPlayerInitialData,
+                YouTubeInitialData = parsedInitialData
+            };
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e, "Could not parse youtube player data.");
+        }
+    }
+
     static string? ExtractJson(string input, string marker)
     {
         var start = input.IndexOf(marker, StringComparison.Ordinal);

Manager.YouTube/Parsers/Json/ChannelJsonParser.cs

@@ -6,7 +6,7 @@ namespace Manager.YouTube.Parsers.Json;
 
 public static class ChannelJsonParser
 {
-    public static Result<Channel> ParseJsonToChannelData(string json)
+    public static Result<InnertubeChannel> ParseJsonToChannelData(string json)
     {
         try
         {
@@ -23,7 +23,7 @@ public static class ChannelJsonParser
                 throw new InvalidOperationException("No channel id found.");
             }
 
-            var channel = new Channel
+            var channel = new InnertubeChannel
             {
                 Id = channelId,
                 ChannelName = channelMetadata.GetProperty("title").ToString(),

Manager.YouTube/Parsers/Json/JsonParser.cs

@@ -1,4 +1,6 @@
+using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using Manager.YouTube.Models.Innertube;
 
 namespace Manager.YouTube.Parsers.Json;
@@ -9,4 +11,81 @@ public static class JsonParser
         array
             .Select(image => new WebImage { Width = image.GetProperty("width").GetInt32(), Height = image.GetProperty("height").GetInt32(), Url = image.GetProperty("url").GetString() ?? "" })
             .ToList();
+    
+    public static string ExtractTextOrHtml(JsonNode? node)
+    {
+        if (node is not JsonObject nodeObj)
+        {
+            return "";
+        }
+
+        // Case 1: Simple text (no formatting)
+        if (nodeObj.TryGetPropertyValue("simpleText", out var simpleText))
+            return simpleText?.GetValue<string>() ?? string.Empty;
+
+        // Case 2: Runs (formatted text segments)
+        if (nodeObj.TryGetPropertyValue("runs", out var runs) && runs != null && runs.GetValueKind() == JsonValueKind.Array)
+        {
+            var sb = new StringBuilder();
+
+            foreach (var runNode in runs.AsArray())
+            {
+                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.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.TryGetPropertyValue("navigationEndpoint", out var nav) && nav is JsonObject navObj &&
+                    navObj.TryGetPropertyValue("url", out var urlProp))
+                {
+                    var url = urlProp?.GetValue<string>();
+                    if (!string.IsNullOrEmpty(url))
+                        formatted = $"<a href=\"{url}\">{formatted}</a>";
+                }
+
+                if (run.TryGetPropertyValue("emoji", out var emoji) && emoji is JsonObject emojiObj)
+                {
+                    if (emojiObj.TryGetPropertyValue("url", out var emojiUrl))
+                    {
+                        var src = emojiUrl?.GetValue<string>();
+                        if (!string.IsNullOrEmpty(src))
+                            formatted = $"<img src=\"{src}\" alt=\"{text}\" class=\"emoji\" />";
+                    }
+                }
+
+                sb.Append(formatted);
+            }
+
+            return sb.ToString();
+        }
+
+        return string.Empty;
+    }
+
+    public static List<WebImage> ExtractWebImages(JsonNode? node)
+    {
+        if (node == null)
+        {
+            return [];
+        }
+
+        var thumbnailsArray = node["thumbnails"];
+        return thumbnailsArray?.Deserialize<List<WebImage>>() ?? [];
+    }
 }

Manager.YouTube/Parsers/Json/VideoJsonParser.cs

@@ -0,0 +1,35 @@
+using System.Text.Json;
+using DotBased.Logging;
+using DotBased.Monads;
+using Manager.YouTube.Models;
+using Manager.YouTube.Models.Parser;
+using Manager.YouTube.Util.Converters;
+
+namespace Manager.YouTube.Parsers.Json;
+
+public static class VideoJsonParser
+{
+    private static readonly JsonSerializerOptions VideoParserOptions = new() { Converters = { new YouTubeVideoJsonConverter() } };
+    private static readonly ILogger Logger = LogService.RegisterLogger(typeof(VideoJsonParser), "Video JSON parser");
+    
+    public static Result<YouTubeVideo> ParseVideoData(YouTubeVideoData videoData)
+    {
+        if (videoData.YouTubePlayerData == null)
+        {
+            return ResultError.Fail("No initial video data found!");
+        }
+
+        YouTubeVideo? video;
+        try
+        {
+            video = videoData.YouTubePlayerData.Deserialize<YouTubeVideo>(VideoParserOptions);
+        }
+        catch (Exception e)
+        {
+            Logger.Error(e, "Failed to parse video data");
+            return ResultError.Fail("Failed to parse video data");
+        }
+        
+        return video != null? video : ResultError.Fail("Failed to parse video data!");
+    }
+}

Manager.YouTube/Util/AuthenticationUtilities.cs

@@ -31,7 +31,17 @@ public static class AuthenticationUtilities
             throw new ArgumentNullException(nameof(origin));
         }
 
-        datasyncId = datasyncId.Replace("||", "");
+        if (datasyncId.Contains("||", StringComparison.OrdinalIgnoreCase))
+        {
+            var ids = datasyncId.Split("||", StringSplitOptions.RemoveEmptyEntries);
+            datasyncId = ids.Length switch
+            {
+                1 => ids[0],
+                2 => ids[1],
+                _ => datasyncId
+            };
+        }
+
         sapisid = Uri.UnescapeDataString(sapisid);
         if (string.IsNullOrWhiteSpace(time))
         {
@@ -52,7 +62,7 @@ public static class AuthenticationUtilities
     private static string GetTime()
     {
         var st = new DateTime(1970, 1, 1);
-        var t = DateTime.Now.ToUniversalTime() - st;
+        var t = DateTime.UtcNow - st;
         var time = (t.TotalMilliseconds + 0.5).ToString(CultureInfo.InvariantCulture);
         return time[..10];
     }

Manager.YouTube/Util/Cipher/CipherDecoder.cs

@@ -0,0 +1,125 @@
+using System.Collections.Frozen;
+using System.Text;
+using System.Text.RegularExpressions;
+using Manager.YouTube.Util.Cipher.Operations;
+
+namespace Manager.YouTube.Util.Cipher;
+
+public partial class CipherDecoder
+{
+    public required string Version { get; init; }
+    public readonly IReadOnlySet<ICipherOperation> Operations;
+
+    private CipherDecoder(IEnumerable<ICipherOperation> operations)
+    {
+        Operations = operations.ToFrozenSet();
+        if (Operations.Count == 0)
+        {
+            throw new ArgumentNullException(nameof(operations), "No decipher operations given.");
+        }
+    }
+
+    public static async Task<CipherDecoder> CreateAsync(string relativeUrl, string version, YouTubeClient? client = null)
+    {
+        var operations = await GetCipherOperations(relativeUrl, client);
+        var decoder = new CipherDecoder(operations)
+        {
+            Version = version
+        };
+        return decoder;
+    }
+
+    public string Decipher(string? signatureCipher)
+    {
+        if (string.IsNullOrEmpty(signatureCipher))
+        {
+            return "";
+        }
+
+        var urlBuilder = new StringBuilder();
+
+        var indexStart = signatureCipher.IndexOf("s=", StringComparison.Ordinal);
+        var indexEnd = signatureCipher.IndexOf("&", StringComparison.Ordinal);
+        var signature = signatureCipher.Substring(indexStart, indexEnd);
+
+        indexStart = signatureCipher.IndexOf("&sp", StringComparison.Ordinal);
+        indexEnd = signatureCipher.IndexOf("&url", StringComparison.Ordinal);
+        var spParam = signatureCipher.Substring(indexStart, indexEnd - indexStart);
+
+        indexStart = signatureCipher.IndexOf("&url", StringComparison.Ordinal);
+        var videoUrl = signatureCipher[indexStart..];
+
+
+        signature = signature[(signature.IndexOf('=') + 1)..];
+        spParam = spParam[(spParam.IndexOf('=') + 1)..];
+        videoUrl = videoUrl[(videoUrl.IndexOf('=') + 1)..];
+        if (string.IsNullOrWhiteSpace(signature))
+        {
+            throw new InvalidOperationException("Invalid signature.");
+        }
+        var signatureDeciphered = Operations.Aggregate(signature, (acc, op) => op.Decipher(acc));
+
+        urlBuilder.Append(videoUrl);
+        urlBuilder.Append($"&{spParam}=");
+        urlBuilder.Append(signatureDeciphered);
+        return urlBuilder.ToString();
+    }
+
+    private static async Task<IEnumerable<ICipherOperation>> GetCipherOperations(string relativeUrl, YouTubeClient? client = null)
+    {
+        var downloadRequest = new HttpRequestMessage(HttpMethod.Get, new Uri($"{NetworkService.Origin}/{relativeUrl}"));
+        var downloadResponse = await NetworkService.DownloadBytesAsync(downloadRequest, client);
+        if (!downloadResponse.IsSuccess)
+        {
+            return [];
+        }
+
+        var playerJs = Encoding.UTF8.GetString(downloadResponse.Value.Data);
+        if (string.IsNullOrWhiteSpace(playerJs))
+        {
+            return [];
+        }
+        
+        var functionBody = FunctionBodyRegex().Match(playerJs).Groups[0].ToString();
+        var definitionBody = DefinitionBodyRegex().Match(functionBody).Groups[1].Value;
+        var decipherDefinition = Regex.Match(playerJs, $@"var\s+{definitionBody}=\{{(\w+:function\(\w+(,\w+)?\)\{{(.*?)\}}),?\}};", RegexOptions.Singleline).Groups[0].ToString();
+
+        SortedSet<ICipherOperation> operations = [];
+        foreach (var statement in functionBody.Split(';'))
+        {
+            // Get the name of the function called in this statement
+            var calledFuncName = StatementFunctionNameRegex().Match(statement).Groups[1].Value;
+            if (string.IsNullOrWhiteSpace(calledFuncName))
+                continue;
+
+            if (Regex.IsMatch(decipherDefinition, $@"{Regex.Escape(calledFuncName)}:\bfunction\b\([a],b\).(\breturn\b)?.?\w+\."))
+            {
+                var index = int.Parse(OperationIndexRegex().Match(statement).Groups[1].Value);
+                operations.Add(new CipherSlice(index));
+            }
+            else if (Regex.IsMatch(decipherDefinition, $@"{Regex.Escape(calledFuncName)}:\bfunction\b\(\w+\,\w\).\bvar\b.\bc=a\b"))
+            {
+                var index = int.Parse(OperationIndexRegex().Match(statement).Groups[1].Value);
+                operations.Add(new CipherSwap(index));
+            }
+            else if (Regex.IsMatch(decipherDefinition, $@"{Regex.Escape(calledFuncName)}:\bfunction\b\(\w+\)"))
+            {
+                operations.Add(new CipherReverse());
+            }
+        }
+
+        return operations;
+    }
+
+    
+    [GeneratedRegex(@"([A-Za-z_$][A-Za-z0-9_$]*)=function\([A-Za-z_$][A-Za-z0-9_$]*\)\{\s*([A-Za-z_$][A-Za-z0-9_$]*)=\2\.split\(\x22\x22\);[\s\S]*?return\s+\2\.join\(\x22\x22\)\s*\}")]
+    private static partial Regex FunctionBodyRegex();
+    [GeneratedRegex("([\\$_\\w]+).\\w+\\(\\w+,\\d+\\);")]
+    private static partial Regex DefinitionBodyRegex();
+    
+    
+    [GeneratedRegex(@"\(\w+,(\d+)\)")]
+    private static partial Regex OperationIndexRegex();
+    [GeneratedRegex(@"\w+(?:.|\[)(\""?\w+(?:\"")?)\]?\(")]
+    private static partial Regex StatementFunctionNameRegex();
+}

Manager.YouTube/Util/Cipher/CipherDecoderCollection.cs

@@ -0,0 +1,11 @@
+using System.Collections.ObjectModel;
+
+namespace Manager.YouTube.Util.Cipher;
+
+public class CipherDecoderCollection : KeyedCollection<string, CipherDecoder>
+{
+    protected override string GetKeyForItem(CipherDecoder item)
+    {
+        return item.Version;
+    }
+}

Manager.YouTube/Util/Cipher/CipherManager.cs

@@ -0,0 +1,47 @@
+using DotBased.Logging;
+using DotBased.Monads;
+using Manager.YouTube.Models.Innertube;
+
+namespace Manager.YouTube.Util.Cipher;
+
+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(ClientState clientState, YouTubeClient? client = null)
+    {
+        var relativePlayerJsUrl = clientState.PlayerJsUrl;
+        if (string.IsNullOrEmpty(relativePlayerJsUrl))
+        {
+            return ResultError.Fail("Could not get player js url.");
+        }
+        var version = GetCipherVersion(relativePlayerJsUrl);
+
+        Logger.Debug($"Getting cipher decoder for version: {version}");
+        if (LoadedCiphers.TryGetValue(version, out var cipher))
+        {
+            return cipher;
+        }
+        
+        try
+        {
+            var decoder = await CipherDecoder.CreateAsync(relativePlayerJsUrl, version, client);
+            LoadedCiphers.Add(decoder);
+        }
+        catch (Exception e)
+        {
+            Logger.Error(e, "Could not create cipher decoder. Version: {DecoderVersion}", version);
+        }
+        
+        return ResultError.Fail($"Could not create cipher decoder for {relativePlayerJsUrl} (v: {version})");
+    }
+
+    private static string GetCipherVersion(string relativePlayerUrl)
+    {
+        var split = relativePlayerUrl.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var v = split[2];
+        var lang = split[4];
+        return $"{v}_{lang}";
+    }
+}

Manager.YouTube/Util/Cipher/Operations/CipherReverse.cs

@@ -0,0 +1,18 @@
+using System.Text;
+
+namespace Manager.YouTube.Util.Cipher.Operations;
+
+public class CipherReverse : ICipherOperation
+{
+    public string Decipher(string cipherSignature)
+    {
+        var buffer = new StringBuilder(cipherSignature.Length);
+
+        for (var i = cipherSignature.Length - 1; i >= 0; i--)
+        {
+            buffer.Append(cipherSignature[i]);
+        }
+
+        return buffer.ToString();
+    }
+}

Manager.YouTube/Util/Cipher/Operations/CipherSlice.cs

@@ -0,0 +1,6 @@
+namespace Manager.YouTube.Util.Cipher.Operations;
+
+public class CipherSlice(int indexToSlice) : ICipherOperation
+{
+    public string Decipher(string cipherSignature) => cipherSignature[indexToSlice..];
+}

Manager.YouTube/Util/Cipher/Operations/CipherSwap.cs

@@ -0,0 +1,12 @@
+using System.Text;
+
+namespace Manager.YouTube.Util.Cipher.Operations;
+
+public class CipherSwap(int indexToSwap) : ICipherOperation
+{
+    public string Decipher(string cipherSignature) => new StringBuilder(cipherSignature)
+    {
+        [0] = cipherSignature[indexToSwap],
+        [indexToSwap] = cipherSignature[0]
+    }.ToString();
+}

Manager.YouTube/Util/Cipher/Operations/ICipherOperation.cs

@@ -0,0 +1,6 @@
+namespace Manager.YouTube.Util.Cipher.Operations;
+
+public interface ICipherOperation
+{
+    string Decipher(string cipherSignature);
+}

Manager.YouTube/Util/Converters/JsonUrlEscapeConverter.cs

@@ -0,0 +1,27 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
+
+namespace Manager.YouTube.Util.Converters;
+
+public partial class JsonUrlEscapeConverter : JsonConverter<string>
+{
+    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var url = reader.GetString();
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return url;
+        }
+
+        return UrlPatternRegex().IsMatch(url) ? Uri.UnescapeDataString(url) : url;
+    }
+
+    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value);
+    }
+
+    [GeneratedRegex("^(https?|ftp)://", RegexOptions.IgnoreCase | RegexOptions.Compiled, "nl-NL")]
+    private static partial Regex UrlPatternRegex();
+}

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

@@ -0,0 +1,121 @@
+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;
+using Manager.YouTube.Models.Innertube;
+using Manager.YouTube.Parsers.Json;
+
+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)
+    {
+        var node = JsonNode.Parse(ref reader);
+        if (node == null)
+        {
+            throw new SerializationException("Failed to parse JSON reader.");
+        }
+        
+        var rootObject = node.AsObject();
+        
+        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?["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?["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 = playerConfig
+        };
+        
+        return video;
+    }
+
+    public override void Write(Utf8JsonWriter writer, YouTubeVideo value, JsonSerializerOptions options)
+    {
+        throw new NotImplementedException("Converter only supports reading.");
+    }
+
+    private PlayerConfig? ExtractPlayerConfig(JsonNode? playerConfigNode)
+    {
+        if (playerConfigNode == null)
+        {
+            return null;
+        }
+
+        try
+        {
+            var playerConfigObj = playerConfigNode.AsObject();
+            var playerConfig = new PlayerConfig
+            {
+                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;
+        }
+        catch (Exception e)
+        {
+            _logger.Error(e, "Failed to extract player config from JSON.");
+            return null;
+        }
+    }
+}

Manager.YouTube/YouTubeClient.cs

@@ -3,7 +3,9 @@ using System.Net.Mime;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using DotBased.Logging;
 using DotBased.Monads;
+using Manager.YouTube.Models;
 using Manager.YouTube.Models.Innertube;
 using Manager.YouTube.Parsers;
 using Manager.YouTube.Parsers.Json;
@@ -13,40 +15,49 @@ 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; } = [];
     public Cookie? SapisidCookie => CookieContainer.GetAllCookies()["SAPISID"];
     public HttpClient HttpClient { get; }
     
-    private YouTubeClient(CookieCollection cookies, string userAgent)
+    private readonly ILogger _logger;
+    
+    private YouTubeClient(CookieCollection? cookies, string userAgent, ILogger logger)
     {
         if (string.IsNullOrWhiteSpace(userAgent))
         {
             throw new ArgumentNullException(nameof(userAgent));
         }
+        _logger = logger;
         UserAgent = userAgent;
-        if (cookies.Count == 0)
+        if (cookies == null || cookies.Count == 0)
         {
             Id = $"anon_{Guid.NewGuid()}";
             IsAnonymous = true;
         }
-
+        else
+        {
             CookieContainer.Add(cookies);
+        }
+        
         HttpClient = new HttpClient(GetHttpClientHandler());
     }
 
     /// <summary>
     /// Loads the given cookies and fetch client state.
     /// </summary>
-    /// <param name="cookies">The cookies to use for making requests. Empty collection for anonymous requests.</param>
+    /// <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, null will create a new logger.</param>
     /// <returns></returns>
-    public static async Task<Result<YouTubeClient>> CreateAsync(CookieCollection cookies, string userAgent)
+    public static async Task<Result<YouTubeClient>> CreateAsync(CookieCollection? cookies, string userAgent, ILogger? logger = null)
     {
-        var client = new YouTubeClient(cookies, userAgent);
+        logger ??= LogService.RegisterLogger<YouTubeClient>();
+        
+        var client = new YouTubeClient(cookies, userAgent, logger);
         var clientInitializeResult = await client.FetchClientDataAsync();
         if (!clientInitializeResult.IsSuccess)
         {
@@ -56,99 +67,58 @@ 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 request = new HttpRequestMessage(HttpMethod.Get, new Uri($"{NetworkService.Origin}/watch?v={videoId}"));
+        
+        var videoResponse = await NetworkService.MakeRequestAsync(request, this, true, cancellationToken);
+        if (!videoResponse.IsSuccess && !string.IsNullOrWhiteSpace(videoResponse.Value))
         {
-            var datasyncResult = await GetDatasyncIds();
-            if (!datasyncResult.IsSuccess)
-            {
-                return datasyncResult;
+            return videoResponse.Error ?? ResultError.Fail("Request failed!");
         }
 
-            foreach (var id in datasyncResult.Value)
+        var html = videoResponse.Value;
+        
+        var stateResult = GetClientStateFromHtml(html);
+        var state = stateResult.Value;
+        if (!stateResult.IsSuccess && State != null)
         {
-                if (DatasyncIds.Contains(id))
-                    continue;
-                DatasyncIds.Add(id);
-            }
+            state = State;
         }
         
-        if (string.IsNullOrWhiteSpace(Id))
+        var htmlParseResult = HtmlParser.GetVideoDataFromHtml(html);
+        if (!htmlParseResult.IsSuccess)
         {
-            var accountInfoResult = await GetCurrentAccountIdAsync();
-            if (!accountInfoResult.IsSuccess)
+            return htmlParseResult.Error ?? ResultError.Fail("Failed to parse HTML video data!");
+        }
+        
+        var videoParseResult = VideoJsonParser.ParseVideoData(htmlParseResult.Value);
+        if (!videoParseResult.IsSuccess)
         {
-                return accountInfoResult;
+            return videoParseResult;
         }
         
-            Id = accountInfoResult.Value;
+        //await DecipherSignaturesAsync(videoParseResult.Value, state);
+
+        return videoParseResult.Value;
     }
     
-        return Result.Success();
-    }
-    
-    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 clientStateResult = HtmlParser.GetStateJson(result.Value);
-        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();
-    }
-    
-    public async Task<Result<Channel>> GetChannelByIdAsync(string channelId)
+    public async Task<Result<InnertubeChannel>> GetChannelByIdAsync(string channelId)
     {
         if (State == null)
         {
@@ -202,11 +172,164 @@ public sealed class YouTubeClient : IDisposable
         return tempDatasyncId;
     }
 
+    public async Task<Result> RotateCookiesPageAsync(string origin = NetworkService.Origin, int ytPid = 1)
+    {
+        if (IsAnonymous)
+        {
+            return ResultError.Fail("Anonymous clients cannot rotate cookies!");
+        }
+
+        if (string.IsNullOrWhiteSpace(origin))
+        {
+            return ResultError.Fail("Origin is empty!");
+        }
+
+        var rotatePageCookiesRequest = new HttpRequestMessage(HttpMethod.Get, new Uri($"https://accounts.youtube.com/RotateCookiesPage?origin={origin}&yt_pid={ytPid}"));
+        return await NetworkService.MakeRequestAsync(rotatePageCookiesRequest, this, true);
+    }
+
+    public async Task<Result> RotateCookiesAsync()
+    {
+        if (IsAnonymous)
+        {
+            return ResultError.Fail("Anonymous clients cannot rotate cookies!");
+        }
+        
+        var rotateRequest = new HttpRequestMessage(HttpMethod.Post, new Uri("https://accounts.youtube.com/RotateCookies"));
+        return await NetworkService.MakeRequestAsync(rotateRequest, this, true);
+    }
+    
     public void Dispose()
     {
         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 })
@@ -232,7 +355,7 @@ public sealed class YouTubeClient : IDisposable
         return JsonAccountParser.ParseAccountId(responseResult.Value);
     }
     
-    private async Task<Result<string[]>> GetDatasyncIds()
+    private async Task<Result<string[]>> GetDatasyncIdsAsync()
     {
         if (State is not { LoggedIn: true } || CookieContainer.Count == 0)
         {
@@ -261,4 +384,49 @@ public sealed class YouTubeClient : IDisposable
 
         return ResultError.Fail("Failed to get datasyncIds! Client not logged in.");
     }
+
+    /*private async Task DecipherSignaturesAsync(YouTubeVideo video, ClientState state)
+    {
+        var streamingData = video.StreamingData;
+        if (streamingData == null)
+        {
+            _logger.Debug("No streaming data available, skipping decipher.");
+            return;
+        }
+        
+        if (string.IsNullOrWhiteSpace(state.PlayerJsUrl))
+        {
+            _logger.Warning("No player js url found.");
+        }
+
+        var formatsWithCipher = streamingData.Formats.Concat(streamingData.AdaptiveFormats).Where(x => !string.IsNullOrWhiteSpace(x.SignatureCipher)).ToList();
+        if (formatsWithCipher.Count == 0)
+        {
+            _logger.Debug("Skipping signature decipher, no signatures found to decipher.");
+        }
+
+        if (string.IsNullOrWhiteSpace(streamingData.ServerAbrStreamingUrl))
+        {
+            _logger.Warning("No ABR streaming url available.");
+        }
+
+        var abrStreamUri = new Uri(streamingData.ServerAbrStreamingUrl);
+        var queries = HttpUtility.ParseQueryString(abrStreamUri.Query);
+        var nSig = queries.Get("n");
+
+        if (string.IsNullOrWhiteSpace(nSig))
+        {
+            _logger.Warning("No N signature found.");
+        }
+        
+        /*var jsEngineResult = await JavaScriptEngineManager.GetPlayerEngine(state.PlayerJsUrl ?? "");
+        if (!jsEngineResult.IsSuccess)
+        {
+            _logger.Warning(jsEngineResult.Error?.Description ?? "Failed to get player script engine.");
+            return;
+        }
+
+        var engine = jsEngineResult.Value;
+        engine.InitializePlayer();#1#
+    }*/
 }

Manager.YouTube/YouTubeClientCollection.cs

@@ -0,0 +1,24 @@
+using System.Collections.ObjectModel;
+
+namespace Manager.YouTube;
+
+public class YouTubeClientCollection : KeyedCollection<string, YouTubeClient>
+{
+    protected override string GetKeyForItem(YouTubeClient item)
+    {
+        return item.Id;
+    }
+
+    public new void Add(YouTubeClient client)
+    {
+        if (Items.Contains(client))
+        {
+            var index = Items.IndexOf(client);
+            Items[index] = client;
+        }
+        else
+        {
+            Items.Add(client);
+        }
+    }
+}