From 31a02776a1cf695350ea60cd391332ab72129a8a Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Fri, 7 Apr 2023 09:58:28 +0200
Subject: [PATCH 01/22] local video provider EVI-43

---
 .../Models/Domain/LocalVideoMetadata.cs       |  27 ++++
 .../LocalVideoDtos/ArchiveLocalVideoDto.cs    |  11 ++
 src/EthernaVideoImporter/Program.cs           |  24 +++
 .../Services/LocalVideoProvider.cs            | 151 ++++++++++++++++++
 src/EthernaVideoImporter/SourceType.cs        |   3 +-
 5 files changed, 215 insertions(+), 1 deletion(-)
 create mode 100644 src/EthernaVideoImporter/Models/Domain/LocalVideoMetadata.cs
 create mode 100644 src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs
 create mode 100644 src/EthernaVideoImporter/Services/LocalVideoProvider.cs

diff --git a/src/EthernaVideoImporter/Models/Domain/LocalVideoMetadata.cs b/src/EthernaVideoImporter/Models/Domain/LocalVideoMetadata.cs
new file mode 100644
index 0000000..243fcd4
--- /dev/null
+++ b/src/EthernaVideoImporter/Models/Domain/LocalVideoMetadata.cs
@@ -0,0 +1,27 @@
+using Etherna.VideoImporter.Core.Models.Domain;
+using System;
+
+namespace Etherna.VideoImporter.Models.Domain
+{
+    internal sealed class LocalVideoMetadata : VideoMetadataBase
+    {
+        // Constructors.
+        internal LocalVideoMetadata(
+            string description,
+            TimeSpan duration,
+            string originVideoQualityLabel,
+            ThumbnailLocalFile? thumbnail,
+            string title,
+            string filePathVideo)
+            : base(description, duration, originVideoQualityLabel, title)
+        {
+            FilePath = filePathVideo;
+            Thumbnail = thumbnail;
+        }
+
+        // Properties.
+        public override string Id => FilePath;
+        public string FilePath { get; }
+        public ThumbnailLocalFile? Thumbnail { get; }
+    }
+}
diff --git a/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs b/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs
new file mode 100644
index 0000000..7910311
--- /dev/null
+++ b/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs
@@ -0,0 +1,11 @@
+namespace Etherna.VideoImporter.Models.LocalVideoDto
+{
+    internal sealed class ArchiveLocalVideoDto
+    {
+        // Properties.
+        public string Description { get; set; } = default!;
+        public string Title { get; set; } = default!;
+        public string? Thumbnail { get; set; }
+        public string Video { get; set; } = default!;
+    }
+}
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index bf81878..1738989 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -41,6 +41,7 @@ internal static class Program
             "Source types:\n" +
             "  ytchannel\tYouTube channel\n" +
             "  ytvideo\tYouTube video\n" +
+            "  localvideo\tLocal video\n" +
             "\n" +
             "Options:\n" +
             $"  -ff\tPath FFmpeg (default dir: {DefaultFFmpegFolder})\n" +
@@ -127,6 +128,16 @@ static async Task Main(string[] args)
                     sourceUri = args[1];
                     break;
 
+                case "localvideo":
+                    if (args.Length < 2)
+                    {
+                        Console.WriteLine("Local Video path is missing");
+                        throw new ArgumentException("Invalid argument");
+                    }
+                    sourceType = SourceType.LocalVideo;
+                    sourceUri = args[1];
+                    break;
+
                 default:
                     Console.WriteLine($"Invalid argument");
                     Console.WriteLine(HelpText);
@@ -213,6 +224,14 @@ static async Task Main(string[] args)
                 return;
             }
 
+            //check local video input
+            if (sourceType == SourceType.LocalVideo &&
+                !File.Exists(sourceUri))
+            {
+                Console.WriteLine($"Local video not found at ({sourceUri})");
+                return;
+            }
+
             //bee node api port
             if (!string.IsNullOrEmpty(beeNodeApiPortStr) &&
                 !int.TryParse(beeNodeApiPortStr, CultureInfo.InvariantCulture, out beeNodeApiPort))
@@ -301,6 +320,11 @@ static async Task Main(string[] args)
                     encoderService,
                     includeAudioTrack,
                     GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360)),
+                SourceType.LocalVideo => new LocalVideoProvider(
+                    sourceUri,
+                    encoderService,
+                    includeAudioTrack,
+                    GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360)),
                 _ => throw new InvalidOperationException()
             };
 
diff --git a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
new file mode 100644
index 0000000..d942e34
--- /dev/null
+++ b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
@@ -0,0 +1,151 @@
+using Etherna.VideoImporter.Core.Models.Domain;
+using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Models.Domain;
+using Etherna.VideoImporter.Models.LocalVideoDto;
+using SkiaSharp;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Etherna.VideoImporter.Services
+{
+    public sealed class LocalVideoProvider : IVideoProvider
+    {
+        // Fields.
+        private readonly string localFile;
+        private readonly IEncoderService encoderService;
+        private readonly bool includeAudioTrack;
+        private readonly IEnumerable<int> supportedHeightResolutions;
+
+        // Constructor.
+        public LocalVideoProvider(
+            string localFile,
+            IEncoderService encoderService,
+            bool includeAudioTrack,
+            IEnumerable<int> supportedHeightResolutions)
+        {
+            this.localFile = localFile;
+            this.encoderService = encoderService;
+            this.includeAudioTrack = includeAudioTrack;
+            this.supportedHeightResolutions = supportedHeightResolutions;
+        }
+
+        // Properties.
+        public string SourceName => localFile;
+
+        // Methods.
+        public async Task<Video> GetVideoAsync(
+            VideoMetadataBase videoMetadata,
+            DirectoryInfo tempDirectory)
+        {
+            if (tempDirectory is null)
+                throw new ArgumentNullException(nameof(tempDirectory));
+
+            var localVideoMetadata = videoMetadata as LocalVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(LocalVideoMetadata)}", nameof(videoMetadata));
+
+            // Video info.
+            var videoHeight = 0;
+            var videoWidth = 0;
+            var byteSizeVideo = 0;
+            var videoLocalFile = new VideoLocalFile(localVideoMetadata.FilePath, videoHeight, videoWidth, byteSizeVideo);
+
+            // Transcode video resolutions.
+            var encodedFiles = await encoderService.EncodeVideosAsync(videoLocalFile, tempDirectory, supportedHeightResolutions, includeAudioTrack);
+
+            // Get thumbnail.
+            List<ThumbnailLocalFile> thumbnailFiles = new();
+            if (localVideoMetadata.Thumbnail is not null)
+            {
+                thumbnailFiles = await DownscaleThumbnailAsync(localVideoMetadata.Thumbnail, tempDirectory);
+            }
+            return new Video(videoMetadata, encodedFiles, thumbnailFiles);
+        }
+
+        public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
+        {
+            var localVideos = JsonSerializer.Deserialize<List<ArchiveLocalVideoDto>>(localFile) ?? throw new InvalidDataException($"LocalFile wrong format in {localFile}");
+
+            var videosMetadata = new List<VideoMetadataBase>();
+            foreach (var video in localVideos)
+            {
+                try
+                {
+                    // Thumbnail info.
+                    ThumbnailLocalFile? thumbnail = null;
+                    if (!string.IsNullOrWhiteSpace(video.Thumbnail))
+                    {
+                        using var thumbFileStream = File.OpenRead(video.Thumbnail);
+                        using var thumbManagedStream = new SKManagedStream(thumbFileStream);
+                        using var thumbBitmap = SKBitmap.Decode(thumbManagedStream);
+                        thumbnail = new ThumbnailLocalFile(video.Thumbnail, thumbBitmap.ByteCount, thumbBitmap.Height, thumbBitmap.Width);
+                        await thumbFileStream.DisposeAsync();
+                    }
+
+                    // Video info.
+                    var duration = new TimeSpan(1);
+                    var videoQualityLabel = "1080p";
+                    // quando audio è null controllare che il video contenga anche l'audio
+
+                    videosMetadata.Add(new LocalVideoMetadata(
+                        video.Description,
+                        duration,
+                        videoQualityLabel,
+                        thumbnail,
+                        video.Title,
+                        video.Video));
+
+                    Console.WriteLine($"Downloaded metadata for {video.Title}");
+                }
+                catch (HttpRequestException ex)
+                {
+                    Console.ForegroundColor = ConsoleColor.DarkRed;
+                    Console.WriteLine($"Error retrieving video: {video.Title}.");
+                    Console.WriteLine(ex.Message);
+                    Console.ResetColor();
+                }
+            }
+
+            Console.WriteLine($"Found {videosMetadata.Count} videos");
+
+            return videosMetadata;
+        }
+
+        // Helpers.
+        private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
+                ThumbnailLocalFile betsResolutionThumbnail,
+                DirectoryInfo importerTempDirectoryInfo)
+        {
+            List<ThumbnailLocalFile> thumbnails = new();
+
+            using var thumbFileStream = File.OpenRead(betsResolutionThumbnail.FilePath);
+            using var thumbManagedStream = new SKManagedStream(thumbFileStream);
+            using var thumbBitmap = SKBitmap.Decode(thumbManagedStream);
+
+            foreach (var responsiveWidthSize in ThumbnailLocalFile.ThumbnailResponsiveSizes)
+            {
+                var responsiveHeightSize = (int)(responsiveWidthSize / betsResolutionThumbnail.AspectRatio);
+
+                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.High);
+                using SKImage scaledImage = SKImage.FromBitmap(scaledBitmap);
+                using SKData data = scaledImage.Encode();
+
+                var thumbnailResizedPath = Path.Combine(importerTempDirectoryInfo.FullName, $"thumb_{responsiveWidthSize}_{responsiveHeightSize}_{Guid.NewGuid()}.jpg");
+                using FileStream outputFileStream = new(thumbnailResizedPath, FileMode.CreateNew);
+                await data.AsStream().CopyToAsync(outputFileStream);
+
+                thumbnails.Add(new ThumbnailLocalFile(
+                    thumbnailResizedPath,
+                    new FileInfo(thumbnailResizedPath).Length,
+                    responsiveHeightSize,
+                    responsiveWidthSize));
+            }
+
+            return thumbnails;
+        }
+    }
+}
diff --git a/src/EthernaVideoImporter/SourceType.cs b/src/EthernaVideoImporter/SourceType.cs
index 23c6859..8db555d 100644
--- a/src/EthernaVideoImporter/SourceType.cs
+++ b/src/EthernaVideoImporter/SourceType.cs
@@ -17,6 +17,7 @@ namespace Etherna.VideoImporter
     enum SourceType
     {
         YouTubeChannel,
-        YouTubeVideo
+        YouTubeVideo,
+        LocalVideo
     }
 }

From 0d07d776ec78d479f41dc02a835786cbdcbe3732 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Fri, 7 Apr 2023 18:07:11 +0200
Subject: [PATCH 02/22] SKFilterQuality to medium

---
 src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs | 2 +-
 src/EthernaVideoImporter/Services/LocalVideoProvider.cs      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 58f33d1..93eda44 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -203,7 +203,7 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
             {
                 var responsiveHeightSize = (int)(responsiveWidthSize / betsResolutionThumbnail.AspectRatio);
 
-                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.High);
+                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.Medium);
                 using SKImage scaledImage = SKImage.FromBitmap(scaledBitmap);
                 using SKData data = scaledImage.Encode();
 
diff --git a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
index d942e34..d26b35c 100644
--- a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
@@ -130,7 +130,7 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
             {
                 var responsiveHeightSize = (int)(responsiveWidthSize / betsResolutionThumbnail.AspectRatio);
 
-                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.High);
+                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.Medium);
                 using SKImage scaledImage = SKImage.FromBitmap(scaledBitmap);
                 using SKData data = scaledImage.Encode();
 

From 7448a38bb19e3a8d2c1f9035834b245ed1ca80d2 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 12:43:10 +0200
Subject: [PATCH 03/22] Dependency injection

---
 .../EthernaVideoImporter.cs                   |  50 +++----
 .../Extensions/ServiceCollectionExtensions.cs |  84 +++++++++++
 .../ImporterSettings.cs                       |  27 ++++
 .../Services/CleanerVideoService.cs           |   9 +-
 .../Services/EncoderService.cs                |  12 +-
 .../Services/EthernaGatewayService.cs         |  21 +--
 .../Services/VideoUploaderService.cs          |  35 +++--
 .../Utilities/IYoutubeDownloader.cs           |   3 +-
 .../Utilities/YoutubeDownloader.cs            |  26 +++-
 src/EthernaVideoImporter.Devcon/Program.cs    | 122 ++++++----------
 .../Services/DevconLinkReporterService.cs     |  12 +-
 .../Services/MdVideoProvider.cs               |  30 ++--
 src/EthernaVideoImporter/Program.cs           | 133 ++++++------------
 .../Services/YouTubeChannelVideoProvider.cs   |  28 ++--
 .../Services/YouTubeSingleVideoProvider.cs    |  28 ++--
 15 files changed, 335 insertions(+), 285 deletions(-)
 create mode 100644 src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
 create mode 100644 src/EthernaVideoImporter.Core/ImporterSettings.cs

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 1a70b5e..9d6aa75 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -12,12 +12,14 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Etherna.ServicesClient;
 using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Models.Index;
 using Etherna.VideoImporter.Core.Models.ManifestDtos;
 using Etherna.VideoImporter.Core.Models.ModelView;
 using Etherna.VideoImporter.Core.Services;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
@@ -32,7 +34,8 @@ public class EthernaVideoImporter
         // Fields.
         private readonly ICleanerVideoService cleanerVideoService;
         private readonly IGatewayService gatewayClient;
-        private readonly IUserIndexClient ethernaIndexClient;
+        private readonly IEthernaUserClients ethernaUserClients;
+        private readonly ImporterSettings importerSettings;
         private readonly ILinkReporterService linkReporterService;
         private readonly IMigrationService migrationService;
         private readonly DirectoryInfo tempDirectoryInfo;
@@ -43,11 +46,12 @@ public class EthernaVideoImporter
         public EthernaVideoImporter(
             ICleanerVideoService cleanerVideoService,
             IGatewayService gatewayClient,
-            IUserIndexClient ethernaIndexClient,
+            IEthernaUserClients ethernaUserClients,
             ILinkReporterService linkReporterService,
             IVideoProvider videoProvider,
             IVideoUploaderService videoUploaderService,
-            IMigrationService migrationService)
+            IMigrationService migrationService,
+            IOptions<ImporterSettings> importerSettingsOption)
         {
             if (cleanerVideoService is null)
                 throw new ArgumentNullException(nameof(cleanerVideoService));
@@ -57,10 +61,13 @@ public EthernaVideoImporter(
                 throw new ArgumentNullException(nameof(videoProvider));
             if (videoUploaderService is null)
                 throw new ArgumentNullException(nameof(videoUploaderService));
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
 
             this.cleanerVideoService = cleanerVideoService;
             this.gatewayClient = gatewayClient;
-            this.ethernaIndexClient = ethernaIndexClient;
+            this.ethernaUserClients = ethernaUserClients;
+            this.importerSettings = importerSettingsOption.Value;
             this.linkReporterService = linkReporterService;
             this.migrationService = migrationService;
             tempDirectoryInfo = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier));
@@ -69,14 +76,7 @@ public EthernaVideoImporter(
         }
 
         // Public methods.
-        public async Task RunAsync(
-            string userEthAddress,
-            bool offerVideos,
-            bool pinVideos,
-            bool deleteVideosRemovedFromSource,
-            bool deleteExogenousVideos,
-            bool unpinRemovedVideos,
-            bool forceUploadVideo)
+        public async Task RunAsync()
         {
             var importSummaryModelView = new ImportSummaryModelView();
 
@@ -91,8 +91,8 @@ public async Task RunAsync(
             // Get information from etherna index.
             Console.WriteLine("Get user's videos on etherna index");
 
-            var userVideosOnIndex = await GetUserVideosOnEthernaAsync(userEthAddress);
-            var ethernaIndexParameters = await ethernaIndexClient.SystemClient.ParametersAsync();
+            var userVideosOnIndex = await GetUserVideosOnEthernaAsync(importerSettings.UserEthAddr);
+            var ethernaIndexParameters = await ethernaUserClients.IndexClient.SystemClient.ParametersAsync();
 
             Console.WriteLine($"Found {userVideosOnIndex.Count()} videos already published on etherna index");
 
@@ -120,7 +120,7 @@ public async Task RunAsync(
 
                     //try to update only manifest, or to skip if possible
                     if (alreadyPresentVideo is not null &&
-                        !forceUploadVideo &&
+                        !importerSettings.ForceUploadVideo &&
                         minRequiredMigrationOp is OperationType.Skip or OperationType.UpdateManifest)
                     {
                         Console.WriteLine("Video already uploaded on etherna");
@@ -164,11 +164,11 @@ public async Task RunAsync(
                             var video = new Video(videoMetadata, videoSwarmFile, thumbnailFiles);
 
                             // Upload new manifest.
-                            var metadataVideo = new ManifestDto(video, alreadyPresentVideo.LastValidManifest.BatchId, userEthAddress);
-                            updatedPermalinkHash = await videoUploaderService.UploadVideoManifestAsync(metadataVideo, pinVideos, offerVideos);
+                            var metadataVideo = new ManifestDto(video, alreadyPresentVideo.LastValidManifest.BatchId, importerSettings.UserEthAddr);
+                            updatedPermalinkHash = await videoUploaderService.UploadVideoManifestAsync(metadataVideo, importerSettings.PinVideos, importerSettings.OfferVideos);
 
                             // Update on index.
-                            await ethernaIndexClient.VideosClient.VideosPutAsync(
+                            await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
                                 alreadyPresentVideo.IndexId,
                                 updatedPermalinkHash);
                         }
@@ -208,7 +208,7 @@ await ethernaIndexClient.VideosClient.VideosPutAsync(
                         }
 
                         // Upload video and all related data.
-                        await videoUploaderService.UploadVideoAsync(video, pinVideos, offerVideos);
+                        await videoUploaderService.UploadVideoAsync(video, importerSettings.PinVideos, importerSettings.OfferVideos);
 
                         updatedIndexId = video.EthernaIndexId!;
                         updatedPermalinkHash = video.EthernaPermalinkHash!;
@@ -287,21 +287,21 @@ await linkReporterService.SetEthernaReferencesAsync(
 
             // Clean up user channel on etherna index.
             IEnumerable<string>? gatewayPinnedHashes = null;
-            if (unpinRemovedVideos)
+            if (importerSettings.UnpinRemovedVideos)
                 gatewayPinnedHashes = await gatewayClient.GetPinnedResourcesAsync();
 
-            if (deleteVideosRemovedFromSource)
+            if (importerSettings.DeleteVideosMissingFromSource)
                 importSummaryModelView.TotDeletedRemovedFromSource = await cleanerVideoService.DeleteVideosRemovedFromSourceAsync(
                     sourceVideosMetadata,
                     userVideosOnIndex,
                     gatewayPinnedHashes,
-                    unpinRemovedVideos);
+                    importerSettings.UnpinRemovedVideos);
 
-            if (deleteExogenousVideos)
+            if (importerSettings.DeleteExogenousVideos)
                 importSummaryModelView.TotDeletedExogenous = await cleanerVideoService.DeleteExogenousVideosAsync(
                     userVideosOnIndex,
                     gatewayPinnedHashes,
-                    unpinRemovedVideos);
+                    importerSettings.UnpinRemovedVideos);
 
             // Print summary.
             Console.ForegroundColor = ConsoleColor.DarkGreen;
@@ -326,7 +326,7 @@ public async Task<IEnumerable<IndexedVideo>> GetUserVideosOnEthernaAsync(string
             VideoDtoPaginatedEnumerableDto? page = null;
             do
             {
-                page = await ethernaIndexClient.UsersClient.Videos2Async(userAddress, page is null ? 0 : page.CurrentPage + 1, MaxForPage);
+                page = await ethernaUserClients.IndexClient.UsersClient.Videos2Async(userAddress, page is null ? 0 : page.CurrentPage + 1, MaxForPage);
                 videos.AddRange(page.Elements);
             } while (page.Elements.Any());
 
diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
new file mode 100644
index 0000000..05bde67
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -0,0 +1,84 @@
+using Etherna.BeeNet;
+using Etherna.ServicesClient;
+using Etherna.ServicesClient.Clients.Index;
+using Etherna.VideoImporter.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Net.Http;
+
+namespace Etherna.VideoImporter.Core.Extensions
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddImportSettings(
+            this IServiceCollection services,
+            bool acceptPurchaseOfAllBatches,
+            bool deleteExogenousVideos,
+            bool deleteVideosMissingFromSource,
+            string ffMpegBinaryPath,
+            string ffMpegFolderPath,
+            bool forceUploadVideo,
+            bool ignoreNewVersionsOfImporter,
+            bool includeAudioTrack,
+            bool offerVideos,
+            bool pinVideos,
+            string sourceUri,
+            bool skip1440,
+            bool skip1080,
+            bool skip720,
+            bool skip480,
+            bool skip360,
+            int ttlPostageStamp,
+            bool unpinRemovedVideos,
+            string userEthAddr)
+        {
+            return services.Configure<ImporterSettings>(options =>
+            {
+                options.AcceptPurchaseOfAllBatches = acceptPurchaseOfAllBatches;
+                options.DeleteExogenousVideos = deleteExogenousVideos;
+                options.DeleteVideosMissingFromSource = deleteVideosMissingFromSource;
+                options.FFMpegBinaryPath = ffMpegBinaryPath;
+                options.FFMpegFolderPath = ffMpegFolderPath;
+                options.ForceUploadVideo = forceUploadVideo;
+                options.IgnoreNewVersionsOfImporter = ignoreNewVersionsOfImporter;
+                options.IncludeAudioTrack = includeAudioTrack;
+                options.OfferVideos = offerVideos;
+                options.PinVideos = pinVideos;
+                options.SourceUri = sourceUri;
+                options.Skip1440 = skip1440;
+                options.Skip1080 = skip1080;
+                options.Skip720 = skip720;
+                options.Skip480 = skip480;
+                options.Skip360 = skip360;
+                options.TTLPostageStamp = TimeSpan.FromSeconds(ttlPostageStamp);
+                options.UnpinRemovedVideos = unpinRemovedVideos;
+                options.UserEthAddr = userEthAddr;
+            });
+        }
+
+        public static IServiceCollection AddCommonServices(this IServiceCollection services, bool useBeeNativeNode)
+        {
+            services
+            .AddTransient<EthernaVideoImporter>()
+            .AddTransient<IBeeNodeClient, BeeNodeClient>()
+            .AddTransient<ICleanerVideoService, CleanerVideoService>()
+            .AddTransient<IEthernaUserClients, EthernaUserClients>()
+            //.AddTransient<IUserIndexClient, EthernaUserClients>()
+            .AddTransient<IVideoUploaderService, VideoUploaderService>();
+
+            return useBeeNativeNode ?
+                services.AddTransient<IGatewayService, BeeGatewayService>() :
+                services.AddTransient<IGatewayService, EthernaGatewayService>();
+        }
+
+        public static IHttpClientBuilder ConfigureHttpClient(this IServiceCollection services, DelegatingHandler delegatingHandler)
+        {
+            return services.AddHttpClient("ethernaClient", c =>
+            {
+                c.Timeout = TimeSpan.FromMinutes(30);
+                c.DefaultRequestHeaders.ConnectionClose = true; //fixes https://etherna.atlassian.net/browse/EVI-74
+            })
+            .ConfigurePrimaryHttpMessageHandler(() => delegatingHandler);
+        }
+    }
+}
diff --git a/src/EthernaVideoImporter.Core/ImporterSettings.cs b/src/EthernaVideoImporter.Core/ImporterSettings.cs
new file mode 100644
index 0000000..ac89586
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/ImporterSettings.cs
@@ -0,0 +1,27 @@
+using System;
+
+namespace Etherna.VideoImporter.Core
+{
+    public class ImporterSettings
+    {
+        public bool AcceptPurchaseOfAllBatches { get; set; }
+        public bool DeleteExogenousVideos { get; set; }
+        public bool DeleteVideosMissingFromSource { get; set; }
+        public string FFMpegBinaryPath { get; set; } = default!;
+        public string FFMpegFolderPath { get; set; } = default!;
+        public bool ForceUploadVideo { get; set; }
+        public bool IgnoreNewVersionsOfImporter { get; set; }
+        public bool IncludeAudioTrack { get; set; }
+        public bool OfferVideos { get; set; }
+        public bool PinVideos { get; set; }
+        public string SourceUri { get; set; } = default!;
+        public bool Skip360 { get; set; }
+        public bool Skip480 { get; set; }
+        public bool Skip720 { get; set; }
+        public bool Skip1080 { get; set; }
+        public bool Skip1440 { get; set; }
+        public TimeSpan TTLPostageStamp { get; set; }
+        public bool UnpinRemovedVideos { get; set; }
+        public string UserEthAddr { get; set; } = default!;
+    }
+}
diff --git a/src/EthernaVideoImporter.Core/Services/CleanerVideoService.cs b/src/EthernaVideoImporter.Core/Services/CleanerVideoService.cs
index c7baa32..a7e9f06 100644
--- a/src/EthernaVideoImporter.Core/Services/CleanerVideoService.cs
+++ b/src/EthernaVideoImporter.Core/Services/CleanerVideoService.cs
@@ -12,6 +12,7 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Etherna.ServicesClient;
 using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Models.Index;
@@ -26,15 +27,15 @@ namespace Etherna.VideoImporter.Core.Services
     public sealed class CleanerVideoService : ICleanerVideoService
     {
         // Fields.
-        private readonly IUserIndexClient ethernaIndexClient;
+        private readonly IEthernaUserClients ethernaUserClients;
         private readonly IGatewayService gatewayService;
 
         // Constructor.
         public CleanerVideoService(
-            IUserIndexClient ethernaIndexClient,
+            IEthernaUserClients ethernaUserClients,
             IGatewayService gatewayService)
         {
-            this.ethernaIndexClient = ethernaIndexClient;
+            this.ethernaUserClients = ethernaUserClients;
             this.gatewayService = gatewayService;
         }
 
@@ -120,7 +121,7 @@ private async Task RemoveFromIndexAsync(
             bool removeSucceeded = false;
             try
             {
-                await ethernaIndexClient.VideosClient.VideosDeleteAsync(indexedVideo.IndexId);
+                await ethernaUserClients.IndexClient.VideosClient.VideosDeleteAsync(indexedVideo.IndexId);
                 removeSucceeded = true;
 
                 Console.ForegroundColor = ConsoleColor.DarkGreen;
diff --git a/src/EthernaVideoImporter.Core/Services/EncoderService.cs b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
index cb1237a..f879eb2 100644
--- a/src/EthernaVideoImporter.Core/Services/EncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
@@ -1,5 +1,6 @@
 using Etherna.VideoImporter.Core.Models.Domain;
 using Medallion.Shell;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -12,16 +13,19 @@ public partial class EncoderService : IEncoderService
     {
         // Fields.
         private readonly List<Command> activedCommands = new();
+        private readonly ImporterSettings importerSettings;
 
         // Constructor.
-        public EncoderService(
-            string ffMpegBinaryPath)
+        public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
         {
-            FFMpegBinaryPath = ffMpegBinaryPath;
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+
+            this.importerSettings = importerSettingsOption.Value;
         }
 
         // Properties.
-        public string FFMpegBinaryPath { get; }
+        public string FFMpegBinaryPath { get => importerSettings.FFMpegBinaryPath; }
 
         // Methods.
         public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
diff --git a/src/EthernaVideoImporter.Core/Services/EthernaGatewayService.cs b/src/EthernaVideoImporter.Core/Services/EthernaGatewayService.cs
index 8e2f7d3..485999a 100644
--- a/src/EthernaVideoImporter.Core/Services/EthernaGatewayService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EthernaGatewayService.cs
@@ -1,4 +1,5 @@
 using Etherna.BeeNet.Clients.GatewayApi;
+using Etherna.ServicesClient;
 using Etherna.ServicesClient.Clients.Gateway;
 using System;
 using System.Collections.Generic;
@@ -12,21 +13,21 @@ public class EthernaGatewayService : GatewayServiceBase
         private readonly TimeSpan BatchCreationTimeout = new(0, 0, 10, 0);
 
         // Fields.
-        private readonly IUserGatewayClient ethernaGatewayClient;
+        private readonly IEthernaUserClients ethernaUserClients;
 
         // Constructor.
         public EthernaGatewayService(
             IBeeGatewayClient beeGatewayClient,
-            IUserGatewayClient ethernaGatewayClient)
+            IEthernaUserClients ethernaUserClients)
             : base(beeGatewayClient)
         {
-            this.ethernaGatewayClient = ethernaGatewayClient;
+            this.ethernaUserClients = ethernaUserClients;
         }
 
         // Methods.
         public override async Task<string> CreatePostageBatchAsync(long amount, int batchDepth)
         {
-            var batchReferenceId = await ethernaGatewayClient.UsersClient.BatchesPostAsync(batchDepth, amount);
+            var batchReferenceId = await ethernaUserClients.GatewayClient.UsersClient.BatchesPostAsync(batchDepth, amount);
 
             // Wait until created batch is avaiable.
             Console.Write("Waiting for batch created... (it may take a while)");
@@ -45,7 +46,7 @@ public override async Task<string> CreatePostageBatchAsync(long amount, int batc
 
                 try
                 {
-                    batchId = await ethernaGatewayClient.SystemClient.PostageBatchRefAsync(batchReferenceId);
+                    batchId = await ethernaUserClients.GatewayClient.SystemClient.PostageBatchRefAsync(batchReferenceId);
                 }
                 catch (GatewayApiException)
                 {
@@ -62,18 +63,18 @@ public override async Task<string> CreatePostageBatchAsync(long amount, int batc
         }
 
         public override Task DeletePinAsync(string hash) =>
-            ethernaGatewayClient.ResourcesClient.PinDeleteAsync(hash);
+            ethernaUserClients.GatewayClient.ResourcesClient.PinDeleteAsync(hash);
 
         public override async Task<long> GetCurrentChainPriceAsync() =>
-            (await ethernaGatewayClient.SystemClient.ChainstateAsync()).CurrentPrice;
+            (await ethernaUserClients.GatewayClient.SystemClient.ChainstateAsync()).CurrentPrice;
 
         public override async Task<IEnumerable<string>> GetPinnedResourcesAsync() =>
-            await ethernaGatewayClient.UsersClient.PinnedResourcesAsync();
+            await ethernaUserClients.GatewayClient.UsersClient.PinnedResourcesAsync();
 
         public override async Task<bool> IsBatchUsableAsync(string batchId) =>
-            (await ethernaGatewayClient.UsersClient.BatchesGetAsync(batchId)).Usable;
+            (await ethernaUserClients.GatewayClient.UsersClient.BatchesGetAsync(batchId)).Usable;
 
         public override Task OfferContentAsync(string hash) =>
-            ethernaGatewayClient.ResourcesClient.OffersPostAsync(hash);
+            ethernaUserClients.GatewayClient.ResourcesClient.OffersPostAsync(hash);
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
index ac8b1ae..62f608d 100644
--- a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
@@ -13,9 +13,11 @@
 //   limitations under the License.
 
 using Etherna.BeeNet.InputModels;
+using Etherna.ServicesClient;
 using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Models.ManifestDtos;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -35,25 +37,22 @@ public sealed class VideoUploaderService : IVideoUploaderService
         private readonly TimeSpan UploadRetryTimeSpan = TimeSpan.FromSeconds(5);
 
         // Fields.
-        private bool acceptPurchaseOfAllBatches;
         private readonly IGatewayService gatewayService;
-        private readonly IUserIndexClient ethernaIndexClient;
-        private readonly TimeSpan ttlPostageStamp;
-        private readonly string userEthAddr;
+        private readonly IEthernaUserClients ethernaUserClients;
+        private readonly ImporterSettings importerSettings;
 
         // Constructor.
         public VideoUploaderService(
             IGatewayService gatewayService,
-            IUserIndexClient ethernaIndexClient,
-            string userEthAddr,
-            TimeSpan ttlPostageStamp,
-            bool confirmPurchaseAllBatches)
+            IEthernaUserClients ethernaUserClients,
+            IOptions<ImporterSettings> importerSettingsOption)
         {
-            this.acceptPurchaseOfAllBatches = confirmPurchaseAllBatches;
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+
             this.gatewayService = gatewayService;
-            this.ethernaIndexClient = ethernaIndexClient;
-            this.userEthAddr = userEthAddr;
-            this.ttlPostageStamp = ttlPostageStamp;
+            this.ethernaUserClients = ethernaUserClients;
+            this.importerSettings = importerSettingsOption.Value;
         }
 
         // Public methods.
@@ -74,12 +73,12 @@ public async Task UploadVideoAsync(
 
             //calculate amount
             var currentPrice = await gatewayService.GetCurrentChainPriceAsync();
-            var amount = (long)(ttlPostageStamp.TotalSeconds * currentPrice / CommonConsts.GnosisBlockTime.TotalSeconds);
+            var amount = (long)(importerSettings.TTLPostageStamp.TotalSeconds * currentPrice / CommonConsts.GnosisBlockTime.TotalSeconds);
             var bzzPrice = amount * Math.Pow(2, batchDepth) / BzzDecimalPlacesToUnit;
 
             Console.WriteLine($"Creating postage batch... Depth: {batchDepth} Amount: {amount} BZZ price: {bzzPrice}");
 
-            if (!acceptPurchaseOfAllBatches)
+            if (!importerSettings.AcceptPurchaseOfAllBatches)
             {
                 bool validSelection = false;
 
@@ -93,7 +92,7 @@ public async Task UploadVideoAsync(
                             validSelection = true;
                             break;
                         case ConsoleKeyInfo ak when ak.Key == ConsoleKey.A:
-                            acceptPurchaseOfAllBatches = true;
+                            importerSettings.AcceptPurchaseOfAllBatches = true;
                             validSelection = true;
                             break;
                         case ConsoleKeyInfo nk when nk.Key == ConsoleKey.N:
@@ -194,7 +193,7 @@ public async Task UploadVideoAsync(
             }
 
             // Manifest.
-            var metadataVideo = new ManifestDto(video, batchId, userEthAddr);
+            var metadataVideo = new ManifestDto(video, batchId, importerSettings.UserEthAddr);
             {
                 var uploadSucceeded = false;
                 for (int i = 0; i < UploadMaxRetry && !uploadSucceeded; i++)
@@ -222,13 +221,13 @@ public async Task UploadVideoAsync(
 
             // List on index.
             if (video.EthernaIndexId is null)
-                video.EthernaIndexId = await ethernaIndexClient.VideosClient.VideosPostAsync(
+                video.EthernaIndexId = await ethernaUserClients.IndexClient.VideosClient.VideosPostAsync(
                     new VideoCreateInput
                     {
                         ManifestHash = video.EthernaPermalinkHash!,
                     });
             else
-                await ethernaIndexClient.VideosClient.VideosPutAsync(video.EthernaIndexId, video.EthernaPermalinkHash!);
+                await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(video.EthernaIndexId, video.EthernaPermalinkHash!);
 
             Console.WriteLine($"Listed on etherna index with Id: {video.EthernaIndexId}");
         }
diff --git a/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
index 287a2c8..1bdb222 100644
--- a/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
@@ -24,7 +24,6 @@ public interface IYoutubeDownloader
         Task<Video> GetVideoAsync(
             YouTubeVideoMetadataBase videoMetadata,
             DirectoryInfo tempDirectory,
-            bool includeAudioTrack,
-            IEnumerable<int> supportedHeightResolutions);
+            ImporterSettings importerSettings);
     }
 }
\ No newline at end of file
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 58f33d1..7e1704a 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -50,13 +50,14 @@ public YoutubeDownloader(
         public async Task<Video> GetVideoAsync(
             YouTubeVideoMetadataBase videoMetadata,
             DirectoryInfo tempDirectory,
-            bool includeAudioTrack,
-            IEnumerable<int> supportedHeightResolutions)
+            ImporterSettings importerSettings)
         {
             if (videoMetadata is null)
                 throw new ArgumentNullException(nameof(videoMetadata));
             if (tempDirectory is null)
                 throw new ArgumentNullException(nameof(tempDirectory));
+            if (importerSettings is null)
+                throw new ArgumentNullException(nameof(importerSettings));
 
             // Get manifest data.
             var youtubeStreamsManifest = await youtubeClient.Videos.Streams.GetManifestAsync(videoMetadata.YoutubeId);
@@ -79,8 +80,8 @@ public async Task<Video> GetVideoAsync(
             var encodedFiles = await encoderService.EncodeVideosAsync(
                 videoLocalFile,
                 tempDirectory,
-                supportedHeightResolutions,
-                includeAudioTrack);
+                GetSupportedHeightResolutions(importerSettings),
+                importerSettings.IncludeAudioTrack);
 
             // Get thumbnail.
             List<ThumbnailLocalFile> thumbnailFiles = new();
@@ -221,6 +222,23 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
             return thumbnails;
         }
 
+        private static IEnumerable<int> GetSupportedHeightResolutions(ImporterSettings importerSettings)
+        {
+            var supportedHeightResolutions = new List<int>();
+            if (!importerSettings.Skip1440)
+                supportedHeightResolutions.Add(1440);
+            if (!importerSettings.Skip1080)
+                supportedHeightResolutions.Add(1080);
+            if (!importerSettings.Skip720)
+                supportedHeightResolutions.Add(720);
+            if (!importerSettings.Skip480)
+                supportedHeightResolutions.Add(480);
+            if (!importerSettings.Skip360)
+                supportedHeightResolutions.Add(360);
+
+            return supportedHeightResolutions;
+        }
+
         private static void PrintProgressLine(string message, double progressStatus, double totalSizeMB, DateTime startDateTime)
         {
             // Calculate ETA.
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 918d6c7..72ccc3b 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -13,18 +13,16 @@
 //   limitations under the License.
 
 using Etherna.Authentication;
-using Etherna.BeeNet;
-using Etherna.ServicesClient;
 using Etherna.VideoImporter.Core;
+using Etherna.VideoImporter.Core.Extensions;
 using Etherna.VideoImporter.Core.Services;
 using Etherna.VideoImporter.Core.SSO;
 using Etherna.VideoImporter.Devcon.Services;
+using Microsoft.Extensions.DependencyInjection;
 using System;
-using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Net.Http;
 using System.Threading.Tasks;
 
 namespace Etherna.VideoImporter.Devcon
@@ -81,7 +79,7 @@ static async Task Main(string[] args)
             bool unpinRemovedVideos = false;
             bool forceUploadVideo = false;
             bool acceptPurchaseOfAllBatches = false;
-            bool ignoreNewVersionOfImporter = false;
+            bool ignoreNewVersionsOfImporter = false;
             bool skip1440 = false;
             bool skip1080 = false;
             bool skip720 = false;
@@ -167,7 +165,7 @@ static async Task Main(string[] args)
                     case "-u": unpinRemovedVideos = true; break;
                     case "-f": forceUploadVideo = true; break;
                     case "-y": acceptPurchaseOfAllBatches = true; break;
-                    case "-i": ignoreNewVersionOfImporter = true; break;
+                    case "-i": ignoreNewVersionsOfImporter = true; break;
                     case "-skip1440": skip1440 = true; break;
                     case "-skip1080": skip1080 = true; break;
                     case "-skip720": skip720 = true; break;
@@ -234,97 +232,59 @@ static async Task Main(string[] args)
             }
             Console.WriteLine($"User {authResult.User.Claims.Where(i => i.Type == EthernaClaimTypes.Username).FirstOrDefault()?.Value} autenticated");
 
-            // Inizialize services.
-            using var httpClient = new HttpClient(authResult.RefreshTokenHandler) { Timeout = TimeSpan.FromMinutes(30) };
-
-            //index
-            var ethernaUserClients = new EthernaUserClients(
-                new Uri(CommonConsts.EthernaCreditUrl),
-                new Uri(CommonConsts.EthernaGatewayUrl),
-                new Uri(CommonConsts.EthernaIndexUrl),
-                new Uri(CommonConsts.EthernaSsoUrl),
-                () => httpClient);
-
-            //bee
-            using var beeNodeClient = new BeeNodeClient(
-                useBeeNativeNode ? beeNodeUrl : CommonConsts.EthernaGatewayUrl,
-                useBeeNativeNode ? beeNodeApiPort : CommonConsts.EthernaGatewayPort,
-                useBeeNativeNode ? beeNodeDebugPort : null,
-                CommonConsts.BeeNodeGatewayVersion,
-                CommonConsts.BeeNodeDebugVersion,
-                httpClient);
-
-            //gateway
-            IGatewayService gatewayService = useBeeNativeNode ?
-                new BeeGatewayService(beeNodeClient.GatewayClient!) :
-                new EthernaGatewayService(
-                    beeNodeClient.GatewayClient!,
-                    ethernaUserClients.GatewayClient);
-
-            //video uploader service
-            var videoUploaderService = new VideoUploaderService(
-                gatewayService,
-                ethernaUserClients.IndexClient,
-                userEthAddr,
-                TimeSpan.FromDays(ttlPostageStamp),
-                acceptPurchaseOfAllBatches);
-            var encoderService = new EncoderService(ffMpegBinaryPath);
-
             // Migration service.
             var migrationService = new MigrationService();
 
             // Check for new version
             var newVersionAvaiable = await EthernaVersionControl.CheckNewVersionAsync();
-            if (newVersionAvaiable && !ignoreNewVersionOfImporter)
+            if (newVersionAvaiable && !ignoreNewVersionsOfImporter)
                 return;
 
-            // Call runner.
-            var importer = new EthernaVideoImporter(
-                new CleanerVideoService(
-                    ethernaUserClients.IndexClient,
-                    gatewayService),
-                gatewayService,
-                ethernaUserClients.IndexClient,
-                new DevconLinkReporterService(mdSourceFolderPath),
-                new MdVideoProvider(
-                    mdSourceFolderPath,
-                    encoderService,
-                    includeAudioTrack,
-                    GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360)),
-                videoUploaderService,
-                migrationService);
+            // Setup DI.
+            var services = new ServiceCollection();
 
-            await importer.RunAsync(
-                userEthAddr,
+            //configure
+            services.AddImportSettings(
+                acceptPurchaseOfAllBatches,
+                deleteExogenousVideos,
+                deleteVideosMissingFromSource,
+                ffMpegBinaryPath,
+                ffMpegFolderPath,
+                forceUploadVideo,
+                ignoreNewVersionsOfImporter,
+                includeAudioTrack,
                 offerVideos,
                 pinVideos,
-                deleteVideosMissingFromSource,
-                deleteExogenousVideos,
+                mdSourceFolderPath,
+                skip1440,
+                skip1080,
+                skip720,
+                skip480,
+                skip360,
+                ttlPostageStamp,
                 unpinRemovedVideos,
-                forceUploadVideo);
+                userEthAddr)
+            .AddLinkReporterService()
+            .AddVideoProvider()
+            .AddCommonServices(useBeeNativeNode)
+            .ConfigureHttpClient(authResult.RefreshTokenHandler);
+
+            var serviceProvider = services.BuildServiceProvider();
+
+            //do the actual work here
+            var importer = serviceProvider.GetService<EthernaVideoImporter>() ?? throw new InvalidOperationException("Cannot resolve EthernaVideoImporter service");
+            await importer.RunAsync();
         }
 
         // Helpers.
-        private static IEnumerable<int> GetSupportedHeightResolutions(
-            bool skip1440,
-            bool skip1080,
-            bool skip720,
-            bool skip480,
-            bool skip360)
+        private static IServiceCollection AddLinkReporterService(this IServiceCollection services)
         {
-            var supportedHeightResolutions = new List<int>();
-            if (!skip1440)
-                supportedHeightResolutions.Add(1440);
-            if (!skip1080)
-                supportedHeightResolutions.Add(1080);
-            if (!skip720)
-                supportedHeightResolutions.Add(720);
-            if (!skip480)
-                supportedHeightResolutions.Add(480);
-            if (!skip360)
-                supportedHeightResolutions.Add(360);
+            return services.AddTransient<ILinkReporterService, DevconLinkReporterService>();
+        }
 
-            return supportedHeightResolutions;
+        private static IServiceCollection AddVideoProvider(this IServiceCollection services)
+        {
+            return services.AddTransient<IVideoProvider, MdVideoProvider>();
         }
     }
 }
diff --git a/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs b/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
index d2aa9d3..7980fa6 100644
--- a/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
@@ -14,6 +14,7 @@
 
 using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Services;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -27,11 +28,14 @@ public sealed class DevconLinkReporterService : ILinkReporterService
         // Fields.
         private const string EthernaIndexPrefix = "ethernaIndex:";
         private const string EthernaPermalinkPrefix = "ethernaPermalink:";
-        private readonly string mdSourceFolderPath;
+        private readonly ImporterSettings importerSettings;
 
-        public DevconLinkReporterService(string mdSourceFolderPath)
+        public DevconLinkReporterService(IOptions<ImporterSettings> importerSettingsOption)
         {
-            this.mdSourceFolderPath = mdSourceFolderPath;
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+
+            this.importerSettings = importerSettingsOption.Value;
         }
 
         // Methods.
@@ -40,7 +44,7 @@ public async Task SetEthernaReferencesAsync(
             string ethernaIndexId,
             string ethernaPermalinkHash)
         {
-            var filePath = Path.Combine(mdSourceFolderPath, sourceVideoId);
+            var filePath = Path.Combine(importerSettings.SourceUri, sourceVideoId);
             var ethernaIndexUrl = CommonConsts.EthernaIndexContentUrlPrefix + ethernaIndexId;
             var ethernaPermalinkUrl = CommonConsts.EthernaPermalinkContentUrlPrefix + ethernaPermalinkHash;
 
diff --git a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
index 8df6774..29046eb 100644
--- a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
@@ -12,11 +12,13 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
 using Etherna.VideoImporter.Core.Utilities;
 using Etherna.VideoImporter.Devcon.Models.Domain;
 using Etherna.VideoImporter.Devcon.Models.MdDto;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -39,46 +41,44 @@ internal sealed class MdVideoProvider : IVideoProvider
 
         // Fields.
         public static readonly string[] _keywordForArrayString = Array.Empty<string>();
-        private readonly bool includeAudioTrack;
-        private readonly IEnumerable<int> supportedHeightResolutions;
-        private readonly string mdFolderRootPath;
+        private readonly ImporterSettings importerSettings;
         private readonly YoutubeClient youtubeClient;
         private readonly IYoutubeDownloader youtubeDownloader;
 
         // Constructor.
         public MdVideoProvider(
-            string mdFolderRootPath,
-            IEncoderService encoderService,
-            bool includeAudioTrack,
-            IEnumerable<int> supportedHeightResolutions)
+            IOptions<ImporterSettings> importerSettingsOption,
+            IEncoderService encoderService)
         {
-            this.mdFolderRootPath = mdFolderRootPath;
-            this.includeAudioTrack = includeAudioTrack;
-            this.supportedHeightResolutions = supportedHeightResolutions;
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (encoderService is null)
+                throw new ArgumentNullException(nameof(encoderService));
+
+            this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
             youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient);
         }
 
         // Properties.
-        public string SourceName => mdFolderRootPath;
+        public string SourceName => importerSettings.SourceUri;
 
         // Methods.
         public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo importerTempDirectoryInfo) => youtubeDownloader.GetVideoAsync(
             videoMetadata as MdFileVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(MdFileVideoMetadata)}", nameof(videoMetadata)),
             importerTempDirectoryInfo,
-            includeAudioTrack,
-            supportedHeightResolutions);
+            importerSettings);
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {
-            var mdFilesPaths = Directory.GetFiles(mdFolderRootPath, "*.md", SearchOption.AllDirectories);
+            var mdFilesPaths = Directory.GetFiles(importerSettings.SourceUri, "*.md", SearchOption.AllDirectories);
 
             Console.WriteLine($"Found {mdFilesPaths.Length} videos");
 
             var videosMetadata = new List<(ArchiveMdFileDto mdDto, YoutubeExplode.Videos.Video ytVideo, VideoOnlyStreamInfo ytBestStreamInfo, string mdRelativePath)>();
             foreach (var (mdFilePath, i) in mdFilesPaths.Select((f, i) => (f, i)))
             {
-                var mdFileRelativePath = Path.GetRelativePath(mdFolderRootPath, mdFilePath);
+                var mdFileRelativePath = Path.GetRelativePath(importerSettings.SourceUri, mdFilePath);
 
                 Console.WriteLine($"File #{i + 1} of {mdFilesPaths.Length}: {mdFileRelativePath}");
 
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index bf81878..dfc233f 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -13,18 +13,16 @@
 //   limitations under the License.
 
 using Etherna.Authentication;
-using Etherna.BeeNet;
-using Etherna.ServicesClient;
 using Etherna.VideoImporter.Core;
+using Etherna.VideoImporter.Core.Extensions;
 using Etherna.VideoImporter.Core.Services;
 using Etherna.VideoImporter.Core.SSO;
 using Etherna.VideoImporter.Services;
+using Microsoft.Extensions.DependencyInjection;
 using System;
-using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Net.Http;
 using System.Threading.Tasks;
 
 namespace Etherna.VideoImporter
@@ -252,58 +250,6 @@ static async Task Main(string[] args)
             }
             Console.WriteLine($"User {authResult.User.Claims.Where(i => i.Type == EthernaClaimTypes.Username).FirstOrDefault()?.Value} autenticated");
 
-            // Inizialize services.
-            using var httpClient = new HttpClient(authResult.RefreshTokenHandler) { Timeout = TimeSpan.FromMinutes(30) };
-            httpClient.DefaultRequestHeaders.ConnectionClose = true; //fixes https://etherna.atlassian.net/browse/EVI-74
-
-            //index
-            var ethernaUserClients = new EthernaUserClients(
-                new Uri(CommonConsts.EthernaCreditUrl),
-                new Uri(CommonConsts.EthernaGatewayUrl),
-                new Uri(CommonConsts.EthernaIndexUrl),
-                new Uri(CommonConsts.EthernaSsoUrl),
-                () => httpClient);
-
-            //bee
-            using var beeNodeClient = new BeeNodeClient(
-                useBeeNativeNode ? beeNodeUrl : CommonConsts.EthernaGatewayUrl,
-                useBeeNativeNode ? beeNodeApiPort : CommonConsts.EthernaGatewayPort,
-                useBeeNativeNode ? beeNodeDebugPort : null,
-                CommonConsts.BeeNodeGatewayVersion,
-                CommonConsts.BeeNodeDebugVersion,
-                httpClient);
-
-            //gateway
-            IGatewayService gatewayService = useBeeNativeNode ? 
-                new BeeGatewayService(beeNodeClient.GatewayClient!) : 
-                new EthernaGatewayService(
-                    beeNodeClient.GatewayClient!,
-                    ethernaUserClients.GatewayClient);
-
-            //video uploader service
-            var videoUploaderService = new VideoUploaderService(
-                gatewayService,
-                ethernaUserClients.IndexClient,
-                userEthAddr,
-                TimeSpan.FromDays(ttlPostageStamp),
-                acceptPurchaseOfAllBatches);
-            var encoderService = new EncoderService(ffMpegBinaryPath);
-
-            IVideoProvider videoProvider = sourceType switch
-            {
-                SourceType.YouTubeChannel => new YouTubeChannelVideoProvider(
-                    sourceUri,
-                    encoderService,
-                    includeAudioTrack,
-                    GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360)),
-                SourceType.YouTubeVideo => new YouTubeSingleVideoProvider(
-                    sourceUri,
-                    encoderService,
-                    includeAudioTrack,
-                    GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360)),
-                _ => throw new InvalidOperationException()
-            };
-
             // Migration service.
             var migrationService = new MigrationService();
 
@@ -312,49 +258,56 @@ static async Task Main(string[] args)
             if (newVersionAvaiable && !ignoreNewVersionsOfImporter)
                 return;
 
-            // Call runner.
-            var importer = new EthernaVideoImporter(
-                new CleanerVideoService(
-                    ethernaUserClients.IndexClient,
-                    gatewayService),
-                gatewayService,
-                ethernaUserClients.IndexClient,
-                new LinkReporterService(),
-                videoProvider,
-                videoUploaderService,
-                migrationService);
+            // Setup DI.
+            var services = new ServiceCollection();
 
-            await importer.RunAsync(
-                userEthAddr,
+            //configure
+            services.AddImportSettings(
+                acceptPurchaseOfAllBatches,
+                deleteExogenousVideos,
+                deleteVideosMissingFromSource,
+                ffMpegBinaryPath,
+                ffMpegFolderPath,
+                forceUploadVideo,
+                ignoreNewVersionsOfImporter,
+                includeAudioTrack,
                 offerVideos,
                 pinVideos,
-                deleteVideosMissingFromSource,
-                deleteExogenousVideos,
+                sourceUri,
+                skip1440,
+                skip1080,
+                skip720,
+                skip480,
+                skip360,
+                ttlPostageStamp,
                 unpinRemovedVideos,
-                forceUploadVideo);
+                userEthAddr)
+            .AddLinkReporterService()
+            .AddVideoProvider(sourceType.Value)
+            .AddCommonServices(useBeeNativeNode)
+            .ConfigureHttpClient(authResult.RefreshTokenHandler);
+
+            var serviceProvider = services.BuildServiceProvider();
+
+            //do the actual work here
+            var importer = serviceProvider.GetService<EthernaVideoImporter>() ?? throw new InvalidOperationException("Cannot resolve EthernaVideoImporter service");
+            await importer.RunAsync();
         }
 
         // Helpers.
-        private static IEnumerable<int> GetSupportedHeightResolutions(
-            bool skip1440,
-            bool skip1080,
-            bool skip720,
-            bool skip480,
-            bool skip360)
+        private static IServiceCollection AddLinkReporterService(this IServiceCollection services)
         {
-            var supportedHeightResolutions = new List<int>();
-            if (!skip1440)
-                supportedHeightResolutions.Add(1440);
-            if (!skip1080)
-                supportedHeightResolutions.Add(1080);
-            if (!skip720)
-                supportedHeightResolutions.Add(720);
-            if (!skip480)
-                supportedHeightResolutions.Add(480);
-            if (!skip360)
-                supportedHeightResolutions.Add(360);
+            return services.AddTransient<ILinkReporterService, LinkReporterService>();
+        }
 
-            return supportedHeightResolutions;
+        private static IServiceCollection AddVideoProvider(this IServiceCollection services, SourceType sourceType)
+        {
+            if (sourceType == SourceType.YouTubeChannel)
+                return services.AddTransient<IVideoProvider, YouTubeChannelVideoProvider>();
+            else if (sourceType == SourceType.YouTubeVideo)
+                return services.AddTransient<IVideoProvider, YouTubeSingleVideoProvider>();
+            else
+                throw new InvalidOperationException();
         }
     }
 }
diff --git a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
index 5796527..9cd72de 100644
--- a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
@@ -12,10 +12,12 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
 using Etherna.VideoImporter.Core.Utilities;
 using Etherna.VideoImporter.Models.Domain;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -31,39 +33,37 @@ namespace Etherna.VideoImporter.Services
     public sealed class YouTubeChannelVideoProvider : IVideoProvider
     {
         // Fields.
-        private readonly string channelUrl;
-        private readonly bool includeAudioTrack;
-        private readonly IEnumerable<int> supportedHeightResolutions;
+        private readonly ImporterSettings importerSettings;
         private readonly YoutubeClient youtubeClient;
         private readonly IYoutubeDownloader youtubeDownloader;
 
         // Constructor.
         public YouTubeChannelVideoProvider(
-            string channelUrl,
-            IEncoderService encoderService,
-            bool includeAudioTrack,
-            IEnumerable<int> supportedHeightResolutions)
+            IOptions<ImporterSettings> importerSettingsOption,
+            IEncoderService encoderService)
         {
-            this.channelUrl = channelUrl;
-            this.includeAudioTrack = includeAudioTrack;
-            this.supportedHeightResolutions = supportedHeightResolutions;
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (encoderService is null)
+                throw new ArgumentNullException(nameof(encoderService));
+
+            this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
             youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient);
         }
 
         // Properties.
-        public string SourceName => channelUrl;
+        public string SourceName => importerSettings.SourceUri;
 
         // Methods.
         public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo tempDirectory) => youtubeDownloader.GetVideoAsync(
             videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)),
             tempDirectory,
-            includeAudioTrack,
-            supportedHeightResolutions);
+            importerSettings);
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {
-            var youtubeChannel = await youtubeClient.Channels.GetByHandleAsync(channelUrl);
+            var youtubeChannel = await youtubeClient.Channels.GetByHandleAsync(importerSettings.SourceUri);
             var youtubeVideos = await youtubeClient.Channels.GetUploadsAsync(youtubeChannel.Url);
 
             Console.WriteLine($"Found {youtubeVideos.Count} videos");
diff --git a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
index cc5f8b2..ad6b6c8 100644
--- a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
@@ -12,10 +12,12 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
 using Etherna.VideoImporter.Core.Utilities;
 using Etherna.VideoImporter.Models.Domain;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -28,39 +30,37 @@ namespace Etherna.VideoImporter.Services
     public sealed class YouTubeSingleVideoProvider : IVideoProvider
     {
         // Fields.
-        private readonly string videoUrl;
-        private readonly bool includeAudioTrack;
-        private readonly IEnumerable<int> supportedHeightResolutions;
+        private readonly ImporterSettings importerSettings;
         private readonly YoutubeClient youtubeClient;
         private readonly IYoutubeDownloader youtubeDownloader;
 
         // Constructor.
         public YouTubeSingleVideoProvider(
-            string videoUrl,
-            IEncoderService encoderService,
-            bool includeAudioTrack,
-            IEnumerable<int> supportedHeightResolutions)
+            IOptions<ImporterSettings> importerSettingsOption,
+            IEncoderService encoderService)
         {
-            this.videoUrl = videoUrl;
-            this.includeAudioTrack = includeAudioTrack;
-            this.supportedHeightResolutions = supportedHeightResolutions;
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (encoderService is null)
+                throw new ArgumentNullException(nameof(encoderService));
+
+            this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
             youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient);
         }
 
         // Properties.
-        public string SourceName => videoUrl;
+        public string SourceName => importerSettings.SourceUri;
 
         // Methods.
         public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo tempDirectory) => youtubeDownloader.GetVideoAsync(
             videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)),
             tempDirectory,
-            includeAudioTrack,
-            supportedHeightResolutions);
+            importerSettings);
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {
-            var metadata = await youtubeClient.Videos.GetAsync(videoUrl);
+            var metadata = await youtubeClient.Videos.GetAsync(importerSettings.SourceUri);
             var bestStreamInfo = (await youtubeClient.Videos.Streams.GetManifestAsync(metadata.Id))
                 .GetVideoOnlyStreams()
                 .OrderByDescending(s => s.VideoResolution.Area)

From bbe2f1dcd8bfb40fe82c27c279130f685b587a04 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 15:06:25 +0200
Subject: [PATCH 04/22] refactory

---
 .../Extensions/ServiceCollectionExtensions.cs | 15 ++++++++---
 .../Services/BeeGatewayClientWrapper.cs       | 26 +++++++++++++++++++
 .../Services/EncoderService.cs                | 24 +++++++++++------
 .../Services/EthernaUserClientsWrapper.cs     | 18 +++++++++++++
 src/EthernaVideoImporter/Program.cs           |  4 ++-
 5 files changed, 74 insertions(+), 13 deletions(-)
 create mode 100644 src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs
 create mode 100644 src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs

diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
index 05bde67..05498a7 100644
--- a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -1,4 +1,5 @@
 using Etherna.BeeNet;
+using Etherna.BeeNet.Clients.GatewayApi;
 using Etherna.ServicesClient;
 using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Services;
@@ -56,14 +57,18 @@ public static IServiceCollection AddImportSettings(
             });
         }
 
-        public static IServiceCollection AddCommonServices(this IServiceCollection services, bool useBeeNativeNode)
+        public static IServiceCollection AddCommonServices(
+            this IServiceCollection services, 
+            bool useBeeNativeNode)
         {
             services
             .AddTransient<EthernaVideoImporter>()
+            .AddTransient<IBeeGatewayClient, BeeGatewayClientWrapper>()
             .AddTransient<IBeeNodeClient, BeeNodeClient>()
             .AddTransient<ICleanerVideoService, CleanerVideoService>()
-            .AddTransient<IEthernaUserClients, EthernaUserClients>()
-            //.AddTransient<IUserIndexClient, EthernaUserClients>()
+            .AddTransient<IEthernaUserClients, EthernaUserClientsWrapper>()
+            .AddTransient<IEncoderService, EncoderService>()
+            .AddTransient<IMigrationService, MigrationService>()
             .AddTransient<IVideoUploaderService, VideoUploaderService>();
 
             return useBeeNativeNode ?
@@ -71,7 +76,9 @@ public static IServiceCollection AddCommonServices(this IServiceCollection servi
                 services.AddTransient<IGatewayService, EthernaGatewayService>();
         }
 
-        public static IHttpClientBuilder ConfigureHttpClient(this IServiceCollection services, DelegatingHandler delegatingHandler)
+        public static IHttpClientBuilder ConfigureHttpClient(
+            this IServiceCollection services, 
+            DelegatingHandler delegatingHandler)
         {
             return services.AddHttpClient("ethernaClient", c =>
             {
diff --git a/src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs b/src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs
new file mode 100644
index 0000000..f4fe67c
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs
@@ -0,0 +1,26 @@
+using Etherna.BeeNet.Clients.GatewayApi;
+using System;
+using System.Net.Http;
+
+namespace Etherna.VideoImporter.Core.Services
+{
+    public class BeeGatewayClientWrapper : BeeGatewayClient
+    {
+        // Constructor.
+        public BeeGatewayClientWrapper(IHttpClientFactory httpClientFactory)
+            : base(
+                  PassThroughNonNull(httpClientFactory).CreateClient("ethernaClient"), 
+                  new Uri(CommonConsts.EthernaGatewayUrl), 
+                  CommonConsts.BeeNodeGatewayVersion)
+        { }
+
+        // Helpers.
+        private static IHttpClientFactory PassThroughNonNull(IHttpClientFactory httpClientFactory)
+        {
+            if (httpClientFactory is null)
+                throw new ArgumentNullException(nameof(httpClientFactory));
+
+            return httpClientFactory;
+        }
+    }
+}
diff --git a/src/EthernaVideoImporter.Core/Services/EncoderService.cs b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
index f879eb2..b2b2665 100644
--- a/src/EthernaVideoImporter.Core/Services/EncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
@@ -63,14 +63,22 @@ public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
 
                 var fileName = $"{importerTempDirectoryInfo.FullName}/{fileNameGuid}_{heightResolution}.mp4";
                 var args = new string[] {
-                    $"-i {originalVideoLocalFile.FilePath}",
-                    "-c:a aac",
-                    "-c:v libx264",
-                    "-movflags faststart",
-                    $"-vf scale={roundedScaledWidth}:{heightResolution}",
-                    "-loglevel info"};
-
-                var command = Command.Run(FFMpegBinaryPath, args.SelectMany(arg => arg.Split(' ')).Append(fileName));
+                    $"-i",
+                    originalVideoLocalFile.FilePath,
+                    "-c:a",
+                    "aac",
+                    "-c:v",
+                    "libx264",
+                    "-movflags",
+                    "faststart",
+                    $"-vf",
+                    $"scale={roundedScaledWidth}:{heightResolution}",
+                    "-loglevel",
+                    "info",
+                    fileName
+                };
+
+                var command = Command.Run(FFMpegBinaryPath, args);
 
                 activedCommands.Add(command);
                 Console.CancelKeyPress += new ConsoleCancelEventHandler(ManageInterrupted);
diff --git a/src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs b/src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs
new file mode 100644
index 0000000..c087d22
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs
@@ -0,0 +1,18 @@
+using Etherna.ServicesClient;
+using System;
+using System.Net.Http;
+
+namespace Etherna.VideoImporter.Core.Services
+{
+    public class EthernaUserClientsWrapper : EthernaUserClients
+    {
+        // Constructor.
+        public EthernaUserClientsWrapper(IHttpClientFactory httpClientFactory) 
+            : base(new Uri(CommonConsts.EthernaCreditUrl),
+                  new Uri(CommonConsts.EthernaGatewayUrl),
+                  new Uri(CommonConsts.EthernaIndexUrl),
+                  new Uri(CommonConsts.EthernaIndexUrl), 
+                  () => httpClientFactory.CreateClient("ethernaClient"))
+        {}
+    }
+}
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index dfc233f..cddee26 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -91,7 +91,7 @@ static async Task Main(string[] args)
             bool skip480 = false;
             bool skip360 = false;
             bool useBeeNativeNode = false;
-
+            args = new string[] { "ytvideo", "https://www.youtube.com/watch?v=Z26BvHOD_sg&list=RDWt0CQupELDw&index=27" };
             // Parse input.
             if (args.Length == 0)
             {
@@ -228,11 +228,13 @@ static async Task Main(string[] args)
             }
 
             //deny delete video old sources when is single
+#pragma warning disable CA1508 // Avoid dead conditional code
             if (sourceType == SourceType.YouTubeVideo && deleteVideosMissingFromSource)
             {
                 Console.WriteLine($"Cannot delete video removed from source when the source is a single video");
                 return;
             }
+#pragma warning restore CA1508 // Avoid dead conditional code
 
             // Sign with SSO and create auth client.
             var authResult = await SignServices.SigInSSO();

From d901975f482909fa95252f894c8af786bd060011 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 15:46:11 +0200
Subject: [PATCH 05/22] fix runtime error

---
 src/EthernaVideoImporter.Core/EthernaVideoImporter.cs      | 2 +-
 .../Utilities/YoutubeDownloader.cs                         | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 9d6aa75..053bdf1 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -208,7 +208,7 @@ await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
                         }
 
                         // Upload video and all related data.
-                        await videoUploaderService.UploadVideoAsync(video, importerSettings.PinVideos, importerSettings.OfferVideos);
+                        //await videoUploaderService.UploadVideoAsync(video, importerSettings.PinVideos, importerSettings.OfferVideos);
 
                         updatedIndexId = video.EthernaIndexId!;
                         updatedPermalinkHash = video.EthernaPermalinkHash!;
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 7e1704a..d5a3492 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -204,7 +204,7 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
             {
                 var responsiveHeightSize = (int)(responsiveWidthSize / betsResolutionThumbnail.AspectRatio);
 
-                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.High);
+                using SKBitmap scaledBitmap = thumbBitmap.Resize(new SKImageInfo(responsiveWidthSize, responsiveHeightSize), SKFilterQuality.Medium);
                 using SKImage scaledImage = SKImage.FromBitmap(scaledBitmap);
                 using SKData data = scaledImage.Encode();
 
@@ -212,6 +212,11 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
                 using FileStream outputFileStream = new(thumbnailResizedPath, FileMode.CreateNew);
                 await data.AsStream().CopyToAsync(outputFileStream);
 
+                await outputFileStream.DisposeAsync();
+                data.Dispose();
+                scaledImage.Dispose();
+                scaledBitmap.Dispose();
+
                 thumbnails.Add(new ThumbnailLocalFile(
                     thumbnailResizedPath,
                     new FileInfo(thumbnailResizedPath).Length,

From 5337a71d1e0ff8505761e6f19b631f6124662a88 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 15:49:02 +0200
Subject: [PATCH 06/22] refactory

---
 src/EthernaVideoImporter/Program.cs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index cddee26..cf4348e 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -91,7 +91,7 @@ static async Task Main(string[] args)
             bool skip480 = false;
             bool skip360 = false;
             bool useBeeNativeNode = false;
-            args = new string[] { "ytvideo", "https://www.youtube.com/watch?v=Z26BvHOD_sg&list=RDWt0CQupELDw&index=27" };
+
             // Parse input.
             if (args.Length == 0)
             {
@@ -228,13 +228,11 @@ static async Task Main(string[] args)
             }
 
             //deny delete video old sources when is single
-#pragma warning disable CA1508 // Avoid dead conditional code
             if (sourceType == SourceType.YouTubeVideo && deleteVideosMissingFromSource)
             {
                 Console.WriteLine($"Cannot delete video removed from source when the source is a single video");
                 return;
             }
-#pragma warning restore CA1508 // Avoid dead conditional code
 
             // Sign with SSO and create auth client.
             var authResult = await SignServices.SigInSSO();
@@ -292,7 +290,8 @@ static async Task Main(string[] args)
             var serviceProvider = services.BuildServiceProvider();
 
             //do the actual work here
-            var importer = serviceProvider.GetService<EthernaVideoImporter>() ?? throw new InvalidOperationException("Cannot resolve EthernaVideoImporter service");
+            var importer = serviceProvider.GetService<EthernaVideoImporter>() 
+                ?? throw new InvalidOperationException("Cannot resolve EthernaVideoImporter service");
             await importer.RunAsync();
         }
 

From 0aabc4dca65d002368c0615a74cb0a81ea0802bf Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 17:50:39 +0200
Subject: [PATCH 07/22] ffprobe

---
 src/EthernaVideoImporter.Core/CommonConsts.cs | 14 ++++
 .../EthernaVideoImporter.cs                   |  2 +-
 src/EthernaVideoImporter.Devcon/Program.cs    |  8 +++
 .../LocalVideoDtos/ArchiveLocalVideoDto.cs    |  2 +-
 .../Models/LocalVideoDtos/FFProbeResult.cs    | 23 ++++++
 src/EthernaVideoImporter/Program.cs           | 19 ++++-
 .../Services/LocalVideoProvider.cs            | 72 +++++++++++++++----
 7 files changed, 122 insertions(+), 18 deletions(-)
 create mode 100644 src/EthernaVideoImporter/Models/LocalVideoDtos/FFProbeResult.cs

diff --git a/src/EthernaVideoImporter.Core/CommonConsts.cs b/src/EthernaVideoImporter.Core/CommonConsts.cs
index 28cbec5..912de3f 100644
--- a/src/EthernaVideoImporter.Core/CommonConsts.cs
+++ b/src/EthernaVideoImporter.Core/CommonConsts.cs
@@ -50,6 +50,20 @@ public static string FFMpegBinaryName
                 throw new InvalidOperationException("OS not supported");
             }
         }
+        public static string FFProbeBinaryName
+        {
+            get
+            {
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                    return "ffprobe.exe";
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                    return "ffprobe";
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                    return "ffprobe";
+
+                throw new InvalidOperationException("OS not supported");
+            }
+        }
         public static readonly TimeSpan GnosisBlockTime = TimeSpan.FromSeconds(5);
         public const string ImporterIdentifier = "EthernaImporter";
     }
diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 1a70b5e..7dfbfed 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -208,7 +208,7 @@ await ethernaIndexClient.VideosClient.VideosPutAsync(
                         }
 
                         // Upload video and all related data.
-                        await videoUploaderService.UploadVideoAsync(video, pinVideos, offerVideos);
+                        //await videoUploaderService.UploadVideoAsync(video, pinVideos, offerVideos);
 
                         updatedIndexId = video.EthernaIndexId!;
                         updatedPermalinkHash = video.EthernaPermalinkHash!;
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 918d6c7..4b2a90b 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -186,6 +186,14 @@ static async Task Main(string[] args)
                 return;
             }
 
+            //FFprobe
+            var ffProbeBinaryPath = Path.Combine(ffMpegFolderPath, CommonConsts.FFProbeBinaryName);
+            if (!File.Exists(ffProbeBinaryPath))
+            {
+                Console.WriteLine($"FFprobe not found at ({ffMpegBinaryPath})");
+                return;
+            }
+
             //ttl postage batch
             if (!string.IsNullOrEmpty(ttlPostageStampStr) &&
                 !int.TryParse(ttlPostageStampStr, CultureInfo.InvariantCulture, out ttlPostageStamp))
diff --git a/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs b/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs
index 7910311..76087df 100644
--- a/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs
+++ b/src/EthernaVideoImporter/Models/LocalVideoDtos/ArchiveLocalVideoDto.cs
@@ -4,8 +4,8 @@ internal sealed class ArchiveLocalVideoDto
     {
         // Properties.
         public string Description { get; set; } = default!;
+        public string FilePath { get; set; } = default!;
         public string Title { get; set; } = default!;
         public string? Thumbnail { get; set; }
-        public string Video { get; set; } = default!;
     }
 }
diff --git a/src/EthernaVideoImporter/Models/LocalVideoDtos/FFProbeResult.cs b/src/EthernaVideoImporter/Models/LocalVideoDtos/FFProbeResult.cs
new file mode 100644
index 0000000..ede8659
--- /dev/null
+++ b/src/EthernaVideoImporter/Models/LocalVideoDtos/FFProbeResult.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace Etherna.VideoImporter.Models.LocalVideoDtos
+{
+    public class FFProbeResult
+    {
+        public IEnumerable<StreamResult> Streams { get; set; } = default!;
+        public FormatResult Format { get; set; } = default!;
+
+        public class FormatResult
+        {
+            public TimeSpan Duration { get; set; }
+        }
+
+        public class StreamResult
+        {
+            public int Height { get; set; }
+            public int Width { get; set; }
+        }
+
+    }
+}
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index 1738989..b9179a6 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -94,7 +94,7 @@ static async Task Main(string[] args)
             bool skip480 = false;
             bool skip360 = false;
             bool useBeeNativeNode = false;
-
+            args = new string[] { "localvideo", "C:/tmp/LocalVideo/localvideo.json" };
             // Parse input.
             if (args.Length == 0)
             {
@@ -208,6 +208,14 @@ static async Task Main(string[] args)
                 return;
             }
 
+            //FFprobe
+            var ffProbeBinaryPath = Path.Combine(ffMpegFolderPath, CommonConsts.FFProbeBinaryName);
+            if (!File.Exists(ffProbeBinaryPath))
+            {
+                Console.WriteLine($"FFprobe not found at ({ffMpegBinaryPath})");
+                return;
+            }
+
             //ttl postage batch
             if (!string.IsNullOrEmpty(ttlPostageStampStr) &&
                 !int.TryParse(ttlPostageStampStr, CultureInfo.InvariantCulture, out ttlPostageStamp))
@@ -225,12 +233,14 @@ static async Task Main(string[] args)
             }
 
             //check local video input
+#pragma warning disable CA1508 // Avoid dead conditional code
             if (sourceType == SourceType.LocalVideo &&
                 !File.Exists(sourceUri))
             {
                 Console.WriteLine($"Local video not found at ({sourceUri})");
                 return;
             }
+#pragma warning restore CA1508 // Avoid dead conditional code
 
             //bee node api port
             if (!string.IsNullOrEmpty(beeNodeApiPortStr) &&
@@ -249,11 +259,13 @@ static async Task Main(string[] args)
             }
 
             //deny delete video old sources when is single
+#pragma warning disable CA1508 // Avoid dead conditional code
             if (sourceType == SourceType.YouTubeVideo && deleteVideosMissingFromSource)
             {
                 Console.WriteLine($"Cannot delete video removed from source when the source is a single video");
                 return;
             }
+#pragma warning restore CA1508 // Avoid dead conditional code
 
             // Sign with SSO and create auth client.
             var authResult = await SignServices.SigInSSO();
@@ -308,6 +320,7 @@ static async Task Main(string[] args)
                 acceptPurchaseOfAllBatches);
             var encoderService = new EncoderService(ffMpegBinaryPath);
 
+#pragma warning disable CA1508 // Avoid dead conditional code
             IVideoProvider videoProvider = sourceType switch
             {
                 SourceType.YouTubeChannel => new YouTubeChannelVideoProvider(
@@ -324,9 +337,11 @@ static async Task Main(string[] args)
                     sourceUri,
                     encoderService,
                     includeAudioTrack,
-                    GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360)),
+                    GetSupportedHeightResolutions(skip1440, skip1080, skip720, skip480, skip360),
+                    ffProbeBinaryPath),
                 _ => throw new InvalidOperationException()
             };
+#pragma warning restore CA1508 // Avoid dead conditional code
 
             // Migration service.
             var migrationService = new MigrationService();
diff --git a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
index d26b35c..7d6f434 100644
--- a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
@@ -2,13 +2,14 @@
 using Etherna.VideoImporter.Core.Services;
 using Etherna.VideoImporter.Models.Domain;
 using Etherna.VideoImporter.Models.LocalVideoDto;
+using Etherna.VideoImporter.Models.LocalVideoDtos;
+using Medallion.Shell;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
-using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 
@@ -17,22 +18,29 @@ namespace Etherna.VideoImporter.Services
     public sealed class LocalVideoProvider : IVideoProvider
     {
         // Fields.
+        private readonly string ffProbeBinaryPath;
         private readonly string localFile;
         private readonly IEncoderService encoderService;
         private readonly bool includeAudioTrack;
         private readonly IEnumerable<int> supportedHeightResolutions;
+        private readonly JsonSerializerOptions options = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        };
 
         // Constructor.
         public LocalVideoProvider(
             string localFile,
             IEncoderService encoderService,
             bool includeAudioTrack,
-            IEnumerable<int> supportedHeightResolutions)
+            IEnumerable<int> supportedHeightResolutions,
+            string ffProbeBinaryPath)
         {
             this.localFile = localFile;
             this.encoderService = encoderService;
             this.includeAudioTrack = includeAudioTrack;
             this.supportedHeightResolutions = supportedHeightResolutions;
+            this.ffProbeBinaryPath = ffProbeBinaryPath;
         }
 
         // Properties.
@@ -46,13 +54,16 @@ public async Task<Video> GetVideoAsync(
             if (tempDirectory is null)
                 throw new ArgumentNullException(nameof(tempDirectory));
 
-            var localVideoMetadata = videoMetadata as LocalVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(LocalVideoMetadata)}", nameof(videoMetadata));
+            var localVideoMetadata = videoMetadata as LocalVideoMetadata 
+                ?? throw new ArgumentException($"Metadata bust be of type {nameof(LocalVideoMetadata)}", nameof(videoMetadata));
 
             // Video info.
-            var videoHeight = 0;
-            var videoWidth = 0;
-            var byteSizeVideo = 0;
-            var videoLocalFile = new VideoLocalFile(localVideoMetadata.FilePath, videoHeight, videoWidth, byteSizeVideo);
+            var ffProbeResult = GetVideoDuration(localVideoMetadata.FilePath);
+            var videoLocalFile = new VideoLocalFile(
+                localVideoMetadata.FilePath, 
+                ffProbeResult.Streams.First().Height, 
+                ffProbeResult.Streams.First().Width, 
+                new FileInfo(localVideoMetadata.FilePath).Length);
 
             // Transcode video resolutions.
             var encodedFiles = await encoderService.EncodeVideosAsync(videoLocalFile, tempDirectory, supportedHeightResolutions, includeAudioTrack);
@@ -68,7 +79,8 @@ public async Task<Video> GetVideoAsync(
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {
-            var localVideos = JsonSerializer.Deserialize<List<ArchiveLocalVideoDto>>(localFile) ?? throw new InvalidDataException($"LocalFile wrong format in {localFile}");
+            var localVideos = JsonSerializer.Deserialize<List<ArchiveLocalVideoDto>>(File.ReadAllText(localFile), options) 
+                ?? throw new InvalidDataException($"LocalFile wrong format in {localFile}");
 
             var videosMetadata = new List<VideoMetadataBase>();
             foreach (var video in localVideos)
@@ -87,17 +99,15 @@ public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
                     }
 
                     // Video info.
-                    var duration = new TimeSpan(1);
-                    var videoQualityLabel = "1080p";
-                    // quando audio è null controllare che il video contenga anche l'audio
+                    var ffProbeResult = GetVideoDuration(video.FilePath);
 
                     videosMetadata.Add(new LocalVideoMetadata(
                         video.Description,
-                        duration,
-                        videoQualityLabel,
+                        ffProbeResult.Format.Duration,
+                        $"{ffProbeResult.Streams.First().Height}p",
                         thumbnail,
                         video.Title,
-                        video.Video));
+                        video.FilePath));
 
                     Console.WriteLine($"Downloaded metadata for {video.Title}");
                 }
@@ -147,5 +157,39 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
 
             return thumbnails;
         }
+
+        private FFProbeResult GetVideoDuration(string videoPath)
+        {
+            var args = new string[] {
+                    $"-v",
+                    "error",
+                    "-show_entries",
+                    "format=duration",
+                    "-show_entries",
+                    "stream=width,height",
+                    "-of",
+                    "json",
+                    "-sexagesimal",
+                    videoPath};
+
+            var command = Command.Run(ffProbeBinaryPath, args);
+            command.Wait();
+            var result = command.Result;
+
+            // Inspect result.
+            if (!result.Success)
+                throw new InvalidOperationException($"ffprobe command failed with exit code {result.ExitCode}: {result.StandardError}");
+
+            var ffProbeResult = JsonSerializer.Deserialize<FFProbeResult>(result.StandardOutput.Trim(), options)
+                ?? throw new InvalidDataException($"FFProbe result have an invalid json");
+
+            /*
+            * ffProbe return even an empty element in Streams
+            * Take the correct resolution with OrderByDescending
+            */
+            ffProbeResult.Streams = new[] { ffProbeResult.Streams.OrderByDescending(s => s.Height).First() };
+
+            return ffProbeResult;
+        }
     }
 }

From 6a7df2b1463716f79c6bdd0d01d3cc3205d55ae9 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 20:58:25 +0200
Subject: [PATCH 08/22] fix encoder

---
 .../Services/EncoderService.cs                | 24 ++++++++++++-------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/Services/EncoderService.cs b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
index cb1237a..e251bed 100644
--- a/src/EthernaVideoImporter.Core/Services/EncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
@@ -59,14 +59,22 @@ public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
 
                 var fileName = $"{importerTempDirectoryInfo.FullName}/{fileNameGuid}_{heightResolution}.mp4";
                 var args = new string[] {
-                    $"-i {originalVideoLocalFile.FilePath}",
-                    "-c:a aac",
-                    "-c:v libx264",
-                    "-movflags faststart",
-                    $"-vf scale={roundedScaledWidth}:{heightResolution}",
-                    "-loglevel info"};
-
-                var command = Command.Run(FFMpegBinaryPath, args.SelectMany(arg => arg.Split(' ')).Append(fileName));
+                    $"-i",
+                    originalVideoLocalFile.FilePath,
+                    "-c:a",
+                    "aac",
+                    "-c:v",
+                    "libx264",
+                    "-movflags",
+                    "faststart",
+                    $"-vf",
+                    $"scale={roundedScaledWidth}:{heightResolution}",
+                    "-loglevel",
+                    "info",
+                    fileName
+                };
+
+                var command = Command.Run(FFMpegBinaryPath, args);
 
                 activedCommands.Add(command);
                 Console.CancelKeyPress += new ConsoleCancelEventHandler(ManageInterrupted);

From 361cba1f3231d7267589f32113bb624a441ee7ae Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sat, 8 Apr 2023 21:03:01 +0200
Subject: [PATCH 09/22] fix thumbnail

---
 .../Utilities/YoutubeDownloader.cs                          | 6 ++++++
 src/EthernaVideoImporter/Services/LocalVideoProvider.cs     | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 93eda44..889d67d 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -211,6 +211,12 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
                 using FileStream outputFileStream = new(thumbnailResizedPath, FileMode.CreateNew);
                 await data.AsStream().CopyToAsync(outputFileStream);
 
+                //dispose required for call "new ThumbnailLocalFile()"
+                await outputFileStream.DisposeAsync();
+                data.Dispose();
+                scaledImage.Dispose();
+                scaledBitmap.Dispose();
+
                 thumbnails.Add(new ThumbnailLocalFile(
                     thumbnailResizedPath,
                     new FileInfo(thumbnailResizedPath).Length,
diff --git a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
index 7d6f434..5966d9e 100644
--- a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
@@ -148,6 +148,12 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
                 using FileStream outputFileStream = new(thumbnailResizedPath, FileMode.CreateNew);
                 await data.AsStream().CopyToAsync(outputFileStream);
 
+                //dispose required for call "new ThumbnailLocalFile()"
+                await outputFileStream.DisposeAsync();
+                data.Dispose();
+                scaledImage.Dispose();
+                scaledBitmap.Dispose();
+
                 thumbnails.Add(new ThumbnailLocalFile(
                     thumbnailResizedPath,
                     new FileInfo(thumbnailResizedPath).Length,

From 21217589aafe39f64b87a5522a9d2533d0fc3bb5 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Sun, 9 Apr 2023 08:09:24 +0200
Subject: [PATCH 10/22] readme

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index f838c45..7c0ba78 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,7 @@ Usage:  EthernaVideoImporter SOURCE_TYPE SOURCE_URI [OPTIONS]
 Source types:
   ytchannel     YouTube channel
   ytvideo       YouTube video
+  localvideo    Local video
 
 Options:
   -ff   Path FFmpeg (default dir: .\FFmpeg\)

From 5c6d0b5d534072bc0140ce21b24cc23265a2d6cf Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Tue, 11 Apr 2023 12:27:50 +0200
Subject: [PATCH 11/22] refactory for tempDirectoryInfo

---
 .../EthernaVideoImporter.cs                   |  4 +--
 .../Extensions/ServiceCollectionExtensions.cs |  3 +-
 .../ImporterSettings.cs                       |  1 +
 .../Services/EncoderService.cs                |  7 ++--
 .../Services/IEncoderService.cs               |  1 -
 .../Services/IVideoProvider.cs                |  2 +-
 .../Utilities/IYoutubeDownloader.cs           |  1 -
 .../Utilities/YoutubeDownloader.cs            | 36 +++++++++----------
 src/EthernaVideoImporter.Devcon/Program.cs    |  1 +
 .../Services/MdVideoProvider.cs               |  5 ++-
 src/EthernaVideoImporter/Program.cs           |  1 +
 .../Services/YouTubeChannelVideoProvider.cs   |  5 ++-
 .../Services/YouTubeSingleVideoProvider.cs    |  5 ++-
 13 files changed, 34 insertions(+), 38 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 053bdf1..4230d61 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -70,7 +70,7 @@ public EthernaVideoImporter(
             this.importerSettings = importerSettingsOption.Value;
             this.linkReporterService = linkReporterService;
             this.migrationService = migrationService;
-            tempDirectoryInfo = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier));
+            tempDirectoryInfo = Directory.CreateDirectory(importerSettings.TempDirectoryPath);
             this.videoProvider = videoProvider;
             this.videoUploaderService = videoUploaderService;
         }
@@ -196,7 +196,7 @@ await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
                         }
 
                         // Get and encode video from source.
-                        var video = await videoProvider.GetVideoAsync(sourceMetadata, tempDirectoryInfo);
+                        var video = await videoProvider.GetVideoAsync(sourceMetadata);
                         video.EthernaIndexId = alreadyPresentVideo?.IndexId;
 
                         if (!video.EncodedFiles.Any())
diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
index 05498a7..f840bf2 100644
--- a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -1,7 +1,6 @@
 using Etherna.BeeNet;
 using Etherna.BeeNet.Clients.GatewayApi;
 using Etherna.ServicesClient;
-using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Services;
 using Microsoft.Extensions.DependencyInjection;
 using System;
@@ -29,6 +28,7 @@ public static IServiceCollection AddImportSettings(
             bool skip720,
             bool skip480,
             bool skip360,
+            string tempDirectoryPath,
             int ttlPostageStamp,
             bool unpinRemovedVideos,
             string userEthAddr)
@@ -51,6 +51,7 @@ public static IServiceCollection AddImportSettings(
                 options.Skip720 = skip720;
                 options.Skip480 = skip480;
                 options.Skip360 = skip360;
+                options.TempDirectoryPath = tempDirectoryPath;
                 options.TTLPostageStamp = TimeSpan.FromSeconds(ttlPostageStamp);
                 options.UnpinRemovedVideos = unpinRemovedVideos;
                 options.UserEthAddr = userEthAddr;
diff --git a/src/EthernaVideoImporter.Core/ImporterSettings.cs b/src/EthernaVideoImporter.Core/ImporterSettings.cs
index ac89586..08f5b90 100644
--- a/src/EthernaVideoImporter.Core/ImporterSettings.cs
+++ b/src/EthernaVideoImporter.Core/ImporterSettings.cs
@@ -20,6 +20,7 @@ public class ImporterSettings
         public bool Skip720 { get; set; }
         public bool Skip1080 { get; set; }
         public bool Skip1440 { get; set; }
+        public string TempDirectoryPath { get; set; } = default!;
         public TimeSpan TTLPostageStamp { get; set; }
         public bool UnpinRemovedVideos { get; set; }
         public string UserEthAddr { get; set; } = default!;
diff --git a/src/EthernaVideoImporter.Core/Services/EncoderService.cs b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
index b2b2665..eb59215 100644
--- a/src/EthernaVideoImporter.Core/Services/EncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
@@ -14,6 +14,7 @@ public partial class EncoderService : IEncoderService
         // Fields.
         private readonly List<Command> activedCommands = new();
         private readonly ImporterSettings importerSettings;
+        private readonly DirectoryInfo tempDirectoryInfo;
 
         // Constructor.
         public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
@@ -22,6 +23,7 @@ public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
 
             this.importerSettings = importerSettingsOption.Value;
+            tempDirectoryInfo = Directory.CreateDirectory(importerSettingsOption.Value.TempDirectoryPath);
         }
 
         // Properties.
@@ -30,14 +32,11 @@ public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
         // Methods.
         public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
             VideoLocalFile originalVideoLocalFile,
-            DirectoryInfo importerTempDirectoryInfo,
             IEnumerable<int> supportedHeightResolutions,
             bool includeAudioTrack)
         {
             if (originalVideoLocalFile is null)
                 throw new ArgumentNullException(nameof(originalVideoLocalFile));
-            if (importerTempDirectoryInfo is null)
-                throw new ArgumentNullException(nameof(importerTempDirectoryInfo));
 
             var videoEncodedFiles = new List<VideoLocalFile>();
             var fileNameGuid = Guid.NewGuid();
@@ -61,7 +60,7 @@ public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
                     _ => throw new InvalidOperationException()
                 };
 
-                var fileName = $"{importerTempDirectoryInfo.FullName}/{fileNameGuid}_{heightResolution}.mp4";
+                var fileName = $"{tempDirectoryInfo.FullName}/{fileNameGuid}_{heightResolution}.mp4";
                 var args = new string[] {
                     $"-i",
                     originalVideoLocalFile.FilePath,
diff --git a/src/EthernaVideoImporter.Core/Services/IEncoderService.cs b/src/EthernaVideoImporter.Core/Services/IEncoderService.cs
index d7f8002..f991746 100644
--- a/src/EthernaVideoImporter.Core/Services/IEncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/IEncoderService.cs
@@ -11,7 +11,6 @@ public interface IEncoderService
 
         Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
             VideoLocalFile originalVideoLocalFile,
-            DirectoryInfo importerTempDirectoryInfo,
             IEnumerable<int> supportedHeightResolutions,
             bool includeAudioTrack);
     }
diff --git a/src/EthernaVideoImporter.Core/Services/IVideoProvider.cs b/src/EthernaVideoImporter.Core/Services/IVideoProvider.cs
index ba47442..3a37b5d 100644
--- a/src/EthernaVideoImporter.Core/Services/IVideoProvider.cs
+++ b/src/EthernaVideoImporter.Core/Services/IVideoProvider.cs
@@ -25,7 +25,7 @@ public interface IVideoProvider
         string SourceName { get; }
 
         // Methods.
-        Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo tempDirectory);
+        Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata);
         Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync();
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
index 1bdb222..ade2403 100644
--- a/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
@@ -23,7 +23,6 @@ public interface IYoutubeDownloader
     {
         Task<Video> GetVideoAsync(
             YouTubeVideoMetadataBase videoMetadata,
-            DirectoryInfo tempDirectory,
             ImporterSettings importerSettings);
     }
 }
\ No newline at end of file
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index d5a3492..75e0ddf 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -15,6 +15,7 @@
 using Etherna.VideoImporter.Core.Extensions;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
+using Microsoft.Extensions.Options;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
@@ -36,26 +37,29 @@ public class YoutubeDownloader : IYoutubeDownloader
         // Fields.
         private readonly IEncoderService encoderService;
         private readonly YoutubeClient youtubeClient;
+        private readonly DirectoryInfo tempDirectoryInfo;
 
         // Constructor.
         public YoutubeDownloader(
             IEncoderService encoderService,
-            YoutubeClient youtubeClient)
+            YoutubeClient youtubeClient,
+            IOptions<ImporterSettings> importerSettingsOption)
         {
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+
             this.encoderService = encoderService;
             this.youtubeClient = youtubeClient;
+            tempDirectoryInfo = Directory.CreateDirectory(importerSettingsOption.Value.TempDirectoryPath);
         }
 
         // Methods.
         public async Task<Video> GetVideoAsync(
             YouTubeVideoMetadataBase videoMetadata,
-            DirectoryInfo tempDirectory,
             ImporterSettings importerSettings)
         {
             if (videoMetadata is null)
                 throw new ArgumentNullException(nameof(videoMetadata));
-            if (tempDirectory is null)
-                throw new ArgumentNullException(nameof(tempDirectory));
             if (importerSettings is null)
                 throw new ArgumentNullException(nameof(importerSettings));
 
@@ -73,13 +77,11 @@ public async Task<Video> GetVideoAsync(
             var videoLocalFile = await DownloadVideoAsync(
                 audioOnlyStreamInfo,
                 videoOnlyStreamInfo,
-                videoMetadata.Title,
-                tempDirectory);
+                videoMetadata.Title);
 
             // Transcode video resolutions.
             var encodedFiles = await encoderService.EncodeVideosAsync(
                 videoLocalFile,
-                tempDirectory,
                 GetSupportedHeightResolutions(importerSettings),
                 importerSettings.IncludeAudioTrack);
 
@@ -89,10 +91,9 @@ public async Task<Video> GetVideoAsync(
             {
                 var betsResolutionThumbnail = await DownloadThumbnailAsync(
                     videoMetadata.Thumbnail,
-                    videoMetadata.Title,
-                    tempDirectory);
+                    videoMetadata.Title);
 
-                thumbnailFiles = await DownscaleThumbnailAsync(betsResolutionThumbnail, tempDirectory);
+                thumbnailFiles = await DownscaleThumbnailAsync(betsResolutionThumbnail);
             }
 
             return new Video(videoMetadata, encodedFiles, thumbnailFiles);
@@ -101,13 +102,12 @@ public async Task<Video> GetVideoAsync(
         // Helpers.
         private async Task<ThumbnailLocalFile> DownloadThumbnailAsync(
             Thumbnail thumbnail,
-            string videoTitle,
-            DirectoryInfo importerTempDirectoryInfo)
+            string videoTitle)
         {
             if (thumbnail is null)
                 throw new ArgumentNullException(nameof(thumbnail));
 
-            string thumbnailFilePath = Path.Combine(importerTempDirectoryInfo.FullName, $"{videoTitle.ToSafeFileName()}_thumb.jpg");
+            string thumbnailFilePath = Path.Combine(tempDirectoryInfo.FullName, $"{videoTitle.ToSafeFileName()}_thumb.jpg");
 
             for (int i = 0; i <= CommonConsts.DownloadMaxRetry; i++)
             {
@@ -144,11 +144,10 @@ private async Task<ThumbnailLocalFile> DownloadThumbnailAsync(
         private async Task<VideoLocalFile> DownloadVideoAsync(
             IAudioStreamInfo audioOnlyStream,
             IVideoStreamInfo videoOnlyStream,
-            string videoTitle,
-            DirectoryInfo importerTempDirectoryInfo)
+            string videoTitle)
         {
             var videoFileName = $"{videoTitle.ToSafeFileName()}_{videoOnlyStream.VideoResolution}.{videoOnlyStream.Container}";
-            var videoFilePath = Path.Combine(importerTempDirectoryInfo.FullName, videoFileName);
+            var videoFilePath = Path.Combine(tempDirectoryInfo.FullName, videoFileName);
             var videoQualityLabel = videoOnlyStream.VideoQuality.Label;
 
             // Download video.
@@ -191,8 +190,7 @@ await youtubeClient.Videos.DownloadAsync(
         }
 
         private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
-            ThumbnailLocalFile betsResolutionThumbnail,
-            DirectoryInfo importerTempDirectoryInfo)
+            ThumbnailLocalFile betsResolutionThumbnail)
         {
             List<ThumbnailLocalFile> thumbnails = new();
 
@@ -208,7 +206,7 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
                 using SKImage scaledImage = SKImage.FromBitmap(scaledBitmap);
                 using SKData data = scaledImage.Encode();
 
-                var thumbnailResizedPath = Path.Combine(importerTempDirectoryInfo.FullName, $"thumb_{responsiveWidthSize}_{responsiveHeightSize}_{Guid.NewGuid()}.jpg");
+                var thumbnailResizedPath = Path.Combine(tempDirectoryInfo.FullName, $"thumb_{responsiveWidthSize}_{responsiveHeightSize}_{Guid.NewGuid()}.jpg");
                 using FileStream outputFileStream = new(thumbnailResizedPath, FileMode.CreateNew);
                 await data.AsStream().CopyToAsync(outputFileStream);
 
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 72ccc3b..b40c7ab 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -261,6 +261,7 @@ static async Task Main(string[] args)
                 skip720,
                 skip480,
                 skip360,
+                Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier + "Devcon"),
                 ttlPostageStamp,
                 unpinRemovedVideos,
                 userEthAddr)
diff --git a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
index 29046eb..0646ddf 100644
--- a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
@@ -57,16 +57,15 @@ public MdVideoProvider(
 
             this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
-            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient);
+            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption);
         }
 
         // Properties.
         public string SourceName => importerSettings.SourceUri;
 
         // Methods.
-        public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo importerTempDirectoryInfo) => youtubeDownloader.GetVideoAsync(
+        public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata) => youtubeDownloader.GetVideoAsync(
             videoMetadata as MdFileVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(MdFileVideoMetadata)}", nameof(videoMetadata)),
-            importerTempDirectoryInfo,
             importerSettings);
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index cf4348e..db807ee 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -279,6 +279,7 @@ static async Task Main(string[] args)
                 skip720,
                 skip480,
                 skip360,
+                Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier),
                 ttlPostageStamp,
                 unpinRemovedVideos,
                 userEthAddr)
diff --git a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
index 9cd72de..4785927 100644
--- a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
@@ -49,16 +49,15 @@ public YouTubeChannelVideoProvider(
 
             this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
-            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient);
+            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption);
         }
 
         // Properties.
         public string SourceName => importerSettings.SourceUri;
 
         // Methods.
-        public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo tempDirectory) => youtubeDownloader.GetVideoAsync(
+        public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata) => youtubeDownloader.GetVideoAsync(
             videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)),
-            tempDirectory,
             importerSettings);
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
diff --git a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
index ad6b6c8..3ac667c 100644
--- a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
@@ -46,16 +46,15 @@ public YouTubeSingleVideoProvider(
 
             this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
-            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient);
+            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption);
         }
 
         // Properties.
         public string SourceName => importerSettings.SourceUri;
 
         // Methods.
-        public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata, DirectoryInfo tempDirectory) => youtubeDownloader.GetVideoAsync(
+        public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata) => youtubeDownloader.GetVideoAsync(
             videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)),
-            tempDirectory,
             importerSettings);
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()

From 967415e20bf612cc26bd2e1525c84709eb4e1a8e Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Tue, 11 Apr 2023 12:33:28 +0200
Subject: [PATCH 12/22] tempDir refactory

---
 .../EthernaVideoImporter.cs                      |  8 +++-----
 .../Extensions/ServiceCollectionExtensions.cs    |  5 +++--
 .../ImporterSettings.cs                          |  3 ++-
 .../Services/EncoderService.cs                   |  4 +---
 .../Utilities/IYoutubeDownloader.cs              |  5 +----
 .../Utilities/YoutubeDownloader.cs               | 16 ++++++----------
 src/EthernaVideoImporter.Devcon/Program.cs       |  5 ++++-
 .../Services/MdVideoProvider.cs                  |  3 +--
 src/EthernaVideoImporter/Program.cs              |  5 ++++-
 .../Services/YouTubeChannelVideoProvider.cs      |  3 +--
 .../Services/YouTubeSingleVideoProvider.cs       |  3 +--
 11 files changed, 27 insertions(+), 33 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 4230d61..12962dc 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -38,7 +38,6 @@ public class EthernaVideoImporter
         private readonly ImporterSettings importerSettings;
         private readonly ILinkReporterService linkReporterService;
         private readonly IMigrationService migrationService;
-        private readonly DirectoryInfo tempDirectoryInfo;
         private readonly IVideoUploaderService videoUploaderService;
         private readonly IVideoProvider videoProvider;
 
@@ -70,7 +69,6 @@ public EthernaVideoImporter(
             this.importerSettings = importerSettingsOption.Value;
             this.linkReporterService = linkReporterService;
             this.migrationService = migrationService;
-            tempDirectoryInfo = Directory.CreateDirectory(importerSettings.TempDirectoryPath);
             this.videoProvider = videoProvider;
             this.videoUploaderService = videoUploaderService;
         }
@@ -248,15 +246,15 @@ await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
                     try
                     {
                         // Clear tmp folder.
-                        foreach (var file in tempDirectoryInfo.GetFiles())
+                        foreach (var file in importerSettings.TempDirectoryPath.GetFiles())
                             file.Delete();
-                        foreach (var dir in tempDirectoryInfo.GetDirectories())
+                        foreach (var dir in importerSettings.TempDirectoryPath.GetDirectories())
                             dir.Delete(true);
                     }
                     catch
                     {
                         Console.ForegroundColor = ConsoleColor.DarkRed;
-                        Console.WriteLine($"Warning: unable to delete some files inside of {tempDirectoryInfo.FullName}.");
+                        Console.WriteLine($"Warning: unable to delete some files inside of {importerSettings.TempDirectoryPath.FullName}.");
                         Console.WriteLine($"Please remove manually after the process.");
                         Console.ResetColor();
                     }
diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
index f840bf2..6d4d83e 100644
--- a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -4,6 +4,7 @@
 using Etherna.VideoImporter.Core.Services;
 using Microsoft.Extensions.DependencyInjection;
 using System;
+using System.IO;
 using System.Net.Http;
 
 namespace Etherna.VideoImporter.Core.Extensions
@@ -28,7 +29,7 @@ public static IServiceCollection AddImportSettings(
             bool skip720,
             bool skip480,
             bool skip360,
-            string tempDirectoryPath,
+            DirectoryInfo tempDirPath,
             int ttlPostageStamp,
             bool unpinRemovedVideos,
             string userEthAddr)
@@ -51,7 +52,7 @@ public static IServiceCollection AddImportSettings(
                 options.Skip720 = skip720;
                 options.Skip480 = skip480;
                 options.Skip360 = skip360;
-                options.TempDirectoryPath = tempDirectoryPath;
+                options.TempDirectoryPath = tempDirPath;
                 options.TTLPostageStamp = TimeSpan.FromSeconds(ttlPostageStamp);
                 options.UnpinRemovedVideos = unpinRemovedVideos;
                 options.UserEthAddr = userEthAddr;
diff --git a/src/EthernaVideoImporter.Core/ImporterSettings.cs b/src/EthernaVideoImporter.Core/ImporterSettings.cs
index 08f5b90..45a75d4 100644
--- a/src/EthernaVideoImporter.Core/ImporterSettings.cs
+++ b/src/EthernaVideoImporter.Core/ImporterSettings.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 
 namespace Etherna.VideoImporter.Core
 {
@@ -20,7 +21,7 @@ public class ImporterSettings
         public bool Skip720 { get; set; }
         public bool Skip1080 { get; set; }
         public bool Skip1440 { get; set; }
-        public string TempDirectoryPath { get; set; } = default!;
+        public DirectoryInfo TempDirectoryPath { get; set; } = default!;
         public TimeSpan TTLPostageStamp { get; set; }
         public bool UnpinRemovedVideos { get; set; }
         public string UserEthAddr { get; set; } = default!;
diff --git a/src/EthernaVideoImporter.Core/Services/EncoderService.cs b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
index eb59215..dcc7e6f 100644
--- a/src/EthernaVideoImporter.Core/Services/EncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
@@ -14,7 +14,6 @@ public partial class EncoderService : IEncoderService
         // Fields.
         private readonly List<Command> activedCommands = new();
         private readonly ImporterSettings importerSettings;
-        private readonly DirectoryInfo tempDirectoryInfo;
 
         // Constructor.
         public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
@@ -23,7 +22,6 @@ public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
 
             this.importerSettings = importerSettingsOption.Value;
-            tempDirectoryInfo = Directory.CreateDirectory(importerSettingsOption.Value.TempDirectoryPath);
         }
 
         // Properties.
@@ -60,7 +58,7 @@ public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
                     _ => throw new InvalidOperationException()
                 };
 
-                var fileName = $"{tempDirectoryInfo.FullName}/{fileNameGuid}_{heightResolution}.mp4";
+                var fileName = $"{importerSettings.TempDirectoryPath.FullName}/{fileNameGuid}_{heightResolution}.mp4";
                 var args = new string[] {
                     $"-i",
                     originalVideoLocalFile.FilePath,
diff --git a/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
index ade2403..f43f3b2 100644
--- a/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/IYoutubeDownloader.cs
@@ -13,8 +13,6 @@
 //   limitations under the License.
 
 using Etherna.VideoImporter.Core.Models.Domain;
-using System.Collections.Generic;
-using System.IO;
 using System.Threading.Tasks;
 
 namespace Etherna.VideoImporter.Core.Utilities
@@ -22,7 +20,6 @@ namespace Etherna.VideoImporter.Core.Utilities
     public interface IYoutubeDownloader
     {
         Task<Video> GetVideoAsync(
-            YouTubeVideoMetadataBase videoMetadata,
-            ImporterSettings importerSettings);
+            YouTubeVideoMetadataBase videoMetadata);
     }
 }
\ No newline at end of file
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 75e0ddf..48d5e38 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -36,8 +36,8 @@ public class YoutubeDownloader : IYoutubeDownloader
     {
         // Fields.
         private readonly IEncoderService encoderService;
+        private readonly ImporterSettings importerSettings;
         private readonly YoutubeClient youtubeClient;
-        private readonly DirectoryInfo tempDirectoryInfo;
 
         // Constructor.
         public YoutubeDownloader(
@@ -50,18 +50,14 @@ public YoutubeDownloader(
 
             this.encoderService = encoderService;
             this.youtubeClient = youtubeClient;
-            tempDirectoryInfo = Directory.CreateDirectory(importerSettingsOption.Value.TempDirectoryPath);
+            importerSettings = importerSettingsOption.Value;
         }
 
         // Methods.
-        public async Task<Video> GetVideoAsync(
-            YouTubeVideoMetadataBase videoMetadata,
-            ImporterSettings importerSettings)
+        public async Task<Video> GetVideoAsync(YouTubeVideoMetadataBase videoMetadata)
         {
             if (videoMetadata is null)
                 throw new ArgumentNullException(nameof(videoMetadata));
-            if (importerSettings is null)
-                throw new ArgumentNullException(nameof(importerSettings));
 
             // Get manifest data.
             var youtubeStreamsManifest = await youtubeClient.Videos.Streams.GetManifestAsync(videoMetadata.YoutubeId);
@@ -107,7 +103,7 @@ private async Task<ThumbnailLocalFile> DownloadThumbnailAsync(
             if (thumbnail is null)
                 throw new ArgumentNullException(nameof(thumbnail));
 
-            string thumbnailFilePath = Path.Combine(tempDirectoryInfo.FullName, $"{videoTitle.ToSafeFileName()}_thumb.jpg");
+            string thumbnailFilePath = Path.Combine(importerSettings.TempDirectoryPath.FullName, $"{videoTitle.ToSafeFileName()}_thumb.jpg");
 
             for (int i = 0; i <= CommonConsts.DownloadMaxRetry; i++)
             {
@@ -147,7 +143,7 @@ private async Task<VideoLocalFile> DownloadVideoAsync(
             string videoTitle)
         {
             var videoFileName = $"{videoTitle.ToSafeFileName()}_{videoOnlyStream.VideoResolution}.{videoOnlyStream.Container}";
-            var videoFilePath = Path.Combine(tempDirectoryInfo.FullName, videoFileName);
+            var videoFilePath = Path.Combine(importerSettings.TempDirectoryPath.FullName, videoFileName);
             var videoQualityLabel = videoOnlyStream.VideoQuality.Label;
 
             // Download video.
@@ -206,7 +202,7 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
                 using SKImage scaledImage = SKImage.FromBitmap(scaledBitmap);
                 using SKData data = scaledImage.Encode();
 
-                var thumbnailResizedPath = Path.Combine(tempDirectoryInfo.FullName, $"thumb_{responsiveWidthSize}_{responsiveHeightSize}_{Guid.NewGuid()}.jpg");
+                var thumbnailResizedPath = Path.Combine(importerSettings.TempDirectoryPath.FullName, $"thumb_{responsiveWidthSize}_{responsiveHeightSize}_{Guid.NewGuid()}.jpg");
                 using FileStream outputFileStream = new(thumbnailResizedPath, FileMode.CreateNew);
                 await data.AsStream().CopyToAsync(outputFileStream);
 
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index b40c7ab..07eabda 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -240,6 +240,9 @@ static async Task Main(string[] args)
             if (newVersionAvaiable && !ignoreNewVersionsOfImporter)
                 return;
 
+            // Create temp dir.
+            var tempDir = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier + "Devcon"));
+
             // Setup DI.
             var services = new ServiceCollection();
 
@@ -261,7 +264,7 @@ static async Task Main(string[] args)
                 skip720,
                 skip480,
                 skip360,
-                Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier + "Devcon"),
+                tempDir,
                 ttlPostageStamp,
                 unpinRemovedVideos,
                 userEthAddr)
diff --git a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
index 0646ddf..1bb4321 100644
--- a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
@@ -65,8 +65,7 @@ public MdVideoProvider(
 
         // Methods.
         public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata) => youtubeDownloader.GetVideoAsync(
-            videoMetadata as MdFileVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(MdFileVideoMetadata)}", nameof(videoMetadata)),
-            importerSettings);
+            videoMetadata as MdFileVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(MdFileVideoMetadata)}", nameof(videoMetadata)));
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index db807ee..8cabbbe 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -258,6 +258,9 @@ static async Task Main(string[] args)
             if (newVersionAvaiable && !ignoreNewVersionsOfImporter)
                 return;
 
+            // Create temp dir.
+            var tempDir = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier));
+
             // Setup DI.
             var services = new ServiceCollection();
 
@@ -279,7 +282,7 @@ static async Task Main(string[] args)
                 skip720,
                 skip480,
                 skip360,
-                Path.Combine(Path.GetTempPath(), CommonConsts.ImporterIdentifier),
+                tempDir,
                 ttlPostageStamp,
                 unpinRemovedVideos,
                 userEthAddr)
diff --git a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
index 4785927..c1c5cb3 100644
--- a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
@@ -57,8 +57,7 @@ public YouTubeChannelVideoProvider(
 
         // Methods.
         public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata) => youtubeDownloader.GetVideoAsync(
-            videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)),
-            importerSettings);
+            videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)));
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {
diff --git a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
index 3ac667c..8f9514d 100644
--- a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
@@ -54,8 +54,7 @@ public YouTubeSingleVideoProvider(
 
         // Methods.
         public Task<Video> GetVideoAsync(VideoMetadataBase videoMetadata) => youtubeDownloader.GetVideoAsync(
-            videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)),
-            importerSettings);
+            videoMetadata as YouTubeVideoMetadata ?? throw new ArgumentException($"Metadata bust be of type {nameof(YouTubeVideoMetadata)}", nameof(videoMetadata)));
 
         public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         {

From 7b3b76a4057bad039ddaa81fe99e0b4f908b4375 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Tue, 11 Apr 2023 18:08:32 +0200
Subject: [PATCH 13/22] Settings refactory

---
 .../EthernaVideoImporter.cs                   | 13 +++--
 .../Extensions/ServiceCollectionExtensions.cs | 57 ++++++++++++-------
 .../ImporterSettings.cs                       | 29 ----------
 .../Services/EncoderService.cs                | 11 +++-
 .../Services/VideoUploaderService.cs          | 14 +++--
 .../Settings/FFMpegSettings.cs                |  8 +++
 .../Settings/ImporterSettings.cs              | 17 ++++++
 .../Settings/UploadSettings.cs                | 18 ++++++
 .../Utilities/YoutubeDownloader.cs            | 26 +++++----
 src/EthernaVideoImporter.Devcon/Program.cs    | 45 ++++++++-------
 .../Services/DevconLinkReporterService.cs     |  1 +
 .../Services/MdVideoProvider.cs               |  7 ++-
 src/EthernaVideoImporter/Program.cs           | 53 +++++++++--------
 .../Services/YouTubeChannelVideoProvider.cs   | 16 ++++--
 .../Services/YouTubeSingleVideoProvider.cs    |  9 ++-
 15 files changed, 197 insertions(+), 127 deletions(-)
 delete mode 100644 src/EthernaVideoImporter.Core/ImporterSettings.cs
 create mode 100644 src/EthernaVideoImporter.Core/Settings/FFMpegSettings.cs
 create mode 100644 src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs
 create mode 100644 src/EthernaVideoImporter.Core/Settings/UploadSettings.cs

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 12962dc..7ce0e67 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -19,11 +19,11 @@
 using Etherna.VideoImporter.Core.Models.ManifestDtos;
 using Etherna.VideoImporter.Core.Models.ModelView;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -40,6 +40,7 @@ public class EthernaVideoImporter
         private readonly IMigrationService migrationService;
         private readonly IVideoUploaderService videoUploaderService;
         private readonly IVideoProvider videoProvider;
+        private readonly UploadSettings uploadSettings;
 
         // Constructor.
         public EthernaVideoImporter(
@@ -50,7 +51,8 @@ public EthernaVideoImporter(
             IVideoProvider videoProvider,
             IVideoUploaderService videoUploaderService,
             IMigrationService migrationService,
-            IOptions<ImporterSettings> importerSettingsOption)
+            IOptions<ImporterSettings> importerSettingsOption,
+            IOptions<UploadSettings> uploadSettingsOption)
         {
             if (cleanerVideoService is null)
                 throw new ArgumentNullException(nameof(cleanerVideoService));
@@ -62,6 +64,8 @@ public EthernaVideoImporter(
                 throw new ArgumentNullException(nameof(videoUploaderService));
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (uploadSettingsOption is null)
+                throw new ArgumentNullException(nameof(uploadSettingsOption));
 
             this.cleanerVideoService = cleanerVideoService;
             this.gatewayClient = gatewayClient;
@@ -69,8 +73,9 @@ public EthernaVideoImporter(
             this.importerSettings = importerSettingsOption.Value;
             this.linkReporterService = linkReporterService;
             this.migrationService = migrationService;
-            this.videoProvider = videoProvider;
+            this.uploadSettings = uploadSettingsOption.Value;
             this.videoUploaderService = videoUploaderService;
+            this.videoProvider = videoProvider;
         }
 
         // Public methods.
@@ -163,7 +168,7 @@ public async Task RunAsync()
 
                             // Upload new manifest.
                             var metadataVideo = new ManifestDto(video, alreadyPresentVideo.LastValidManifest.BatchId, importerSettings.UserEthAddr);
-                            updatedPermalinkHash = await videoUploaderService.UploadVideoManifestAsync(metadataVideo, importerSettings.PinVideos, importerSettings.OfferVideos);
+                            updatedPermalinkHash = await videoUploaderService.UploadVideoManifestAsync(metadataVideo, uploadSettings.PinVideos, uploadSettings.OfferVideos);
 
                             // Update on index.
                             await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
index 6d4d83e..0f9e933 100644
--- a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -2,6 +2,7 @@
 using Etherna.BeeNet.Clients.GatewayApi;
 using Etherna.ServicesClient;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.IO;
@@ -11,51 +12,67 @@ namespace Etherna.VideoImporter.Core.Extensions
 {
     public static class ServiceCollectionExtensions
     {
-        public static IServiceCollection AddImportSettings(
+        public static IServiceCollection ConfigureFFMpegSettings(
+            this IServiceCollection services,
+            string ffMpegBinaryPath,
+            string ffMpegFolderPath)
+        {
+            return services.Configure<FFMpegSettings>(options =>
+            {
+                options.FFMpegBinaryPath = ffMpegBinaryPath;
+                options.FFMpegFolderPath = ffMpegFolderPath;
+            });
+        }
+
+        public static IServiceCollection ConfigureImportSettings(
             this IServiceCollection services,
-            bool acceptPurchaseOfAllBatches,
             bool deleteExogenousVideos,
             bool deleteVideosMissingFromSource,
-            string ffMpegBinaryPath,
-            string ffMpegFolderPath,
             bool forceUploadVideo,
             bool ignoreNewVersionsOfImporter,
-            bool includeAudioTrack,
-            bool offerVideos,
-            bool pinVideos,
             string sourceUri,
-            bool skip1440,
-            bool skip1080,
-            bool skip720,
-            bool skip480,
-            bool skip360,
             DirectoryInfo tempDirPath,
-            int ttlPostageStamp,
             bool unpinRemovedVideos,
             string userEthAddr)
         {
             return services.Configure<ImporterSettings>(options =>
             {
-                options.AcceptPurchaseOfAllBatches = acceptPurchaseOfAllBatches;
                 options.DeleteExogenousVideos = deleteExogenousVideos;
                 options.DeleteVideosMissingFromSource = deleteVideosMissingFromSource;
-                options.FFMpegBinaryPath = ffMpegBinaryPath;
-                options.FFMpegFolderPath = ffMpegFolderPath;
                 options.ForceUploadVideo = forceUploadVideo;
                 options.IgnoreNewVersionsOfImporter = ignoreNewVersionsOfImporter;
+                options.SourceUri = sourceUri;
+                options.TempDirectoryPath = tempDirPath;
+                options.UnpinRemovedVideos = unpinRemovedVideos;
+                options.UserEthAddr = userEthAddr;
+            });
+        }
+
+        public static IServiceCollection ConfigureUploadSettings(
+            this IServiceCollection services,
+            bool acceptPurchaseOfAllBatches,
+            bool includeAudioTrack,
+            bool offerVideos,
+            bool pinVideos,
+            bool skip1440,
+            bool skip1080,
+            bool skip720,
+            bool skip480,
+            bool skip360,
+            int ttlPostageStamp)
+        {
+            return services.Configure<UploadSettings>(options =>
+            {
+                options.AcceptPurchaseOfAllBatches = acceptPurchaseOfAllBatches;
                 options.IncludeAudioTrack = includeAudioTrack;
                 options.OfferVideos = offerVideos;
                 options.PinVideos = pinVideos;
-                options.SourceUri = sourceUri;
                 options.Skip1440 = skip1440;
                 options.Skip1080 = skip1080;
                 options.Skip720 = skip720;
                 options.Skip480 = skip480;
                 options.Skip360 = skip360;
-                options.TempDirectoryPath = tempDirPath;
                 options.TTLPostageStamp = TimeSpan.FromSeconds(ttlPostageStamp);
-                options.UnpinRemovedVideos = unpinRemovedVideos;
-                options.UserEthAddr = userEthAddr;
             });
         }
 
diff --git a/src/EthernaVideoImporter.Core/ImporterSettings.cs b/src/EthernaVideoImporter.Core/ImporterSettings.cs
deleted file mode 100644
index 45a75d4..0000000
--- a/src/EthernaVideoImporter.Core/ImporterSettings.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System;
-using System.IO;
-
-namespace Etherna.VideoImporter.Core
-{
-    public class ImporterSettings
-    {
-        public bool AcceptPurchaseOfAllBatches { get; set; }
-        public bool DeleteExogenousVideos { get; set; }
-        public bool DeleteVideosMissingFromSource { get; set; }
-        public string FFMpegBinaryPath { get; set; } = default!;
-        public string FFMpegFolderPath { get; set; } = default!;
-        public bool ForceUploadVideo { get; set; }
-        public bool IgnoreNewVersionsOfImporter { get; set; }
-        public bool IncludeAudioTrack { get; set; }
-        public bool OfferVideos { get; set; }
-        public bool PinVideos { get; set; }
-        public string SourceUri { get; set; } = default!;
-        public bool Skip360 { get; set; }
-        public bool Skip480 { get; set; }
-        public bool Skip720 { get; set; }
-        public bool Skip1080 { get; set; }
-        public bool Skip1440 { get; set; }
-        public DirectoryInfo TempDirectoryPath { get; set; } = default!;
-        public TimeSpan TTLPostageStamp { get; set; }
-        public bool UnpinRemovedVideos { get; set; }
-        public string UserEthAddr { get; set; } = default!;
-    }
-}
diff --git a/src/EthernaVideoImporter.Core/Services/EncoderService.cs b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
index dcc7e6f..58dffa8 100644
--- a/src/EthernaVideoImporter.Core/Services/EncoderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/EncoderService.cs
@@ -1,4 +1,5 @@
 using Etherna.VideoImporter.Core.Models.Domain;
+using Etherna.VideoImporter.Core.Settings;
 using Medallion.Shell;
 using Microsoft.Extensions.Options;
 using System;
@@ -13,19 +14,25 @@ public partial class EncoderService : IEncoderService
     {
         // Fields.
         private readonly List<Command> activedCommands = new();
+        private readonly FFMpegSettings ffMpegSettings;
         private readonly ImporterSettings importerSettings;
 
         // Constructor.
-        public EncoderService(IOptions<ImporterSettings> importerSettingsOption)
+        public EncoderService(
+            IOptions<FFMpegSettings> ffMpegSettingsOption,
+            IOptions<ImporterSettings> importerSettingsOption)
         {
+            if (ffMpegSettingsOption is null)
+                throw new ArgumentNullException(nameof(ffMpegSettingsOption));
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
 
+            this.ffMpegSettings = ffMpegSettingsOption.Value;
             this.importerSettings = importerSettingsOption.Value;
         }
 
         // Properties.
-        public string FFMpegBinaryPath { get => importerSettings.FFMpegBinaryPath; }
+        public string FFMpegBinaryPath { get => ffMpegSettings.FFMpegBinaryPath; }
 
         // Methods.
         public async Task<IEnumerable<VideoLocalFile>> EncodeVideosAsync(
diff --git a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
index 62f608d..d75345d 100644
--- a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
@@ -17,6 +17,7 @@
 using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Models.ManifestDtos;
+using Etherna.VideoImporter.Core.Settings;
 using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
@@ -40,19 +41,24 @@ public sealed class VideoUploaderService : IVideoUploaderService
         private readonly IGatewayService gatewayService;
         private readonly IEthernaUserClients ethernaUserClients;
         private readonly ImporterSettings importerSettings;
+        private readonly UploadSettings uploadSettings;
 
         // Constructor.
         public VideoUploaderService(
             IGatewayService gatewayService,
             IEthernaUserClients ethernaUserClients,
-            IOptions<ImporterSettings> importerSettingsOption)
+            IOptions<ImporterSettings> importerSettingsOption,
+            IOptions<UploadSettings> uploadSettingsOption)
         {
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (uploadSettingsOption is null)
+                throw new ArgumentNullException(nameof(uploadSettingsOption));
 
             this.gatewayService = gatewayService;
             this.ethernaUserClients = ethernaUserClients;
             this.importerSettings = importerSettingsOption.Value;
+            this.uploadSettings = uploadSettingsOption.Value;
         }
 
         // Public methods.
@@ -73,12 +79,12 @@ public async Task UploadVideoAsync(
 
             //calculate amount
             var currentPrice = await gatewayService.GetCurrentChainPriceAsync();
-            var amount = (long)(importerSettings.TTLPostageStamp.TotalSeconds * currentPrice / CommonConsts.GnosisBlockTime.TotalSeconds);
+            var amount = (long)(uploadSettings.TTLPostageStamp.TotalSeconds * currentPrice / CommonConsts.GnosisBlockTime.TotalSeconds);
             var bzzPrice = amount * Math.Pow(2, batchDepth) / BzzDecimalPlacesToUnit;
 
             Console.WriteLine($"Creating postage batch... Depth: {batchDepth} Amount: {amount} BZZ price: {bzzPrice}");
 
-            if (!importerSettings.AcceptPurchaseOfAllBatches)
+            if (!uploadSettings.AcceptPurchaseOfAllBatches)
             {
                 bool validSelection = false;
 
@@ -92,7 +98,7 @@ public async Task UploadVideoAsync(
                             validSelection = true;
                             break;
                         case ConsoleKeyInfo ak when ak.Key == ConsoleKey.A:
-                            importerSettings.AcceptPurchaseOfAllBatches = true;
+                            uploadSettings.AcceptPurchaseOfAllBatches = true;
                             validSelection = true;
                             break;
                         case ConsoleKeyInfo nk when nk.Key == ConsoleKey.N:
diff --git a/src/EthernaVideoImporter.Core/Settings/FFMpegSettings.cs b/src/EthernaVideoImporter.Core/Settings/FFMpegSettings.cs
new file mode 100644
index 0000000..1ee6197
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/Settings/FFMpegSettings.cs
@@ -0,0 +1,8 @@
+namespace Etherna.VideoImporter.Core.Settings
+{
+    public class FFMpegSettings
+    {
+        public string FFMpegBinaryPath { get; set; } = default!;
+        public string FFMpegFolderPath { get; set; } = default!;
+    }
+}
diff --git a/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs b/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs
new file mode 100644
index 0000000..854caa9
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs
@@ -0,0 +1,17 @@
+using System;
+using System.IO;
+
+namespace Etherna.VideoImporter.Core.Settings
+{
+    public class ImporterSettings
+    {
+        public bool DeleteExogenousVideos { get; set; }
+        public bool DeleteVideosMissingFromSource { get; set; }
+        public bool ForceUploadVideo { get; set; }
+        public bool IgnoreNewVersionsOfImporter { get; set; }
+        public string SourceUri { get; set; } = default!;
+        public DirectoryInfo TempDirectoryPath { get; set; } = default!;
+        public bool UnpinRemovedVideos { get; set; }
+        public string UserEthAddr { get; set; } = default!;
+    }
+}
diff --git a/src/EthernaVideoImporter.Core/Settings/UploadSettings.cs b/src/EthernaVideoImporter.Core/Settings/UploadSettings.cs
new file mode 100644
index 0000000..465ca08
--- /dev/null
+++ b/src/EthernaVideoImporter.Core/Settings/UploadSettings.cs
@@ -0,0 +1,18 @@
+using System;
+
+namespace Etherna.VideoImporter.Core.Settings
+{
+    public class UploadSettings
+    {
+        public bool AcceptPurchaseOfAllBatches { get; set; }
+        public bool IncludeAudioTrack { get; set; }
+        public bool OfferVideos { get; set; }
+        public bool PinVideos { get; set; }
+        public bool Skip360 { get; set; }
+        public bool Skip480 { get; set; }
+        public bool Skip720 { get; set; }
+        public bool Skip1080 { get; set; }
+        public bool Skip1440 { get; set; }
+        public TimeSpan TTLPostageStamp { get; set; }
+    }
+}
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 48d5e38..b82cc83 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -15,6 +15,7 @@
 using Etherna.VideoImporter.Core.Extensions;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Microsoft.Extensions.Options;
 using SkiaSharp;
 using System;
@@ -37,20 +38,25 @@ public class YoutubeDownloader : IYoutubeDownloader
         // Fields.
         private readonly IEncoderService encoderService;
         private readonly ImporterSettings importerSettings;
-        private readonly YoutubeClient youtubeClient;
+        private readonly YoutubeClient youtubeClient; 
+        private readonly UploadSettings uploadSettings;
 
         // Constructor.
         public YoutubeDownloader(
             IEncoderService encoderService,
             YoutubeClient youtubeClient,
-            IOptions<ImporterSettings> importerSettingsOption)
+            IOptions<ImporterSettings> importerSettingsOption,
+            IOptions<UploadSettings> uploadSettingsOption)
         {
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (uploadSettingsOption is null)
+                throw new ArgumentNullException(nameof(uploadSettingsOption));
 
             this.encoderService = encoderService;
             this.youtubeClient = youtubeClient;
             importerSettings = importerSettingsOption.Value;
+            uploadSettings = uploadSettingsOption.Value;
         }
 
         // Methods.
@@ -78,8 +84,8 @@ public async Task<Video> GetVideoAsync(YouTubeVideoMetadataBase videoMetadata)
             // Transcode video resolutions.
             var encodedFiles = await encoderService.EncodeVideosAsync(
                 videoLocalFile,
-                GetSupportedHeightResolutions(importerSettings),
-                importerSettings.IncludeAudioTrack);
+                GetSupportedHeightResolutions(uploadSettings),
+                uploadSettings.IncludeAudioTrack);
 
             // Get thumbnail.
             List<ThumbnailLocalFile> thumbnailFiles = new();
@@ -221,18 +227,18 @@ private async Task<List<ThumbnailLocalFile>> DownscaleThumbnailAsync(
             return thumbnails;
         }
 
-        private static IEnumerable<int> GetSupportedHeightResolutions(ImporterSettings importerSettings)
+        private static IEnumerable<int> GetSupportedHeightResolutions(UploadSettings uploadSettings)
         {
             var supportedHeightResolutions = new List<int>();
-            if (!importerSettings.Skip1440)
+            if (!uploadSettings.Skip1440)
                 supportedHeightResolutions.Add(1440);
-            if (!importerSettings.Skip1080)
+            if (!uploadSettings.Skip1080)
                 supportedHeightResolutions.Add(1080);
-            if (!importerSettings.Skip720)
+            if (!uploadSettings.Skip720)
                 supportedHeightResolutions.Add(720);
-            if (!importerSettings.Skip480)
+            if (!uploadSettings.Skip480)
                 supportedHeightResolutions.Add(480);
-            if (!importerSettings.Skip360)
+            if (!uploadSettings.Skip360)
                 supportedHeightResolutions.Add(360);
 
             return supportedHeightResolutions;
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 07eabda..4eb88d6 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -247,27 +247,30 @@ static async Task Main(string[] args)
             var services = new ServiceCollection();
 
             //configure
-            services.AddImportSettings(
-                acceptPurchaseOfAllBatches,
-                deleteExogenousVideos,
-                deleteVideosMissingFromSource,
-                ffMpegBinaryPath,
-                ffMpegFolderPath,
-                forceUploadVideo,
-                ignoreNewVersionsOfImporter,
-                includeAudioTrack,
-                offerVideos,
-                pinVideos,
-                mdSourceFolderPath,
-                skip1440,
-                skip1080,
-                skip720,
-                skip480,
-                skip360,
-                tempDir,
-                ttlPostageStamp,
-                unpinRemovedVideos,
-                userEthAddr)
+            services
+                .ConfigureFFMpegSettings(
+                    ffMpegBinaryPath,
+                    ffMpegFolderPath)
+                .ConfigureImportSettings(
+                    deleteExogenousVideos,
+                    deleteVideosMissingFromSource,
+                    forceUploadVideo,
+                    ignoreNewVersionsOfImporter,
+                    mdSourceFolderPath,
+                    tempDir,
+                    unpinRemovedVideos,
+                    userEthAddr)
+                .ConfigureUploadSettings(
+                    acceptPurchaseOfAllBatches,
+                    includeAudioTrack,
+                    offerVideos,
+                    pinVideos,
+                    skip1440,
+                    skip1080,
+                    skip720,
+                    skip480,
+                    skip360,
+                    ttlPostageStamp)
             .AddLinkReporterService()
             .AddVideoProvider()
             .AddCommonServices(useBeeNativeNode)
diff --git a/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs b/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
index 7980fa6..99ff94a 100644
--- a/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
@@ -14,6 +14,7 @@
 
 using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
diff --git a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
index 1bb4321..744d726 100644
--- a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
@@ -12,9 +12,9 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Etherna.VideoImporter.Core.Utilities;
 using Etherna.VideoImporter.Devcon.Models.Domain;
 using Etherna.VideoImporter.Devcon.Models.MdDto;
@@ -48,7 +48,8 @@ internal sealed class MdVideoProvider : IVideoProvider
         // Constructor.
         public MdVideoProvider(
             IOptions<ImporterSettings> importerSettingsOption,
-            IEncoderService encoderService)
+            IEncoderService encoderService,
+            IOptions<UploadSettings> uploadSettingsOption)
         {
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
@@ -57,7 +58,7 @@ public MdVideoProvider(
 
             this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
-            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption);
+            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption, uploadSettingsOption);
         }
 
         // Properties.
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index 8cabbbe..a7c8242 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -265,31 +265,34 @@ static async Task Main(string[] args)
             var services = new ServiceCollection();
 
             //configure
-            services.AddImportSettings(
-                acceptPurchaseOfAllBatches,
-                deleteExogenousVideos,
-                deleteVideosMissingFromSource,
-                ffMpegBinaryPath,
-                ffMpegFolderPath,
-                forceUploadVideo,
-                ignoreNewVersionsOfImporter,
-                includeAudioTrack,
-                offerVideos,
-                pinVideos,
-                sourceUri,
-                skip1440,
-                skip1080,
-                skip720,
-                skip480,
-                skip360,
-                tempDir,
-                ttlPostageStamp,
-                unpinRemovedVideos,
-                userEthAddr)
-            .AddLinkReporterService()
-            .AddVideoProvider(sourceType.Value)
-            .AddCommonServices(useBeeNativeNode)
-            .ConfigureHttpClient(authResult.RefreshTokenHandler);
+            services
+                .ConfigureFFMpegSettings(
+                    ffMpegBinaryPath,
+                    ffMpegFolderPath)
+                .ConfigureImportSettings(
+                    deleteExogenousVideos,
+                    deleteVideosMissingFromSource,
+                    forceUploadVideo,
+                    ignoreNewVersionsOfImporter,
+                    sourceUri,
+                    tempDir,
+                    unpinRemovedVideos,
+                    userEthAddr)
+                .ConfigureUploadSettings(
+                    acceptPurchaseOfAllBatches,
+                    includeAudioTrack,
+                    offerVideos,
+                    pinVideos,
+                    skip1440,
+                    skip1080,
+                    skip720,
+                    skip480,
+                    skip360,
+                    ttlPostageStamp)
+                .AddLinkReporterService()
+                .AddVideoProvider(sourceType.Value)
+                .AddCommonServices(useBeeNativeNode)
+                .ConfigureHttpClient(authResult.RefreshTokenHandler);
 
             var serviceProvider = services.BuildServiceProvider();
 
diff --git a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
index c1c5cb3..e358b9e 100644
--- a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
@@ -12,15 +12,14 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Etherna.VideoImporter.Core.Utilities;
 using Etherna.VideoImporter.Models.Domain;
 using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
@@ -36,20 +35,25 @@ public sealed class YouTubeChannelVideoProvider : IVideoProvider
         private readonly ImporterSettings importerSettings;
         private readonly YoutubeClient youtubeClient;
         private readonly IYoutubeDownloader youtubeDownloader;
+        private readonly UploadSettings uploadSettings;
 
         // Constructor.
         public YouTubeChannelVideoProvider(
+            IEncoderService encoderService,
             IOptions<ImporterSettings> importerSettingsOption,
-            IEncoderService encoderService)
+            IOptions<UploadSettings> uploadSettingsOption)
         {
-            if (importerSettingsOption is null)
-                throw new ArgumentNullException(nameof(importerSettingsOption));
             if (encoderService is null)
                 throw new ArgumentNullException(nameof(encoderService));
+            if (importerSettingsOption is null)
+                throw new ArgumentNullException(nameof(importerSettingsOption));
+            if (uploadSettingsOption is null)
+                throw new ArgumentNullException(nameof(uploadSettingsOption));
 
             this.importerSettings = importerSettingsOption.Value;
+            this.uploadSettings = uploadSettingsOption.Value;
             youtubeClient = new();
-            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption);
+            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption, uploadSettingsOption);
         }
 
         // Properties.
diff --git a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
index 8f9514d..4dbcefb 100644
--- a/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeSingleVideoProvider.cs
@@ -12,9 +12,9 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-using Etherna.VideoImporter.Core;
 using Etherna.VideoImporter.Core.Models.Domain;
 using Etherna.VideoImporter.Core.Services;
+using Etherna.VideoImporter.Core.Settings;
 using Etherna.VideoImporter.Core.Utilities;
 using Etherna.VideoImporter.Models.Domain;
 using Microsoft.Extensions.Options;
@@ -37,16 +37,19 @@ public sealed class YouTubeSingleVideoProvider : IVideoProvider
         // Constructor.
         public YouTubeSingleVideoProvider(
             IOptions<ImporterSettings> importerSettingsOption,
-            IEncoderService encoderService)
+            IEncoderService encoderService,
+            IOptions<UploadSettings> uploadSettingsOption)
         {
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
             if (encoderService is null)
                 throw new ArgumentNullException(nameof(encoderService));
+            if (uploadSettingsOption is null)
+                throw new ArgumentNullException(nameof(uploadSettingsOption));
 
             this.importerSettings = importerSettingsOption.Value;
             youtubeClient = new();
-            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption);
+            youtubeDownloader = new YoutubeDownloader(encoderService, youtubeClient, importerSettingsOption, uploadSettingsOption);
         }
 
         // Properties.

From e226a7346a894febc12b28e40497f6289fcd7b11 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Tue, 11 Apr 2023 18:15:11 +0200
Subject: [PATCH 14/22] refactory settings

---
 .../EthernaVideoImporter.cs                   | 11 +++------
 .../Services/IVideoUploaderService.cs         | 14 ++---------
 .../Services/VideoUploaderService.cs          | 24 +++++++------------
 3 files changed, 14 insertions(+), 35 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 7ce0e67..fbe2e64 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -40,7 +40,6 @@ public class EthernaVideoImporter
         private readonly IMigrationService migrationService;
         private readonly IVideoUploaderService videoUploaderService;
         private readonly IVideoProvider videoProvider;
-        private readonly UploadSettings uploadSettings;
 
         // Constructor.
         public EthernaVideoImporter(
@@ -51,8 +50,7 @@ public EthernaVideoImporter(
             IVideoProvider videoProvider,
             IVideoUploaderService videoUploaderService,
             IMigrationService migrationService,
-            IOptions<ImporterSettings> importerSettingsOption,
-            IOptions<UploadSettings> uploadSettingsOption)
+            IOptions<ImporterSettings> importerSettingsOption)
         {
             if (cleanerVideoService is null)
                 throw new ArgumentNullException(nameof(cleanerVideoService));
@@ -64,8 +62,6 @@ public EthernaVideoImporter(
                 throw new ArgumentNullException(nameof(videoUploaderService));
             if (importerSettingsOption is null)
                 throw new ArgumentNullException(nameof(importerSettingsOption));
-            if (uploadSettingsOption is null)
-                throw new ArgumentNullException(nameof(uploadSettingsOption));
 
             this.cleanerVideoService = cleanerVideoService;
             this.gatewayClient = gatewayClient;
@@ -73,7 +69,6 @@ public EthernaVideoImporter(
             this.importerSettings = importerSettingsOption.Value;
             this.linkReporterService = linkReporterService;
             this.migrationService = migrationService;
-            this.uploadSettings = uploadSettingsOption.Value;
             this.videoUploaderService = videoUploaderService;
             this.videoProvider = videoProvider;
         }
@@ -168,7 +163,7 @@ public async Task RunAsync()
 
                             // Upload new manifest.
                             var metadataVideo = new ManifestDto(video, alreadyPresentVideo.LastValidManifest.BatchId, importerSettings.UserEthAddr);
-                            updatedPermalinkHash = await videoUploaderService.UploadVideoManifestAsync(metadataVideo, uploadSettings.PinVideos, uploadSettings.OfferVideos);
+                            updatedPermalinkHash = await videoUploaderService.UploadVideoManifestAsync(metadataVideo);
 
                             // Update on index.
                             await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
@@ -211,7 +206,7 @@ await ethernaUserClients.IndexClient.VideosClient.VideosPutAsync(
                         }
 
                         // Upload video and all related data.
-                        //await videoUploaderService.UploadVideoAsync(video, importerSettings.PinVideos, importerSettings.OfferVideos);
+                        await videoUploaderService.UploadVideoAsync(video);
 
                         updatedIndexId = video.EthernaIndexId!;
                         updatedPermalinkHash = video.EthernaPermalinkHash!;
diff --git a/src/EthernaVideoImporter.Core/Services/IVideoUploaderService.cs b/src/EthernaVideoImporter.Core/Services/IVideoUploaderService.cs
index f12dda9..db4281e 100644
--- a/src/EthernaVideoImporter.Core/Services/IVideoUploaderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/IVideoUploaderService.cs
@@ -27,23 +27,13 @@ public interface IVideoUploaderService
         /// Start to upload all video data (manifest, video with all avaiable resolutions, thumbnail, index).
         /// </summary>
         /// <param name="video">Video data</param>
-        /// <param name="pinVideo">Pin video</param>
-        /// <param name="offerVideo">Offer video contents for free</param>
-        public Task UploadVideoAsync(
-            Video video,
-            bool pinVideo,
-            bool offerVideo);
+        public Task UploadVideoAsync(Video video);
 
         /// <summary>
         /// Upload a new video manifest
         /// </summary>
         /// <param name="videoManifest">The video manifest</param>
-        /// <param name="pinManifest">True if need to pin manifest</param>
-        /// <param name="offerManifest">Offer manifest for free</param>
         /// <returns>The new manifest hash</returns>
-        Task<string> UploadVideoManifestAsync(
-            ManifestDto videoManifest,
-            bool pinManifest,
-            bool offerManifest);
+        Task<string> UploadVideoManifestAsync(ManifestDto videoManifest);
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
index d75345d..88775ec 100644
--- a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
@@ -62,10 +62,7 @@ public VideoUploaderService(
         }
 
         // Public methods.
-        public async Task UploadVideoAsync(
-            Video video,
-            bool pinVideo,
-            bool offerVideo)
+        public async Task UploadVideoAsync(Video video)
         {
             if (video is null)
                 throw new ArgumentNullException(nameof(video));
@@ -138,7 +135,7 @@ public async Task UploadVideoAsync(
                         encodedFile.SetSwarmHash(await gatewayService.UploadFilesAsync(
                             batchId,
                             files: new List<FileParameterInput> { fileParameterInput },
-                            pinVideo));
+                            uploadSettings.PinVideos));
                         uploadSucceeded = true;
                     }
                     catch (Exception ex)
@@ -154,7 +151,7 @@ public async Task UploadVideoAsync(
                 if (!uploadSucceeded)
                     throw new InvalidOperationException($"Can't upload file after {UploadMaxRetry} retries");
 
-                if (offerVideo)
+                if (uploadSettings.OfferVideos)
                     await gatewayService.OfferContentAsync(encodedFile.SwarmHash!);
             }
 
@@ -176,7 +173,7 @@ public async Task UploadVideoAsync(
                         thumbnailReference = await gatewayService.UploadFilesAsync(
                             batchId,
                             new List<FileParameterInput> { fileThumbnailParameterInput },
-                            pinVideo);
+                            uploadSettings.PinVideos);
                         uploadSucceeded = true;
                     }
                     catch (Exception ex)
@@ -194,7 +191,7 @@ public async Task UploadVideoAsync(
 
                 thumbnailFile.SetSwarmHash(thumbnailReference);
 
-                if (offerVideo)
+                if (uploadSettings.OfferVideos)
                     await gatewayService.OfferContentAsync(thumbnailReference);
             }
 
@@ -206,7 +203,7 @@ public async Task UploadVideoAsync(
                 {
                     try
                     {
-                        video.EthernaPermalinkHash = await UploadVideoManifestAsync(metadataVideo, pinVideo, offerVideo);
+                        video.EthernaPermalinkHash = await UploadVideoManifestAsync(metadataVideo);
                         uploadSucceeded = true;
                     }
                     catch (Exception ex)
@@ -238,10 +235,7 @@ public async Task UploadVideoAsync(
             Console.WriteLine($"Listed on etherna index with Id: {video.EthernaIndexId}");
         }
 
-        public async Task<string> UploadVideoManifestAsync(
-            ManifestDto videoManifest,
-            bool pinManifest,
-            bool offerManifest)
+        public async Task<string> UploadVideoManifestAsync(ManifestDto videoManifest)
         {
             if (videoManifest is null)
                 throw new ArgumentNullException(nameof(videoManifest));
@@ -267,7 +261,7 @@ public async Task<string> UploadVideoManifestAsync(
                                 "metadata.json",
                                 "application/json")
                         },
-                        pinManifest);
+                        uploadSettings.PinVideos);
                     uploadSucceeded = true;
                 }
                 catch (Exception ex)
@@ -283,7 +277,7 @@ public async Task<string> UploadVideoManifestAsync(
             if (!uploadSucceeded)
                 throw new InvalidOperationException($"Can't upload file after {UploadMaxRetry} retries");
 
-            if (offerManifest)
+            if (uploadSettings.OfferVideos)
                 await gatewayService.OfferContentAsync(manifestReference);
 
             return manifestReference;

From cedb3882e43a92bf7cf8e36f6a87bcdcf0a1bb70 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Tue, 11 Apr 2023 18:41:48 +0200
Subject: [PATCH 15/22] refactory ServiceCollectionExtensions

---
 .../Extensions/ServiceCollectionExtensions.cs | 98 ++++++++++++-------
 .../Services/BeeGatewayClientWrapper.cs       | 26 -----
 .../Services/EthernaUserClientsWrapper.cs     | 18 ----
 .../Settings/ImporterSettings.cs              |  4 +-
 src/EthernaVideoImporter.Devcon/Program.cs    | 18 +++-
 src/EthernaVideoImporter/Program.cs           | 13 ++-
 6 files changed, 89 insertions(+), 88 deletions(-)
 delete mode 100644 src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs
 delete mode 100644 src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs

diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
index 0f9e933..a29531c 100644
--- a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -12,17 +12,61 @@ namespace Etherna.VideoImporter.Core.Extensions
 {
     public static class ServiceCollectionExtensions
     {
+        public static IServiceCollection AddEthernaVideoImporterService(this IServiceCollection services) =>
+            services.AddTransient<EthernaVideoImporter>();
+
+        public static IServiceCollection AddBeeGatewayClientService(this IServiceCollection services) =>
+            services.AddTransient<IBeeGatewayClient>((sp) =>
+             {
+                 var httpClientFactory = sp.GetRequiredService<IHttpClientFactory>();
+                 return new BeeGatewayClient(
+                     httpClientFactory.CreateClient("ethernaClient"),
+                     new Uri(CommonConsts.EthernaGatewayUrl),
+                     CommonConsts.BeeNodeGatewayVersion);
+             });
+
+        public static IServiceCollection AddBeeNodeClientService(this IServiceCollection services) =>
+            services.AddTransient<IBeeNodeClient, BeeNodeClient>();
+
+        public static IServiceCollection AddCleanerVideoService(this IServiceCollection services) =>
+            services.AddTransient<ICleanerVideoService, CleanerVideoService>();
+
+        public static IServiceCollection AddEncoderService(this IServiceCollection services) =>
+            services.AddTransient<IEncoderService, EncoderService>();
+
+        public static IServiceCollection AddEthernaUserClientsService(this IServiceCollection services) =>
+            services.AddTransient<IEthernaUserClients>((sp) =>
+            {
+                var httpClientFactory = sp.GetRequiredService<IHttpClientFactory>();
+                return new EthernaUserClients(
+                            new Uri(CommonConsts.EthernaCreditUrl),
+                            new Uri(CommonConsts.EthernaGatewayUrl),
+                            new Uri(CommonConsts.EthernaIndexUrl),
+                            new Uri(CommonConsts.EthernaIndexUrl),
+                            () => httpClientFactory.CreateClient("ethernaClient"));
+            });
+
+        public static IServiceCollection AddGatewayService(this IServiceCollection services, bool useBeeNativeNode) =>
+                useBeeNativeNode ?
+                    services.AddTransient<IGatewayService, BeeGatewayService>() :
+                    services.AddTransient<IGatewayService, EthernaGatewayService>();
+        
+        public static IServiceCollection AddMigrationService(this IServiceCollection services) =>
+            services.AddTransient<IMigrationService, MigrationService>();
+
+        public static IServiceCollection AddVideoUploaderService(this IServiceCollection services) =>
+            services.AddTransient<IVideoUploaderService, VideoUploaderService>();
+
         public static IServiceCollection ConfigureFFMpegSettings(
             this IServiceCollection services,
             string ffMpegBinaryPath,
             string ffMpegFolderPath)
-        {
-            return services.Configure<FFMpegSettings>(options =>
+        =>
+            services.Configure<FFMpegSettings>(options =>
             {
                 options.FFMpegBinaryPath = ffMpegBinaryPath;
                 options.FFMpegFolderPath = ffMpegFolderPath;
             });
-        }
 
         public static IServiceCollection ConfigureImportSettings(
             this IServiceCollection services,
@@ -33,9 +77,10 @@ public static IServiceCollection ConfigureImportSettings(
             string sourceUri,
             DirectoryInfo tempDirPath,
             bool unpinRemovedVideos,
+            bool useBeeNativeNode,
             string userEthAddr)
-        {
-            return services.Configure<ImporterSettings>(options =>
+        =>
+            services.Configure<ImporterSettings>(options =>
             {
                 options.DeleteExogenousVideos = deleteExogenousVideos;
                 options.DeleteVideosMissingFromSource = deleteVideosMissingFromSource;
@@ -44,8 +89,20 @@ public static IServiceCollection ConfigureImportSettings(
                 options.SourceUri = sourceUri;
                 options.TempDirectoryPath = tempDirPath;
                 options.UnpinRemovedVideos = unpinRemovedVideos;
+                options.UseBeeNativeNode = useBeeNativeNode;
                 options.UserEthAddr = userEthAddr;
             });
+
+        public static IHttpClientBuilder AddEthernaHttpClient(
+            this IServiceCollection services,
+            DelegatingHandler delegatingHandler)
+        {
+            return services.AddHttpClient("ethernaClient", c =>
+            {
+                c.Timeout = TimeSpan.FromMinutes(30);
+                c.DefaultRequestHeaders.ConnectionClose = true; //fixes https://etherna.atlassian.net/browse/EVI-74
+            })
+            .ConfigurePrimaryHttpMessageHandler(() => delegatingHandler);
         }
 
         public static IServiceCollection ConfigureUploadSettings(
@@ -75,36 +132,5 @@ public static IServiceCollection ConfigureUploadSettings(
                 options.TTLPostageStamp = TimeSpan.FromSeconds(ttlPostageStamp);
             });
         }
-
-        public static IServiceCollection AddCommonServices(
-            this IServiceCollection services, 
-            bool useBeeNativeNode)
-        {
-            services
-            .AddTransient<EthernaVideoImporter>()
-            .AddTransient<IBeeGatewayClient, BeeGatewayClientWrapper>()
-            .AddTransient<IBeeNodeClient, BeeNodeClient>()
-            .AddTransient<ICleanerVideoService, CleanerVideoService>()
-            .AddTransient<IEthernaUserClients, EthernaUserClientsWrapper>()
-            .AddTransient<IEncoderService, EncoderService>()
-            .AddTransient<IMigrationService, MigrationService>()
-            .AddTransient<IVideoUploaderService, VideoUploaderService>();
-
-            return useBeeNativeNode ?
-                services.AddTransient<IGatewayService, BeeGatewayService>() :
-                services.AddTransient<IGatewayService, EthernaGatewayService>();
-        }
-
-        public static IHttpClientBuilder ConfigureHttpClient(
-            this IServiceCollection services, 
-            DelegatingHandler delegatingHandler)
-        {
-            return services.AddHttpClient("ethernaClient", c =>
-            {
-                c.Timeout = TimeSpan.FromMinutes(30);
-                c.DefaultRequestHeaders.ConnectionClose = true; //fixes https://etherna.atlassian.net/browse/EVI-74
-            })
-            .ConfigurePrimaryHttpMessageHandler(() => delegatingHandler);
-        }
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs b/src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs
deleted file mode 100644
index f4fe67c..0000000
--- a/src/EthernaVideoImporter.Core/Services/BeeGatewayClientWrapper.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using Etherna.BeeNet.Clients.GatewayApi;
-using System;
-using System.Net.Http;
-
-namespace Etherna.VideoImporter.Core.Services
-{
-    public class BeeGatewayClientWrapper : BeeGatewayClient
-    {
-        // Constructor.
-        public BeeGatewayClientWrapper(IHttpClientFactory httpClientFactory)
-            : base(
-                  PassThroughNonNull(httpClientFactory).CreateClient("ethernaClient"), 
-                  new Uri(CommonConsts.EthernaGatewayUrl), 
-                  CommonConsts.BeeNodeGatewayVersion)
-        { }
-
-        // Helpers.
-        private static IHttpClientFactory PassThroughNonNull(IHttpClientFactory httpClientFactory)
-        {
-            if (httpClientFactory is null)
-                throw new ArgumentNullException(nameof(httpClientFactory));
-
-            return httpClientFactory;
-        }
-    }
-}
diff --git a/src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs b/src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs
deleted file mode 100644
index c087d22..0000000
--- a/src/EthernaVideoImporter.Core/Services/EthernaUserClientsWrapper.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using Etherna.ServicesClient;
-using System;
-using System.Net.Http;
-
-namespace Etherna.VideoImporter.Core.Services
-{
-    public class EthernaUserClientsWrapper : EthernaUserClients
-    {
-        // Constructor.
-        public EthernaUserClientsWrapper(IHttpClientFactory httpClientFactory) 
-            : base(new Uri(CommonConsts.EthernaCreditUrl),
-                  new Uri(CommonConsts.EthernaGatewayUrl),
-                  new Uri(CommonConsts.EthernaIndexUrl),
-                  new Uri(CommonConsts.EthernaIndexUrl), 
-                  () => httpClientFactory.CreateClient("ethernaClient"))
-        {}
-    }
-}
diff --git a/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs b/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs
index 854caa9..aa27420 100644
--- a/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs
+++ b/src/EthernaVideoImporter.Core/Settings/ImporterSettings.cs
@@ -1,5 +1,4 @@
-using System;
-using System.IO;
+using System.IO;
 
 namespace Etherna.VideoImporter.Core.Settings
 {
@@ -12,6 +11,7 @@ public class ImporterSettings
         public string SourceUri { get; set; } = default!;
         public DirectoryInfo TempDirectoryPath { get; set; } = default!;
         public bool UnpinRemovedVideos { get; set; }
+        public bool UseBeeNativeNode { get; set; }
         public string UserEthAddr { get; set; } = default!;
     }
 }
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 4eb88d6..80256b7 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -23,6 +23,7 @@
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Security.AccessControl;
 using System.Threading.Tasks;
 
 namespace Etherna.VideoImporter.Devcon
@@ -259,6 +260,7 @@ static async Task Main(string[] args)
                     mdSourceFolderPath,
                     tempDir,
                     unpinRemovedVideos,
+                    useBeeNativeNode,
                     userEthAddr)
                 .ConfigureUploadSettings(
                     acceptPurchaseOfAllBatches,
@@ -271,10 +273,18 @@ static async Task Main(string[] args)
                     skip480,
                     skip360,
                     ttlPostageStamp)
-            .AddLinkReporterService()
-            .AddVideoProvider()
-            .AddCommonServices(useBeeNativeNode)
-            .ConfigureHttpClient(authResult.RefreshTokenHandler);
+                .AddBeeGatewayClientService()
+                .AddBeeNodeClientService()
+                .AddLinkReporterService()
+                .AddCleanerVideoService()
+                .AddEncoderService()
+                .AddEthernaUserClientsService()
+                .AddGatewayService(useBeeNativeNode)
+                .AddEthernaVideoImporterService()
+                .AddMigrationService()
+                .AddVideoUploaderService()
+                .AddVideoProvider()
+                .AddEthernaHttpClient(authResult.RefreshTokenHandler);
 
             var serviceProvider = services.BuildServiceProvider();
 
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index a7c8242..5bdc74f 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -277,6 +277,7 @@ static async Task Main(string[] args)
                     sourceUri,
                     tempDir,
                     unpinRemovedVideos,
+                    useBeeNativeNode,
                     userEthAddr)
                 .ConfigureUploadSettings(
                     acceptPurchaseOfAllBatches,
@@ -289,10 +290,18 @@ static async Task Main(string[] args)
                     skip480,
                     skip360,
                     ttlPostageStamp)
+                .AddBeeGatewayClientService()
+                .AddBeeNodeClientService()
                 .AddLinkReporterService()
+                .AddCleanerVideoService()
+                .AddEncoderService()
+                .AddEthernaUserClientsService()
+                .AddGatewayService(useBeeNativeNode)
+                .AddEthernaVideoImporterService()
+                .AddMigrationService()
+                .AddVideoUploaderService()
                 .AddVideoProvider(sourceType.Value)
-                .AddCommonServices(useBeeNativeNode)
-                .ConfigureHttpClient(authResult.RefreshTokenHandler);
+                .AddEthernaHttpClient(authResult.RefreshTokenHandler);
 
             var serviceProvider = services.BuildServiceProvider();
 

From fe1b0ef8e1a5e11b35632f1b2db85e431ab98cda Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Tue, 11 Apr 2023 19:25:14 +0200
Subject: [PATCH 16/22] change services to singleton

---
 .../Extensions/ServiceCollectionExtensions.cs               | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
index a29531c..161102c 100644
--- a/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/src/EthernaVideoImporter.Core/Extensions/ServiceCollectionExtensions.cs
@@ -16,7 +16,7 @@ public static IServiceCollection AddEthernaVideoImporterService(this IServiceCol
             services.AddTransient<EthernaVideoImporter>();
 
         public static IServiceCollection AddBeeGatewayClientService(this IServiceCollection services) =>
-            services.AddTransient<IBeeGatewayClient>((sp) =>
+            services.AddSingleton<IBeeGatewayClient>((sp) =>
              {
                  var httpClientFactory = sp.GetRequiredService<IHttpClientFactory>();
                  return new BeeGatewayClient(
@@ -26,7 +26,7 @@ public static IServiceCollection AddBeeGatewayClientService(this IServiceCollect
              });
 
         public static IServiceCollection AddBeeNodeClientService(this IServiceCollection services) =>
-            services.AddTransient<IBeeNodeClient, BeeNodeClient>();
+            services.AddSingleton<IBeeNodeClient, BeeNodeClient>();
 
         public static IServiceCollection AddCleanerVideoService(this IServiceCollection services) =>
             services.AddTransient<ICleanerVideoService, CleanerVideoService>();
@@ -35,7 +35,7 @@ public static IServiceCollection AddEncoderService(this IServiceCollection servi
             services.AddTransient<IEncoderService, EncoderService>();
 
         public static IServiceCollection AddEthernaUserClientsService(this IServiceCollection services) =>
-            services.AddTransient<IEthernaUserClients>((sp) =>
+            services.AddSingleton<IEthernaUserClients>((sp) =>
             {
                 var httpClientFactory = sp.GetRequiredService<IHttpClientFactory>();
                 return new EthernaUserClients(

From 6ae4ff2a64554013a461103be58bc7ccd22f8c2d Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Wed, 12 Apr 2023 09:22:26 +0200
Subject: [PATCH 17/22] Yaml Deserialization

---
 .../EthernaVideoImporter.Devcon.csproj        |  1 +
 .../Services/MdVideoProvider.cs               | 93 ++++---------------
 2 files changed, 18 insertions(+), 76 deletions(-)

diff --git a/src/EthernaVideoImporter.Devcon/EthernaVideoImporter.Devcon.csproj b/src/EthernaVideoImporter.Devcon/EthernaVideoImporter.Devcon.csproj
index fca5038..1a1bbad 100644
--- a/src/EthernaVideoImporter.Devcon/EthernaVideoImporter.Devcon.csproj
+++ b/src/EthernaVideoImporter.Devcon/EthernaVideoImporter.Devcon.csproj
@@ -37,6 +37,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="YamlDotNet" Version="13.0.2" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
index 8df6774..974562c 100644
--- a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
@@ -22,16 +22,17 @@
 using System.IO;
 using System.Linq;
 using System.Net.Http;
-using System.Text;
-using System.Text.Json;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
 using YoutubeExplode;
 using YoutubeExplode.Exceptions;
 using YoutubeExplode.Videos.Streams;
 
 namespace Etherna.VideoImporter.Devcon.Services
 {
-    internal sealed class MdVideoProvider : IVideoProvider
+    internal sealed partial class MdVideoProvider : IVideoProvider
     {
         // Consts.
         public static readonly string[] _keywordNames = { "IMAGE", "IMAGEURL", "EDITION", "TITLE", "DESCRIPTION", "YOUTUBEURL", "IPFSHASH", "DURATION", "EXPERTISE", "TYPE", "TRACK", "KEYWORDS", "TAGS", "SPEAKERS", "ETHERNAINDEX", "ETHERNAPERMALINK", "SOURCEID" };
@@ -82,55 +83,16 @@ public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
 
                 Console.WriteLine($"File #{i + 1} of {mdFilesPaths.Length}: {mdFileRelativePath}");
 
-                // Get from md file.
-                var mdConvertedToJson = new StringBuilder();
-                var markerLine = 0;
-                var keyFound = 0;
-                var descriptionExtraRows = new List<string>();
-                ArchiveMdFileDto? videoDataInfoDto = null;
-                foreach (var line in File.ReadLines(mdFilePath))
-                {
-                    if (string.IsNullOrWhiteSpace(line))
-                        continue;
-                    if (_keywordSkips.Any(keyToSkip =>
-                        line.StartsWith(keyToSkip, StringComparison.InvariantCultureIgnoreCase)))
-                        continue;
-
-                    if (line == "---")
-                    {
-                        markerLine++;
-
-                        if (markerLine == 1)
-                            mdConvertedToJson.AppendLine("{");
-                        else if (markerLine == 2)
-                        {
-                            mdConvertedToJson.AppendLine("}");
-                            try
-                            {
-                                videoDataInfoDto = JsonSerializer.Deserialize<ArchiveMdFileDto>(
-                                    mdConvertedToJson.ToString(),
-                                    new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase })!;
-                            }
-                            catch (Exception ex)
-                            {
-                                Console.ForegroundColor = ConsoleColor.DarkRed;
-                                Console.WriteLine($"Unable to parse file: {mdFileRelativePath}");
-                                Console.WriteLine(ex.Message);
-                                Console.ResetColor();
-                            }
-
-                            markerLine = 0;
-                            keyFound = 0;
-                            mdConvertedToJson = new StringBuilder();
-                            videoDataInfoDto?.AddDescription(descriptionExtraRows);
-                        }
-                    }
-                    else
-                    {
-                        mdConvertedToJson.AppendLine(FormatLineForJson(line, keyFound == 0, descriptionExtraRows));
-                        keyFound++;
-                    }
-                }
+                // Deserialize YAML section from MD.
+                string content = File.ReadAllText(mdFilePath);
+                var yamlMatch = YamlRegex().Match(content);
+                string yamlString = yamlMatch.ToString().Trim('-');
+
+                var deserializer = new DeserializerBuilder()
+                                        .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                                        .IgnoreUnmatchedProperties()
+                                        .Build();
+                var videoDataInfoDto = deserializer.Deserialize<ArchiveMdFileDto>(yamlString);
 
                 if (videoDataInfoDto is null)
                     continue;
@@ -182,30 +144,6 @@ public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
         }
 
         // Helpers.
-        private static string FormatLineForJson(string line, bool isFirstRow, List<string> descriptionExtraRows)
-        {
-            if (string.IsNullOrWhiteSpace(line))
-                return "";
-
-            // Prevent multiline description error 
-            if (!_keywordNames.Any(keywordName => line.StartsWith(keywordName, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                descriptionExtraRows.Add(line);
-                return "";
-            }
-
-            var formatedString = (isFirstRow ? "" : ",") // Add , at end of every previus row (isFirstKeyFound used to avoid insert , in the last keyword)
-                + "\"" // Add " at start of every row
-                + ReplaceFirstOccurrence(line, ":", "\":"); // Find the first : and add "
-
-            // Prevent error for description multiline
-            if (line.StartsWith("DESCRIPTION", StringComparison.InvariantCultureIgnoreCase) &&
-                !formatedString.EndsWith("\"", StringComparison.InvariantCultureIgnoreCase))
-                formatedString += "\"";
-
-            return formatedString.Replace("\t", " ", StringComparison.InvariantCultureIgnoreCase); // Replace \t \ with space
-        }
-
         private static string ReplaceFirstOccurrence(string source, string find, string replace)
         {
             if (string.IsNullOrWhiteSpace(source))
@@ -215,5 +153,8 @@ private static string ReplaceFirstOccurrence(string source, string find, string
             string result = source.Remove(index, find.Length).Insert(index, replace);
             return result;
         }
+
+        [GeneratedRegex("---\\r?\\n[\\s\\S]*?---")]
+        private static partial Regex YamlRegex();
     }
 }

From fa63f141c70170a6e201a5844df5cc81cdfe11a6 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Wed, 12 Apr 2023 12:01:15 +0200
Subject: [PATCH 18/22] remove test code

---
 src/EthernaVideoImporter/Program.cs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index b9179a6..e459f3f 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -94,7 +94,7 @@ static async Task Main(string[] args)
             bool skip480 = false;
             bool skip360 = false;
             bool useBeeNativeNode = false;
-            args = new string[] { "localvideo", "C:/tmp/LocalVideo/localvideo.json" };
+
             // Parse input.
             if (args.Length == 0)
             {
@@ -212,7 +212,7 @@ static async Task Main(string[] args)
             var ffProbeBinaryPath = Path.Combine(ffMpegFolderPath, CommonConsts.FFProbeBinaryName);
             if (!File.Exists(ffProbeBinaryPath))
             {
-                Console.WriteLine($"FFprobe not found at ({ffMpegBinaryPath})");
+                Console.WriteLine($"FFprobe not found at ({ffProbeBinaryPath})");
                 return;
             }
 
@@ -233,14 +233,12 @@ static async Task Main(string[] args)
             }
 
             //check local video input
-#pragma warning disable CA1508 // Avoid dead conditional code
             if (sourceType == SourceType.LocalVideo &&
                 !File.Exists(sourceUri))
             {
                 Console.WriteLine($"Local video not found at ({sourceUri})");
                 return;
             }
-#pragma warning restore CA1508 // Avoid dead conditional code
 
             //bee node api port
             if (!string.IsNullOrEmpty(beeNodeApiPortStr) &&
@@ -259,13 +257,11 @@ static async Task Main(string[] args)
             }
 
             //deny delete video old sources when is single
-#pragma warning disable CA1508 // Avoid dead conditional code
             if (sourceType == SourceType.YouTubeVideo && deleteVideosMissingFromSource)
             {
                 Console.WriteLine($"Cannot delete video removed from source when the source is a single video");
                 return;
             }
-#pragma warning restore CA1508 // Avoid dead conditional code
 
             // Sign with SSO and create auth client.
             var authResult = await SignServices.SigInSSO();

From 65e01fc0bac375d834e9e0893cf8d2eb811f8b83 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Wed, 12 Apr 2023 12:17:16 +0200
Subject: [PATCH 19/22] devcon no need ffprobe

---
 src/EthernaVideoImporter.Devcon/Program.cs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 4b2a90b..918d6c7 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -186,14 +186,6 @@ static async Task Main(string[] args)
                 return;
             }
 
-            //FFprobe
-            var ffProbeBinaryPath = Path.Combine(ffMpegFolderPath, CommonConsts.FFProbeBinaryName);
-            if (!File.Exists(ffProbeBinaryPath))
-            {
-                Console.WriteLine($"FFprobe not found at ({ffMpegBinaryPath})");
-                return;
-            }
-
             //ttl postage batch
             if (!string.IsNullOrEmpty(ttlPostageStampStr) &&
                 !int.TryParse(ttlPostageStampStr, CultureInfo.InvariantCulture, out ttlPostageStamp))

From bcc0cb379320bea8a2e8817eb686cbc1bbdee578 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Wed, 12 Apr 2023 12:43:08 +0200
Subject: [PATCH 20/22] refactory

---
 src/EthernaVideoImporter/Services/LocalVideoProvider.cs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
index 5966d9e..00b5575 100644
--- a/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/LocalVideoProvider.cs
@@ -19,9 +19,9 @@ public sealed class LocalVideoProvider : IVideoProvider
     {
         // Fields.
         private readonly string ffProbeBinaryPath;
-        private readonly string localFile;
         private readonly IEncoderService encoderService;
         private readonly bool includeAudioTrack;
+        private readonly string localFile;
         private readonly IEnumerable<int> supportedHeightResolutions;
         private readonly JsonSerializerOptions options = new JsonSerializerOptions
         {
@@ -36,9 +36,9 @@ public LocalVideoProvider(
             IEnumerable<int> supportedHeightResolutions,
             string ffProbeBinaryPath)
         {
-            this.localFile = localFile;
             this.encoderService = encoderService;
             this.includeAudioTrack = includeAudioTrack;
+            this.localFile = localFile;
             this.supportedHeightResolutions = supportedHeightResolutions;
             this.ffProbeBinaryPath = ffProbeBinaryPath;
         }
@@ -71,9 +71,8 @@ public async Task<Video> GetVideoAsync(
             // Get thumbnail.
             List<ThumbnailLocalFile> thumbnailFiles = new();
             if (localVideoMetadata.Thumbnail is not null)
-            {
                 thumbnailFiles = await DownscaleThumbnailAsync(localVideoMetadata.Thumbnail, tempDirectory);
-            }
+
             return new Video(videoMetadata, encodedFiles, thumbnailFiles);
         }
 

From 5fa94aeea0dc4dbb39ae182593b179feedcf4994 Mon Sep 17 00:00:00 2001
From: Federico Cicciarella <federico.cicciarella@gmail.com>
Date: Thu, 13 Apr 2023 10:16:15 +0200
Subject: [PATCH 21/22] enabled UploadVideoAsync

---
 src/EthernaVideoImporter.Core/EthernaVideoImporter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
index 7dfbfed..1a70b5e 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.cs
@@ -208,7 +208,7 @@ await ethernaIndexClient.VideosClient.VideosPutAsync(
                         }
 
                         // Upload video and all related data.
-                        //await videoUploaderService.UploadVideoAsync(video, pinVideos, offerVideos);
+                        await videoUploaderService.UploadVideoAsync(video, pinVideos, offerVideos);
 
                         updatedIndexId = video.EthernaIndexId!;
                         updatedPermalinkHash = video.EthernaPermalinkHash!;

From cfeeb05e7c0b5971e3c21aabff6a602e7c90b65d Mon Sep 17 00:00:00 2001
From: Mirko Da Corte <mirko@etherna.io>
Date: Mon, 8 May 2023 18:15:34 +0200
Subject: [PATCH 22/22] update dependencies

---
 .../EthernaVideoImporter.Core.csproj                | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/EthernaVideoImporter.Core.csproj b/src/EthernaVideoImporter.Core/EthernaVideoImporter.Core.csproj
index 6fb6925..8c9cfde 100644
--- a/src/EthernaVideoImporter.Core/EthernaVideoImporter.Core.csproj
+++ b/src/EthernaVideoImporter.Core/EthernaVideoImporter.Core.csproj
@@ -23,7 +23,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Bee.Net" Version="0.2.0-alpha.172" />
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Bee.Net" Version="0.2.0-alpha.189" />
     <PackageReference Include="Blurhash.SkiaSharp" Version="2.0.0" />
     <PackageReference Include="Etherna.YoutubeDownloader.Converter" Version="6.3.3" />
     <PackageReference Include="EthernaServicesClient" Version="0.3.0-alpha.60" />
@@ -31,19 +35,18 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="IdentityModel.OidcClient" Version="5.2.1" />
     <PackageReference Include="Keccak256" Version="1.0.0" />
     <PackageReference Include="MedallionShell" Version="1.6.2" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.3" />
-    <PackageReference Include="IdentityModel.OidcClient" Version="5.2.1" />
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.28.0" />
-    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.30.0" />
   </ItemGroup>
 
   <ItemGroup>