MigrationDiffService.cs

#nullable enable
using System.Text.RegularExpressions;
using EfMigrationDiff.Models;
using EfMigrationDiff.Repositories;
using EfMigrationDiff.Configuration;
using Microsoft.Extensions.Logging;

namespace EfMigrationDiff.Services;

/// <summary>
/// Service for comparing migrations between branches and generating diff reports.
/// </summary>
public class MigrationDiffService
{
    private readonly MigrationRepository _migrationRepository;
    private readonly ConflictDetectionService _conflictDetectionService;
    private readonly SchemaChangeDetectorService _schemaChangeDetectorService;
    private readonly ILogger<MigrationDiffService> _logger;
    private readonly EfMigrationDiffOptions? _options;

    /// <summary>
    /// Initializes a new instance of <see cref="MigrationDiffService"/>.
    /// </summary>
    /// <param name="migrationRepository">Repository used to retrieve migration metadata.</param>
    /// <param name="conflictDetectionService">Service that detects schema conflicts between branches.</param>
    /// <param name="schemaChangeDetectorService">Service that extracts schema changes from a migration.</param>
    /// <param name="logger">Logger instance for diagnostic output.</param>
    /// <param name="options">
    /// Optional configuration options. May contain settings such as ignored migration patterns.
    /// </param>
    public MigrationDiffService(
        MigrationRepository migrationRepository,
        ConflictDetectionService conflictDetectionService,
        SchemaChangeDetectorService schemaChangeDetectorService,
        ILogger<MigrationDiffService> logger,
        EfMigrationDiffOptions? options = null)
    {
        _migrationRepository = migrationRepository;
        _conflictDetectionService = conflictDetectionService;
        _schemaChangeDetectorService = schemaChangeDetectorService;
        _logger = logger;
        _options = options;
    }

    /// <summary>
    /// Compares migrations between two branches and generates a diff report
    /// containing source‑only, target‑only, and common migrations along with
    /// detected schema conflicts. Retrieves all migrations from both branches,
    /// categorizes them, detects schema changes, and identifies conflicts.
    /// </summary>
    /// <param name="sourceBranch">The source (feature) branch to compare.</param>
    /// <param name="targetBranch">The target (base) branch to compare against.</param>
    /// <returns>
    /// A <see cref="MigrationDiff"/> containing categorized migrations, schema changes,
    /// and any detected conflicts between the two branches.
    /// </returns>
    /// <exception cref="ArgumentNullException">
    /// Thrown when <paramref name="sourceBranch"/> or <paramref name="targetBranch"/> is null.
    /// </exception>
    public MigrationDiff CompareBranches(BranchInfo sourceBranch, BranchInfo targetBranch)
    {
        ArgumentNullException.ThrowIfNull(sourceBranch);
        ArgumentNullException.ThrowIfNull(targetBranch);

        _logger.LogInformation("Starting comparison between branch {SourceBranch} and {TargetBranch}", sourceBranch.Id, targetBranch.Id);
        
        var diff = new MigrationDiff(sourceBranch.Id, targetBranch.Id);

        // Get all migrations for each branch
        var sourceMigrations = GetBranchMigrations(sourceBranch);
        var targetMigrations = GetBranchMigrations(targetBranch);

        // Categorize migrations
        CategorizeMigrations(sourceMigrations, targetMigrations, diff);

        // Detect schema changes in source
        foreach (var migration in sourceMigrations)
        {
            var changes = _schemaChangeDetectorService.DetectChanges(migration);
            diff.SourceSchemaChanges.AddRange(changes);
        }

        // Detect schema changes in target
        foreach (var migration in targetMigrations)
        {
            var changes = _schemaChangeDetectorService.DetectChanges(migration);
            diff.TargetSchemaChanges.AddRange(changes);
        }

        // Detect conflicts
        var conflicts = _conflictDetectionService.DetectConflicts(diff.SourceSchemaChanges, diff.TargetSchemaChanges);
        foreach (var conflict in conflicts)
        {
            diff.AddConflict(conflict);
        }

        if (diff.HasConflicts())
        {
            _logger.LogWarning("Detected {ConflictCount} conflicts between {SourceBranch} and {TargetBranch}", diff.Conflicts.Count, sourceBranch.Id, targetBranch.Id);
        }
        else
        {
            _logger.LogInformation("No conflicts detected between {SourceBranch} and {TargetBranch}", sourceBranch.Id, targetBranch.Id);
        }

        diff.GenerateSummary();
        return diff;
    }

    /// <summary>
    /// Compares migrations within a single <see cref="DbContext"/> across branches.
    /// Useful when a project contains multiple <see cref="DbContext"/> classes and you need
    /// to isolate migration analysis to a specific database context.
    /// </summary>
    /// <param name="sourceBranch">The base branch to compare from.</param>
    /// <param name="targetBranch">The feature or target branch to compare against.</param>
    /// <param name="dbContextName">
    /// The fully qualified or simple name of the <see cref="DbContext"/> class to filter migrations by.
    /// Only migrations belonging to this context are included in the comparison.
    /// </param>
    /// <returns>
    /// A <see cref="MigrationDiff"/> scoped to migrations from the specified <see cref="DbContext"/> only.
    /// </returns>
    public MigrationDiff CompareDbContextMigrations(
        BranchInfo sourceBranch,
        BranchInfo targetBranch,
        string dbContextName)
    {
        var diff = new MigrationDiff(sourceBranch.Id, targetBranch.Id);

        var sourceMigrations = GetContextMigrations(sourceBranch, dbContextName);
        var targetMigrations = GetContextMigrations(targetBranch, dbContextName);

        CategorizeMigrations(sourceMigrations, targetMigrations, diff);

        foreach (var migration in sourceMigrations)
        {
            diff.SourceSchemaChanges.AddRange(_schemaChangeDetectorService.DetectChanges(migration));
        }

        foreach (var migration in targetMigrations)
        {
            diff.TargetSchemaChanges.AddRange(_schemaChangeDetectorService.DetectChanges(migration));
        }

        var conflicts = _conflictDetectionService.DetectConflicts(diff.SourceSchemaChanges, diff.TargetSchemaChanges);
        foreach (var conflict in conflicts)
        {
            diff.AddConflict(conflict);
        }

        diff.GenerateSummary();
        return diff;
    }

    /// <summary>
    /// Gets all migrations for a specific branch, respecting the ignore list.
    /// </summary>
    private List<Migration> GetBranchMigrations(BranchInfo branch)
    {
        var migrations = new List<Migration>();

        foreach (var migrationId in branch.MigrationIds)
        {
            var migration = _migrationRepository.GetById(migrationId);
            if (migration is not null)
            {
                var identifier = migration.Name ?? migration.Id;
                if (IsIgnored(identifier))
                {
                    _logger.LogInformation("Skipping ignored migration {Migration}", identifier);
                    continue;
                }

                migrations.Add(migration);
            }
        }

        return migrations.OrderBy(m => m.Sequence).ToList();
    }

    /// <summary>
    /// Gets migrations for a specific <see cref="DbContext"/> in a branch, respecting the ignore list.
    /// </summary>
    private List<Migration> GetContextMigrations(BranchInfo branch, string dbContextName)
    {
        var migrations = new List<Migration>();

        foreach (var migrationId in branch.MigrationIds)
        {
            var migration = _migrationRepository.GetById(migrationId);
            if (migration?.DbContextName == dbContextName)
            {
                var identifier = migration.Name ?? migration.Id;
                if (IsIgnored(identifier))
                {
                    _logger.LogInformation("Skipping ignored migration {Migration}", identifier);
                    continue;
                }

                migrations.Add(migration);
            }
        }

        return migrations.OrderBy(m => m.Sequence).ToList();
    }

    /// <summary>
    /// Determines whether a migration name matches any of the ignore globs.
    /// </summary>
    private bool IsIgnored(string? migrationName)
    {
        if (string.IsNullOrEmpty(migrationName) || _options?.IgnoredMigrations == null)
            return false;

        foreach (var pattern in _options.IgnoredMigrations)
        {
            if (GlobMatch(migrationName, pattern))
                return true;
        }

        return false;
    }

    /// <summary>
    /// Simple glob matching where '*' matches any sequence of characters.
    /// Case‑insensitive.
    /// </summary>
    private bool GlobMatch(string text, string pattern)
    {
        var regexPattern = "^" + Regex.Escape(pattern).Replace("\\*", ".*") + "$";
        return Regex.IsMatch(text, regexPattern, RegexOptions.IgnoreCase);
    }

    /// <summary>
    /// Categorizes migrations into source‑only, target‑only, and common.
    /// </summary>
    private void CategorizeMigrations(
        List<Migration> sourceMigrations,
        List<Migration> targetMigrations,
        MigrationDiff diff)
    {
        var targetIds = new HashSet<string>(targetMigrations.Select(m => m.Id));
        var sourceIds = new HashSet<string>(sourceMigrations.Select(m => m.Id));

        foreach (var migration in sourceMigrations)
        {
            if (targetIds.Contains(migration.Id))
            {
                diff.AddCommonMigration(migration);
            }
            else
            {
                diff.AddSourceOnlyMigration(migration);
            }
        }

        foreach (var migration in targetMigrations)
        {
            if (!sourceIds.Contains(migration.Id))
            {
                diff.AddTargetOnlyMigration(migration);
            }
        }
    }

    /// <summary>
    /// Generates a detailed comparison report suitable for console or text display.
    /// Includes source‑only and target‑only migration lists, common migration counts,
    /// conflict details with blocking status, and schema change statistics.
    /// </summary>
    /// <param name="diff">The migration diff result to generate the report from.</param>
    /// <returns>A formatted multi‑line string containing the full comparison report.</returns>
    public string GenerateReport(MigrationDiff diff)
    {
        var report = new System.Text.StringBuilder();
        report.AppendLine("=== Migration Diff Report ===");
        report.AppendLine($"Result: {diff.GetResultDescription()}");
        report.AppendLine();

        report.AppendLine($"Source Only Migrations: {diff.OnlyInSource.Count}");
        foreach (var migration in diff.OnlyInSource)
        {
            report.AppendLine($"  - {migration.Name}");
        }
        report.AppendLine();

        report.AppendLine($"Target Only Migrations: {diff.OnlyInTarget.Count}");
        foreach (var migration in diff.OnlyInTarget)
        {
            report.AppendLine($"  - {migration.Name}");
        }
        report.AppendLine();

        report.AppendLine($"Common Migrations: {diff.InBoth.Count}");
        report.AppendLine();

        if (diff.HasConflicts())
        {
            report.AppendLine($"Conflicts Detected: {diff.Conflicts.Count}");
            report.AppendLine($"Blocking Conflicts: {diff.GetBlockingConflicts()}");
            foreach (var conflict in diff.Conflicts)
            {
                report.AppendLine($"  - {conflict}");
            }
            report.AppendLine();
        }

        report.AppendLine($"Schema Changes: {diff.GetTotalSchemaChanges()}");
        report.AppendLine($"Destructive Changes: {diff.GetDestructiveChanges().Count}");

        return report.ToString();
    }
}