YouTube-Manager/Manager.App/Services/LibraryService.cs

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.Models.Innertube;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;

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, CacheService cacheService)
    {
        _logger = logger;
        _librarySettings = librarySettings.Value;
        _dbContextFactory = contextFactory;
        _cacheService = cacheService;
        _libraryDirectory = Directory.CreateDirectory(_librarySettings.Path);
        logger.LogDebug("Library directory: {LibraryWorkingDir}", _libraryDirectory.FullName);
        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirMedia));
        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirChannels));
    }
    
    public async Task<Result> FetchChannelImagesAsync(InnertubeChannel innertubeChannel)
    {
        try
        {
            await using var context = await _dbContextFactory.CreateDbContextAsync();
            
            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);

            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();
    }

    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)))
            {
                continue;
            }

            var cacheResult = await _cacheService.CacheFromUrl(image.Url);
            if (!cacheResult.IsSuccess)
            {
                _logger.LogWarning("Failed to get image {ImageUrl}", image.Url);
                continue;
            }

            var cachedFile = cacheResult.Value;
            
            var fileId = Guid.NewGuid();
            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(cachedFile.Data.AsMemory(0, cachedFile.Data.Length));
            
            var file = new FileEntity
            {
                Id = fileId,
                OriginalUrl = image.Url,
                OriginalFileName = cachedFile.OriginalFileName,
                ForeignKey = foreignKey,
                FileType = fileType,
                RelativePath = relativePath.Replace('\\', '/'),
                MimeType = cachedFile.ContentType,
                SizeBytes = cachedFile.Data.Length,
                Height = image.Height,
                Width = image.Width
            };
            
            await context.Files.AddAsync(file);
        }
    }

    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.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.ClientAccounts.Add(dbClient);
            }

            var savedResult= await context.SaveChangesAsync(cancellationToken);
            return savedResult <= 0 ? ResultError.Fail("Could not save changes!") : Result.Success();
        }
        catch (Exception e)
        {
            return ResultError.Error(e);
        }
    }

    public async Task<Result<ChannelEntity>> GetChannelByIdAsync(string id, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(id))
        {
            return ResultError.Fail("Channel id cannot be null or empty!");
        }

        try
        {
            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
            var channel = await context.Channels
                .Include(c => c.ClientAccount)
                .ThenInclude(p => p!.HttpCookies)
                .FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
            
            if (channel == null)
            {
                return ResultError.Fail("Channel not found!");
            }

            return channel;
        }
        catch (Exception e)
        {
            return HandleException(e);
        }
    }

    public async Task<Result> SaveChannelAsync(InnertubeChannel innertubeChannel, CancellationToken cancellationToken = default)
    {
        try
        {
            var imagesResult = await FetchChannelImagesAsync(innertubeChannel);
            if (!imagesResult.IsSuccess)
            {
                return ResultError.Fail("Failed to fetch channel images!");
            }
            
            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
            
            var channelResult = await GetChannelByIdAsync(innertubeChannel.Id, cancellationToken);

            ChannelEntity? channelEntity;
            try
            {
                if (channelResult.IsSuccess)
                {
                    channelEntity = channelResult.Value;
                    channelEntity.Name = innertubeChannel.ChannelName;
                    channelEntity.Handle = innertubeChannel.Handle;
                    channelEntity.Description = innertubeChannel.Description;
                }
                else
                {
                    channelEntity = new ChannelEntity
                    {
                        Id = innertubeChannel.Id,
                        Name = innertubeChannel.ChannelName,
                        Handle = innertubeChannel.Handle,
                        Description = innertubeChannel.Description
                    };
                }
            }
            catch (Exception e)
            {
                return ResultError.Error(e);
            }
            
            if (context.Channels.Any(c => c.Id == innertubeChannel.Id))
            {
                context.Channels.Update(channelEntity);
            }
            else
            {
                context.Channels.Add(channelEntity);
            }
            
            var changed = await context.SaveChangesAsync(cancellationToken);
            return changed <= 0 ? ResultError.Fail("Failed to save channel!") : Result.Success();
        }
        catch (Exception e)
        {
            return HandleException(e);
        }
    }

    public async Task<Result<LibraryInformation>> GetLibraryInfoAsync(CancellationToken cancellationToken = default)
    {
        try
        {
            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
            var libInfo = new LibraryInformation
            {
                LibraryPath = _libraryDirectory.FullName,
                CreatedAtUtc = _libraryDirectory.CreationTimeUtc,
                LastModifiedUtc = _libraryDirectory.LastWriteTimeUtc,
                TotalChannels = await context.Channels.CountAsync(cancellationToken: cancellationToken),
                TotalMedia = await context.Media.CountAsync(cancellationToken: cancellationToken),
                TotalSizeBytes = GetDirectorySize(_libraryDirectory)
            };
            return libInfo;
        }
        catch (Exception e)
        {
            return HandleException(e);
        }
    }

    public async Task<ListResult<ChannelEntity>> GetChannelsAsync(int total = 20, int offset = 0, CancellationToken cancellationToken = default)
    {
        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());
        }
        catch (Exception e)
        {
            return HandleException(e);
        }
    }

    private long GetDirectorySize(DirectoryInfo dir)
    {
        try
        {
            var size = dir.EnumerateFiles("*", SearchOption.AllDirectories).Select(f => f.Length).Sum();
            return size;
        }
        catch (Exception e)
        {
            _logger.LogError(e, "Error while getting directory size.");
            throw;
        }
    }

    private ResultError HandleException(Exception exception)
    {
        if (exception is OperationCanceledException)
        {
            return ResultError.Fail("Library service operation cancelled");
        }

        _logger.LogError(exception, "Failed to get library information");
        return ResultError.Fail("Failed to get library information");
    }
}