PM> Install-Package Aspose.Cells

using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;
using System;
using System.IO;
using System.Text;

public class ExcelMigrationService
{
    private readonly string _sourceDirectory;
    private readonly string _outputDirectory;
    private readonly string _logPath;
    
    public ExcelMigrationService(string sourceDirectory, string outputDirectory, string logPath)
    {
        _sourceDirectory = sourceDirectory;
        _outputDirectory = outputDirectory;
        _logPath = logPath;
        
        // Ensure output directory exists
        if (!Directory.Exists(_outputDirectory))
            Directory.CreateDirectory(_outputDirectory);
            
        // Ensure result subdirectories exist
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "xlsx"));
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "pdf"));
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "html"));
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "json"));
    }
    
    // Methods to be implemented
}

public void MigrateToModernFormat(string inputFile, SaveFormat targetFormat)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "xlsx", $"{fileName}.xlsx");
        
        // Configure options for conversion
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.SaveFormat = targetFormat;
        lcsopts.OutputFile = outputFile;
        
        // Execute the conversion
        SpreadsheetConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to {outputFile} successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile}: {ex.Message}");
        throw;
    }
}

public void BatchConvertDirectory(SaveFormat targetFormat)
{
    string[] excelFiles = Directory.GetFiles(_sourceDirectory, "*.xls*", SearchOption.AllDirectories);
    int successCount = 0;
    int failureCount = 0;
    
    foreach (string file in excelFiles)
    {
        try
        {
            MigrateToModernFormat(file, targetFormat);
            successCount++;
        }
        catch
        {
            failureCount++;
        }
    }
    
    LogConversion($"Batch conversion completed. Success: {successCount}, Failures: {failureCount}");
}

public void ConvertToPdf(string inputFile, bool onePagePerSheet = true)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "pdf", $"{fileName}.pdf");
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodePdfSaveOptions lcsopts = new LowCodePdfSaveOptions();
        PdfSaveOptions pdfOpts = new PdfSaveOptions();
        pdfOpts.OnePagePerSheet = onePagePerSheet;
        lcsopts.PdfOptions = pdfOpts;
        lcsopts.OutputFile = outputFile;
        
        PdfConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to PDF successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile} to PDF: {ex.Message}");
        throw;
    }
}

public void BatchConvertToPdf(bool onePagePerSheet = true)
{
    string[] excelFiles = Directory.GetFiles(_sourceDirectory, "*.xls*", SearchOption.AllDirectories);
    
    foreach (string file in excelFiles)
    {
        try
        {
            ConvertToPdf(file, onePagePerSheet);
        }
        catch
        {
            // Failures are logged in the ConvertToPdf method
        }
    }
}

public void ConvertToHtml(string inputFile, string cellNameAttribute = null)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "html", $"{fileName}.html");
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeHtmlSaveOptions lcsopts = new LowCodeHtmlSaveOptions();
        HtmlSaveOptions htmlOpts = new HtmlSaveOptions();
        
        if (!string.IsNullOrEmpty(cellNameAttribute))
            htmlOpts.CellNameAttribute = cellNameAttribute;
            
        // Configure to export only the first sheet
        htmlOpts.SheetSet = new Aspose.Cells.Rendering.SheetSet(new int[] { 0 });
        lcsopts.HtmlOptions = htmlOpts;
        lcsopts.OutputFile = outputFile;
        
        HtmlConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to HTML successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile} to HTML: {ex.Message}");
        throw;
    }
}

public string ConvertToJson(string inputFile)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "json", $"{fileName}.json");
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.OutputFile = outputFile;
        
        JsonConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to JSON successfully.");
        return outputFile;
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile} to JSON: {ex.Message}");
        throw;
    }
}

public void SecureDocument(string inputFile, string password)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "secured", $"{fileName}_secured.xlsx");
        
        // Ensure secured directory exists
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "secured"));
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.SaveFormat = SaveFormat.Xlsx;
        lcsopts.OutputFile = outputFile;
        
        SpreadsheetLocker.Process(lclopts, lcsopts, password, null);
        
        LogConversion($"Secured {inputFile} with password protection successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error securing {inputFile}: {ex.Message}");
        throw;
    }
}

public void MergeDocuments(List<string> inputFiles, string outputFileName)
{
    try
    {
        string outputFile = Path.Combine(_outputDirectory, $"{outputFileName}.xlsx");
        
        LowCodeMergeOptions lcmOpts = new LowCodeMergeOptions();
        lcmOpts.LoadOptionsProvider = new CustomMergerSourceProvider(inputFiles);
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.OutputFile = outputFile;
        lcsopts.SaveFormat = SaveFormat.Xlsx;
        lcmOpts.SaveOptions = lcsopts;
        
        SpreadsheetMerger.Process(lcmOpts);
        
        LogConversion($"Successfully merged {inputFiles.Count} documents into {outputFile}.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error merging documents: {ex.Message}");
        throw;
    }
}

private class CustomMergerSourceProvider : AbstractLowCodeLoadOptionsProvider
{
    private readonly List<string> _sourceFiles;
    private int _currentIndex = -1;
    
    public CustomMergerSourceProvider(List<string> sourceFiles)
    {
        _sourceFiles = sourceFiles;
    }
    
    public override bool MoveNext()
    {
        _currentIndex++;
        return _currentIndex < _sourceFiles.Count;
    }
    
    public override LowCodeLoadOptions Current
    {
        get
        {
            LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
            lclopts.InputFile = _sourceFiles[_currentIndex];
            return lclopts;
        }
    }
}

private void LogConversion(string message)
{
    string logEntry = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}";
    File.AppendAllText(_logPath, logEntry + Environment.NewLine);
    Console.WriteLine(logEntry);
}

using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace EnterpriseExcelMigration
{
    class Program
    {
        static void Main(string[] args)
        {
            // Define paths
            string sourceDirectory = @"C:\SourceExcelFiles";
            string outputDirectory = @"C:\MigratedFiles";
            string logPath = @"C:\Logs\migration_log.txt";
            
            try
            {
                // Initialize migration service
                ExcelMigrationService migrationService = new ExcelMigrationService(
                    sourceDirectory, outputDirectory, logPath);
                
                Console.WriteLine("Starting enterprise Excel migration process...");
                
                // Convert all Excel files to XLSX format
                migrationService.BatchConvertDirectory(SaveFormat.Xlsx);
                
                // Create PDF versions for archival
                migrationService.BatchConvertToPdf(true);
                
                // Generate HTML for web access (sample file)
                string sampleFile = Path.Combine(sourceDirectory, "financial_report.xls");
                if (File.Exists(sampleFile))
                {
                    migrationService.ConvertToHtml(sampleFile, "CellIdentifier");
                }
                
                // Extract data from critical files to JSON for system integration
                List<string> criticalFiles = new List<string>
                {
                    Path.Combine(sourceDirectory, "quarterly_data.xlsx"),
                    Path.Combine(sourceDirectory, "annual_report.xls")
                };
                
                foreach (string file in criticalFiles)
                {
                    if (File.Exists(file))
                    {
                        migrationService.ConvertToJson(file);
                    }
                }
                
                // Secure sensitive documents
                string sensitiveFile = Path.Combine(sourceDirectory, "employee_data.xlsx");
                if (File.Exists(sensitiveFile))
                {
                    migrationService.SecureDocument(sensitiveFile, "SecurePassword123!");
                }
                
                // Merge quarterly reports into annual summary
                List<string> quarterlyReports = new List<string>
                {
                    Path.Combine(sourceDirectory, "Q1_report.xlsx"),
                    Path.Combine(sourceDirectory, "Q2_report.xlsx"),
                    Path.Combine(sourceDirectory, "Q3_report.xlsx"),
                    Path.Combine(sourceDirectory, "Q4_report.xlsx")
                };
                
                // Only proceed if all files exist
                if (quarterlyReports.TrueForAll(File.Exists))
                {
                    migrationService.MergeDocuments(quarterlyReports, "Annual_Summary");
                }
                
                Console.WriteLine("Migration process completed successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Migration process failed: {ex.Message}");
                File.AppendAllText(logPath, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - CRITICAL ERROR: {ex.Message}{Environment.NewLine}");
            }
            
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

public void ProcessTemplatedDocuments(string templateFile, List<string> dataFiles, SaveFormat outputFormat)
{
    // Load the template
    Workbook templateWorkbook = new Workbook(templateFile);
    
    foreach (string dataFile in dataFiles)
    {
        try
        {
            // Load data document
            Workbook dataWorkbook = new Workbook(dataFile);
            
            // Custom processing logic to extract data and apply to template
            // ...
            
            // Save using LowCode converters
            string outputFile = Path.Combine(_outputDirectory, 
                $"{Path.GetFileNameWithoutExtension(dataFile)}_processed.xlsx");
                
            LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
            lcsopts.SaveFormat = outputFormat;
            lcsopts.OutputFile = outputFile;
            
            // Custom processing complete, save the workbook
            MemoryStream ms = new MemoryStream();
            templateWorkbook.Save(ms, SaveFormat.Xlsx);
            ms.Position = 0;
            
            // Convert to final format if needed
            LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
            lclopts.LoadFromStream = ms;
            
            SpreadsheetConverter.Process(lclopts, lcsopts);
            
            LogConversion($"Processed template with data from {dataFile}");
        }
        catch (Exception ex)
        {
            LogConversion($"Error processing template with {dataFile}: {ex.Message}");
        }
    }
}

public void PerformIncrementalMigration(string changeLogPath)
{
    Dictionary<string, DateTime> previousMigration = LoadChangeLog(changeLogPath);
    Dictionary<string, DateTime> currentMigration = new Dictionary<string, DateTime>();
    List<string> filesToMigrate = new List<string>();
    
    // Identify changed or new files
    foreach (string file in Directory.GetFiles(_sourceDirectory, "*.xls*", SearchOption.AllDirectories))
    {
        DateTime lastModified = File.GetLastWriteTime(file);
        currentMigration[file] = lastModified;
        
        if (!previousMigration.ContainsKey(file) || previousMigration[file] < lastModified)
        {
            filesToMigrate.Add(file);
        }
    }
    
    // Process only changed files
    foreach (string file in filesToMigrate)
    {
        try
        {
            MigrateToModernFormat(file, SaveFormat.Xlsx);
            ConvertToPdf(file);
            ConvertToJson(file);
        }
        catch (Exception ex)
        {
            LogConversion($"Error during incremental migration of {file}: {ex.Message}");
        }
    }
    
    // Save current state for next incremental migration
    SaveChangeLog(changeLogPath, currentMigration);
    
    LogConversion($"Incremental migration completed. Processed {filesToMigrate.Count} modified files.");
}

private Dictionary<string, DateTime> LoadChangeLog(string changeLogPath)
{
    Dictionary<string, DateTime> result = new Dictionary<string, DateTime>();
    
    if (File.Exists(changeLogPath))
    {
        foreach (string line in File.ReadAllLines(changeLogPath))
        {
            string[] parts = line.Split('|');
            if (parts.Length == 2 && DateTime.TryParse(parts[1], out DateTime timestamp))
            {
                result[parts[0]] = timestamp;
            }
        }
    }
    
    return result;
}

private void SaveChangeLog(string changeLogPath, Dictionary<string, DateTime> changeLog)
{
    List<string> lines = new List<string>();
    
    foreach (var entry in changeLog)
    {
        lines.Add($"{entry.Key}|{entry.Value:yyyy-MM-dd HH:mm:ss}");
    }
    
    File.WriteAllLines(changeLogPath, lines);
}