Review data conversion methods

FileConvertor/App.xaml.cs

@@ -61,8 +61,8 @@ private void ConfigureServices(IServiceCollection services)
             services.AddSingleton<ConverterFactory>(provider =>
             {
                 var factory = new ConverterFactory(provider);
-                
-                // Register converter types instead of instances
+
+                // Register original converter types
                 factory.RegisterConverterType(typeof(TextToPdfConverter));
                 factory.RegisterConverterType(typeof(PngToJpgConverter));
                 factory.RegisterConverterType(typeof(ExcelToCsvConverter));
@@ -82,8 +82,58 @@ private void ConfigureServices(IServiceCollection services)
                 factory.RegisterConverterType(typeof(Mp4ToMp3Converter));
                 factory.RegisterConverterType(typeof(M4aToMp3Converter));
                 factory.RegisterConverterType(typeof(HeicToJpgConverter));
-
-                Logger.Log(LogLevel.Info, "App", "Registered converter types for lazy loading");
+                factory.RegisterConverterType(typeof(WavToMp3Converter));
+
+                // Register RTF converters
+                factory.RegisterConverterType(typeof(RtfToPdfConverter));
+                factory.RegisterConverterType(typeof(RtfToDocxConverter));
+                factory.RegisterConverterType(typeof(RtfToTextConverter));
+
+                // Register advanced image converters
+                factory.RegisterConverterType(typeof(GifToPngConverter));
+                factory.RegisterConverterType(typeof(GifToJpgConverter));
+                factory.RegisterConverterType(typeof(PngToGifConverter));
+                factory.RegisterConverterType(typeof(JpgToGifConverter));
+                factory.RegisterConverterType(typeof(BmpToGifConverter));
+                factory.RegisterConverterType(typeof(TiffToPngConverter));
+                factory.RegisterConverterType(typeof(TiffToJpgConverter));
+                factory.RegisterConverterType(typeof(PngToTiffConverter));
+                factory.RegisterConverterType(typeof(JpgToTiffConverter));
+                factory.RegisterConverterType(typeof(BmpToTiffConverter));
+                factory.RegisterConverterType(typeof(PngToIcoConverter));
+                factory.RegisterConverterType(typeof(IcoToPngConverter));
+                factory.RegisterConverterType(typeof(WebpToPngConverter));
+
+                // Register additional audio converters
+                factory.RegisterConverterType(typeof(FlacToMp3Converter));
+                factory.RegisterConverterType(typeof(FlacToWavConverter));
+                factory.RegisterConverterType(typeof(OggToMp3Converter));
+                factory.RegisterConverterType(typeof(AacToMp3Converter));
+                factory.RegisterConverterType(typeof(Mp3ToFlacConverter));
+
+                // Register video converters
+                factory.RegisterConverterType(typeof(AviToMp4Converter));
+                factory.RegisterConverterType(typeof(MovToMp4Converter));
+                factory.RegisterConverterType(typeof(MkvToMp4Converter));
+                factory.RegisterConverterType(typeof(WebmToMp4Converter));
+                factory.RegisterConverterType(typeof(Mp4ToAviConverter));
+
+                // Register Markdown converters
+                factory.RegisterConverterType(typeof(PdfToMarkdownConverter));
+                factory.RegisterConverterType(typeof(DocxToMarkdownConverter));
+                factory.RegisterConverterType(typeof(HtmlToMarkdownConverter));
+
+                // Register Excel advanced converters
+                factory.RegisterConverterType(typeof(ExcelToJsonConverter));
+                factory.RegisterConverterType(typeof(ExcelToXmlConverter));
+                factory.RegisterConverterType(typeof(CsvToJsonConverter));
+
+                // Register document converters
+                factory.RegisterConverterType(typeof(HtmlToDocxConverter));
+                factory.RegisterConverterType(typeof(TextToDocxConverter));
+                factory.RegisterConverterType(typeof(DocxToTextConverter));
+
+                Logger.Log(LogLevel.Info, "App", "Registered 58 converter types for lazy loading");
                 return factory;
             });
 

FileConvertor/Core/Converters/AacToMp3Converter.cs

@@ -0,0 +1,24 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using NAudio.Wave;
+using NAudio.Lame;
+
+namespace FileConvertor.Core.Converters
+{
+    public class AacToMp3Converter : BaseConverter
+    {
+        public override string SourceFormat => "aac";
+        public override string TargetFormat => "mp3";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            await Task.Run(() =>
+            {
+                using var reader = new StreamMediaFoundationReader(sourceStream);
+                using var writer = new LameMP3FileWriter(targetStream, reader.WaveFormat, 128);
+                reader.CopyTo(writer);
+            });
+        }
+    }
+}

FileConvertor/Core/Converters/AviToMp4Converter.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xabe.FFmpeg;
+
+namespace FileConvertor.Core.Converters
+{
+    public class AviToMp4Converter : BaseConverter
+    {
+        public override string SourceFormat => "avi";
+        public override string TargetFormat => "mp4";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            var tempInput = Path.GetTempFileName();
+            var tempOutput = Path.GetTempFileName();
+
+            try
+            {
+                // Write source stream to temp file
+                using (var fileStream = File.Create(tempInput))
+                {
+                    await sourceStream.CopyToAsync(fileStream);
+                }
+
+                // Convert using FFmpeg
+                var mediaInfo = await FFmpeg.GetMediaInfo(tempInput);
+                var conversion = FFmpeg.Conversions.New();
+
+                if (mediaInfo.VideoStreams.Any())
+                    conversion.AddStream(mediaInfo.VideoStreams.First());
+
+                if (mediaInfo.AudioStreams.Any())
+                    conversion.AddStream(mediaInfo.AudioStreams.First());
+
+                await conversion
+                    .SetOutput(tempOutput)
+                    .Start();
+
+                // Copy result to target stream
+                using var outputFile = File.OpenRead(tempOutput);
+                await outputFile.CopyToAsync(targetStream);
+            }
+            finally
+            {
+                if (File.Exists(tempInput)) File.Delete(tempInput);
+                if (File.Exists(tempOutput)) File.Delete(tempOutput);
+            }
+        }
+    }
+}

FileConvertor/Core/Converters/BmpToGifConverter.cs

@@ -0,0 +1,25 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using System.Windows.Media.Imaging;
+
+namespace FileConvertor.Core.Converters
+{
+    public class BmpToGifConverter : BaseConverter
+    {
+        public override string SourceFormat => "bmp";
+        public override string TargetFormat => "gif";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            await Task.Run(() =>
+            {
+                var decoder = new BmpBitmapDecoder(sourceStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
+                var encoder = new GifBitmapEncoder();
+
+                encoder.Frames.Add(BitmapFrame.Create(decoder.Frames[0]));
+                encoder.Save(targetStream);
+            });
+        }
+    }
+}

FileConvertor/Core/Converters/BmpToTiffConverter.cs

@@ -0,0 +1,25 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using System.Windows.Media.Imaging;
+
+namespace FileConvertor.Core.Converters
+{
+    public class BmpToTiffConverter : BaseConverter
+    {
+        public override string SourceFormat => "bmp";
+        public override string TargetFormat => "tiff";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            await Task.Run(() =>
+            {
+                var decoder = new BmpBitmapDecoder(sourceStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
+                var encoder = new TiffBitmapEncoder { Compression = TiffCompressOption.Zip };
+
+                encoder.Frames.Add(BitmapFrame.Create(decoder.Frames[0]));
+                encoder.Save(targetStream);
+            });
+        }
+    }
+}

FileConvertor/Core/Converters/CsvToJsonConverter.cs

@@ -0,0 +1,88 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace FileConvertor.Core.Converters
+{
+    public class CsvToJsonConverter : BaseConverter
+    {
+        public override string SourceFormat => "csv";
+        public override string TargetFormat => "json";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            await Task.Run(() =>
+            {
+                using var reader = new StreamReader(sourceStream, Encoding.UTF8);
+                var data = new List<Dictionary<string, string>>();
+
+                // Read header
+                var headerLine = reader.ReadLine();
+                if (string.IsNullOrEmpty(headerLine))
+                    return;
+
+                var headers = ParseCsvLine(headerLine);
+
+                // Read data
+                while (!reader.EndOfStream)
+                {
+                    var line = reader.ReadLine();
+                    if (string.IsNullOrEmpty(line))
+                        continue;
+
+                    var values = ParseCsvLine(line);
+                    var rowData = new Dictionary<string, string>();
+
+                    for (int i = 0; i < Math.Min(headers.Count, values.Count); i++)
+                    {
+                        rowData[headers[i]] = values[i];
+                    }
+
+                    data.Add(rowData);
+                }
+
+                // Write JSON
+                var json = JsonSerializer.Serialize(data, new JsonSerializerOptions
+                {
+                    WriteIndented = true
+                });
+
+                using var writer = new StreamWriter(targetStream, Encoding.UTF8);
+                writer.Write(json);
+                writer.Flush();
+            });
+        }
+
+        private List<string> ParseCsvLine(string line)
+        {
+            var values = new List<string>();
+            var currentValue = new StringBuilder();
+            bool inQuotes = false;
+
+            for (int i = 0; i < line.Length; i++)
+            {
+                char c = line[i];
+
+                if (c == '"')
+                {
+                    inQuotes = !inQuotes;
+                }
+                else if (c == ',' && !inQuotes)
+                {
+                    values.Add(currentValue.ToString());
+                    currentValue.Clear();
+                }
+                else
+                {
+                    currentValue.Append(c);
+                }
+            }
+
+            values.Add(currentValue.ToString());
+            return values;
+        }
+    }
+}

FileConvertor/Core/Converters/DocxToMarkdownConverter.cs

@@ -0,0 +1,67 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+
+namespace FileConvertor.Core.Converters
+{
+    public class DocxToMarkdownConverter : BaseConverter
+    {
+        public override string SourceFormat => "docx";
+        public override string TargetFormat => "md";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            await Task.Run(() =>
+            {
+                var markdown = new StringBuilder();
+
+                using (var wordDocument = WordprocessingDocument.Open(sourceStream, false))
+                {
+                    var body = wordDocument.MainDocumentPart?.Document.Body;
+
+                    if (body != null)
+                    {
+                        foreach (var element in body.Elements())
+                        {
+                            if (element is Paragraph paragraph)
+                            {
+                                var text = paragraph.InnerText;
+
+                                if (!string.IsNullOrWhiteSpace(text))
+                                {
+                                    // Check if it's a heading
+                                    var styleId = paragraph.ParagraphProperties?.ParagraphStyleId?.Val?.Value;
+
+                                    if (styleId != null && styleId.StartsWith("Heading"))
+                                    {
+                                        var level = 1;
+                                        if (styleId.Length > 7 && char.IsDigit(styleId[7]))
+                                        {
+                                            level = int.Parse(styleId[7].ToString());
+                                        }
+
+                                        markdown.AppendLine($"{new string('#', level)} {text}");
+                                    }
+                                    else
+                                    {
+                                        markdown.AppendLine(text);
+                                    }
+
+                                    markdown.AppendLine();
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Write markdown to stream
+                using var writer = new StreamWriter(targetStream, Encoding.UTF8);
+                writer.Write(markdown.ToString().TrimEnd());
+                writer.Flush();
+            });
+        }
+    }
+}

FileConvertor/Core/Converters/DocxToTextConverter.cs

@@ -0,0 +1,29 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using DocumentFormat.OpenXml.Packaging;
+
+namespace FileConvertor.Core.Converters
+{
+    public class DocxToTextConverter : BaseConverter
+    {
+        public override string SourceFormat => "docx";
+        public override string TargetFormat => "txt";
+
+        public override async Task ConvertAsync(Stream sourceStream, Stream targetStream)
+        {
+            await Task.Run(() =>
+            {
+                using var wordDocument = WordprocessingDocument.Open(sourceStream, false);
+                var body = wordDocument.MainDocumentPart?.Document.Body;
+
+                var text = body?.InnerText ?? string.Empty;
+
+                using var writer = new StreamWriter(targetStream, Encoding.UTF8);
+                writer.Write(text);
+                writer.Flush();
+            });
+        }
+    }
+}