EonaCat.Sync/EonaCat.Sync/SyncServiceFactory.cs

using System;
using System.Threading.Tasks;
using EonaCat.Sync.Interfaces;
using EonaCat.Sync.Services;

namespace EonaCat.Sync
{
    /// <summary>
    /// Main entry point for the EonaCat Synchronization Service.
    /// Provides easy access to file and database synchronization capabilities.
    /// </summary>
    public class SyncServiceFactory
    {
        /// <summary>
        /// Creates a sync service with default implementations.
        /// </summary>
        public static SyncService CreateSyncService(ISyncNotifier notifier = null)
        {
            var fileSynchronizer = new FileSynchronizer();
            var databaseSynchronizer = new DatabaseSynchronizer();
            var conflictResolver = new DefaultConflictResolver();
            var changeTracker = new InMemoryChangeTracker();
            var syncNotifier = notifier ?? new DefaultSyncNotifier();

            return new SyncService(
                fileSynchronizer,
                databaseSynchronizer,
                conflictResolver,
                changeTracker,
                syncNotifier);
        }

        /// <summary>
        /// Creates a sync service with custom file sync options.
        /// </summary>
        public static SyncService CreateFileSyncService(FileSyncOptions options = null)
        {
            var fileSynchronizer = new FileSynchronizer(options);
            var databaseSynchronizer = new DatabaseSynchronizer();
            var conflictResolver = new DefaultConflictResolver();
            var changeTracker = new InMemoryChangeTracker();
            var notifier = new DefaultSyncNotifier();

            return new SyncService(
                fileSynchronizer,
                databaseSynchronizer,
                conflictResolver,
                changeTracker,
                notifier);
        }

        /// <summary>
        /// Creates a sync service with custom database sync options.
        /// </summary>
        public static SyncService CreateDatabaseSyncService(DatabaseSyncOptions options = null)
        {
            var fileSynchronizer = new FileSynchronizer();
            var databaseSynchronizer = new DatabaseSynchronizer(options);
            var conflictResolver = new DefaultConflictResolver();
            var changeTracker = new InMemoryChangeTracker();
            var notifier = new DefaultSyncNotifier();

            return new SyncService(
                fileSynchronizer,
                databaseSynchronizer,
                conflictResolver,
                changeTracker,
                notifier);
        }

        /// <summary>
        /// Creates a fully customized sync service.
        /// </summary>
        public static SyncService CreateCustomSyncService(
            FileSyncOptions fileSyncOptions = null,
            DatabaseSyncOptions databaseSyncOptions = null,
            ISyncNotifier notifier = null)
        {
            var fileSynchronizer = new FileSynchronizer(fileSyncOptions);
            var databaseSynchronizer = new DatabaseSynchronizer(databaseSyncOptions);
            var conflictResolver = new DefaultConflictResolver();
            var changeTracker = new InMemoryChangeTracker();
            var syncNotifier = notifier ?? new DefaultSyncNotifier();

            return new SyncService(
                fileSynchronizer,
                databaseSynchronizer,
                conflictResolver,
                changeTracker,
                syncNotifier);
        }
    }

    /// <summary>
    /// Example usage of the synchronization service.
    /// </summary>
    public class SyncExample
    {
        /// <summary>
        /// Example: Synchronize files between two directories.
        /// </summary>
        public static async Task ExampleFileSyncAsync()
        {
            var syncService = SyncServiceFactory.CreateSyncService();

            string sourceDir = @"C:\Source\Files";
            string targetDir = @"C:\Target\Files";

            var result = await syncService.SyncFilesAsync(sourceDir, targetDir);

            Console.WriteLine($"Sync completed. Changes applied: {result.ChangesApplied}");
            Console.WriteLine($"Success: {result.Success}");
        }

        /// <summary>
        /// Example: Synchronize database between two servers.
        /// </summary>
        public static async Task ExampleDatabaseSyncAsync()
        {
            var options = new DatabaseSyncOptions
            {
                UseTransactions = true,
                DatabaseBatchSize = 500
            };

            var syncService = SyncServiceFactory.CreateDatabaseSyncService(options);

            string sourceConnection = "Server=SourceServer;Database=SourceDB;Integrated Security=true;";
            string targetConnection = "Server=TargetServer;Database=TargetDB;Integrated Security=true;";
            string[] entityNames = { "Users", "Products", "Orders" };

            var result = await syncService.SyncDatabaseAsync(sourceConnection, targetConnection, entityNames);

            Console.WriteLine($"Database sync completed. Changes applied: {result.ChangesApplied}");
            Console.WriteLine($"Success: {result.Success}");
        }

        /// <summary>
        /// Example: Full synchronization of both files and database.
        /// </summary>
        public static async Task ExampleFullSyncAsync()
        {
            var syncService = SyncServiceFactory.CreateSyncService();

            var options = new SyncOptions
            {
                ConflictResolutionStrategy = "LastWriteWins",
                DeleteMissingFilesInTarget = false,
                ValidateAfterSync = true
            };

            string sourceFileDir = @"C:\System1\Data";
            string targetFileDir = @"C:\System2\Data";
            string sourceDb = "Server=System1;Database=AppDB;";
            string targetDb = "Server=System2;Database=AppDB;";
            string[] entities = { "Users", "Settings", "Documents" };

            var result = await syncService.SyncFullAsync(
                sourceFileDir, targetFileDir, sourceDb, targetDb, entities, options);

            Console.WriteLine($"Full sync result - Changes: {result.ChangesApplied}, " +
                            $"Conflicts: {result.ConflictsEncountered}, Success: {result.Success}");
        }

        /// <summary>
        /// Example: Bidirectional file synchronization.
        /// </summary>
        public static async Task ExampleBidirectionalSyncAsync()
        {
            var syncService = SyncServiceFactory.CreateSyncService();

            var options = new SyncOptions
            {
                BidirectionalSync = true,
                ConflictResolutionStrategy = "LastWriteWins"
            };

            var result = await syncService.SyncBidirectionalAsync(
                @"C:\Location1", 
                @"C:\Location2", 
                options);

            Console.WriteLine($"Bidirectional sync completed. Changes: {result.ChangesApplied}");
        }
    }
}