Модуль подписки пользователя в ASP.NET MVC

[ApiController]
[Route("api/subscriptions")]
public class SubscriptionController : ControllerBase
{
    private readonly ISubscriptionService _subscriptionService;
    
    public SubscriptionController(ISubscriptionService subscriptionService)
    {
        _subscriptionService = subscriptionService;
    }
    
    [HttpPost("subscribe")]
    public async Task<ActionResult<SubscriptionResponse>> Subscribe(
        [FromBody] SubscriptionRequest request)
    {
        var result = await _subscriptionService.CreateSubscriptionAsync(
            request.UserId, request.PlanId, request.PaymentToken);
            
        return result.IsSuccess 
            ? Ok(result.Value) 
            : BadRequest(result.Error);
    }
}

public class SubscriptionService : ISubscriptionService
{
    private readonly ISubscriptionRepository _repository;
    private readonly IPaymentService _paymentService;
    private readonly INotificationService _notificationService;
    
    public async Task<Result<Subscription>> CreateSubscriptionAsync(
        int userId, int planId, string paymentToken)
    {
        var user = await _repository.GetUserAsync(userId);
        if (user == null) return Result.Fail<Subscription>("User not found");
        
        var plan = await _repository.GetPlanAsync(planId);
        if (plan == null) return Result.Fail<Subscription>("Plan not found");
        
        var paymentResult = await _paymentService.ProcessPaymentAsync(
            paymentToken, plan.Price);
            
        if (!paymentResult.IsSuccess)
            return Result.Fail<Subscription>("Payment failed");
            
        var subscription = new Subscription(userId, planId, DateTime.UtcNow);
        await _repository.SaveSubscriptionAsync(subscription);
        
        await _notificationService.SendWelcomeEmailAsync(user.Email);
        
        return Result.Success(subscription);
    }
}

public class SubscriptionRepository : ISubscriptionRepository
{
    private readonly ApplicationDbContext _context;
    
    public async Task<Subscription> GetActiveSubscriptionAsync(int userId)
    {
        return await _context.Subscriptions
            .Where(s => s.UserId == userId && s.IsActive)
            .OrderByDescending(s => s.CreatedAt)
            .FirstOrDefaultAsync();
    }
    
    public async Task SaveSubscriptionAsync(Subscription subscription)
    {
        _context.Subscriptions.Add(subscription);
        await _context.SaveChangesAsync();
    }
}

public class SubscriptionCreated : IDomainEvent
{
    public int UserId { get; }
    public int PlanId { get; }
    public DateTime CreatedAt { get; }
    
    public SubscriptionCreated(int userId, int planId)
    {
        UserId = userId;
        PlanId = planId;
        CreatedAt = DateTime.UtcNow;
    }
}

public class Subscription
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public int PlanId { get; set; }
    public SubscriptionStatus Status { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? ActivatedAt { get; set; }
    public DateTime? ExpiresAt { get; set; }
    public DateTime? CanceledAt { get; set; }
    public string CancellationReason { get; set; }
    public decimal AmountPaid { get; set; }
    public string Currency { get; set; }
    public string ExternalPaymentId { get; set; }
    
    public virtual User User { get; set; }
    public virtual SubscriptionPlan Plan { get; set; }
    public virtual ICollection<SubscriptionHistory> History { get; set; }
}
 
public enum SubscriptionStatus
{
    Pending,
    Active,
    Suspended,
    Canceled,
    Expired,
    Failed
}

public class ApplicationUser : IdentityUser
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime LastLoginAt { get; set; }
    public bool IsBlocked { get; set; }
    public string TimeZone { get; set; }
    public string PreferredLanguage { get; set; }
    
    public virtual UserProfile Profile { get; set; }
    public virtual ICollection<Subscription> Subscriptions { get; set; }
    public virtual ICollection<PaymentMethod> PaymentMethods { get; set; }
}

public class SubscriptionPlan
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal BasePrice { get; set; }
    public string Currency { get; set; }
    public BillingCycle BillingCycle { get; set; }
    public int TrialDays { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedAt { get; set; }
    public int MaxUsers { get; set; }
    public int MaxProjects { get; set; }
    public long StorageLimit { get; set; }
    
    public virtual ICollection<PlanFeature> Features { get; set; }
    public virtual ICollection<PlanPricing> RegionalPricing { get; set; }
}
 
public enum BillingCycle
{
    Monthly,
    Quarterly,
    Yearly,
    Lifetime
}

public class SubscriptionHistory
{
    public int Id { get; set; }
    public int SubscriptionId { get; set; }
    public SubscriptionStatus PreviousStatus { get; set; }
    public SubscriptionStatus NewStatus { get; set; }
    public string Reason { get; set; }
    public DateTime ChangedAt { get; set; }
    public string ChangedBy { get; set; }
    public string AdditionalData { get; set; }
    
    public virtual Subscription Subscription { get; set; }
}

public class PaymentMethod
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public PaymentType Type { get; set; }
    public string Token { get; set; }
    public string LastFourDigits { get; set; }
    public string ExpiryMonth { get; set; }
    public string ExpiryYear { get; set; }
    public string CardBrand { get; set; }
    public bool IsDefault { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedAt { get; set; }
    
    public virtual ApplicationUser User { get; set; }
}
 
public enum PaymentType
{
    CreditCard,
    DebitCard,
    PayPal,
    BankTransfer,
    Cryptocurrency
}

[Required]
[Range(0.01, 999999.99)]
public decimal BasePrice { get; set; }
 
[Required]
[StringLength(100)]
public string Name { get; set; }

public class SubscriptionDbContext : IdentityDbContext<ApplicationUser>
{
    public DbSet<Subscription> Subscriptions { get; set; }
    public DbSet<SubscriptionPlan> SubscriptionPlans { get; set; }
    public DbSet<SubscriptionHistory> SubscriptionHistories { get; set; }
    public DbSet<PaymentMethod> PaymentMethods { get; set; }
    public DbSet<Invoice> Invoices { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // Subscription configuration
        modelBuilder.Entity<Subscription>(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.Property(e => e.Status).HasConversion<int>();
            entity.Property(e => e.AmountPaid).HasPrecision(10, 2);
            entity.Property(e => e.Currency).HasMaxLength(3);
            
            entity.HasIndex(e => new { e.UserId, e.Status, e.ExpiresAt })
                  .HasDatabaseName("IX_Subscription_User_Status_Expires");
                  
            entity.HasOne(d => d.User)
                  .WithMany(p => p.Subscriptions)
                  .HasForeignKey(d => d.UserId)
                  .OnDelete(DeleteBehavior.Restrict);
        });
        
        // Soft delete filter
        modelBuilder.Entity<Subscription>()
                   .HasQueryFilter(e => !e.IsDeleted);
    }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseSqlServer(connectionString, options =>
            {
                options.MigrationsHistoryTable("__EFMigrationsHistory", "subscription");
                options.EnableRetryOnFailure(3, TimeSpan.FromSeconds(10), null);
                options.CommandTimeout(30);
            });
        }
    }
}

public partial class MigrateExistingSubscriptionsToNewPlans : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        // Сначала структурные изменения
        migrationBuilder.AddColumn<int>(
            name: "NewPlanId",
            table: "Subscriptions",
            nullable: true);
            
        // Потом миграция данных
        migrationBuilder.Sql(@"
            UPDATE Subscriptions 
            SET NewPlanId = CASE 
                WHEN PlanId = 1 THEN 10  -- Basic -> Starter
                WHEN PlanId = 2 THEN 11  -- Pro -> Professional  
                WHEN PlanId = 3 THEN 12  -- Enterprise -> Business
                ELSE PlanId 
            END
            WHERE PlanId IN (1, 2, 3)
        ");
        
        // Проверяем результат
        migrationBuilder.Sql(@"
            IF EXISTS (SELECT 1 FROM Subscriptions WHERE NewPlanId IS NULL AND Status = 1)
            BEGIN
                RAISERROR('Migration failed: some active subscriptions have no new plan', 16, 1)
            END
        ");
    }
    
    protected override void Down(MigrationBuilder migrationBuilder)
    {
        // Откат данных перед структурными изменениями
        migrationBuilder.Sql(@"
            UPDATE Subscriptions 
            SET PlanId = CASE 
                WHEN NewPlanId = 10 THEN 1
                WHEN NewPlanId = 11 THEN 2  
                WHEN NewPlanId = 12 THEN 3
                ELSE NewPlanId 
            END
            WHERE NewPlanId IN (10, 11, 12)
        ");
        
        migrationBuilder.DropColumn(
            name: "NewPlanId",
            table: "Subscriptions");
    }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);
    
    // Seed data for subscription plans
    modelBuilder.Entity<SubscriptionPlan>().HasData(
        new SubscriptionPlan 
        { 
            Id = 1, 
            Name = "Free", 
            BasePrice = 0, 
            BillingCycle = BillingCycle.Monthly,
            IsActive = true,
            MaxUsers = 1,
            StorageLimit = 1024 * 1024 * 1024 // 1GB
        },
        new SubscriptionPlan 
        { 
            Id = 2, 
            Name = "Professional", 
            BasePrice = 29.99m, 
            BillingCycle = BillingCycle.Monthly,
            IsActive = true,
            MaxUsers = 10,
            StorageLimit = 100L * 1024 * 1024 * 1024 // 100GB
        }
    );
}

// Медленный запрос без индекса
var activeSubscriptions = await context.Subscriptions
    .Where(s => s.Status == SubscriptionStatus.Active)
    .Where(s => s.ExpiresAt > DateTime.UtcNow)
    .ToListAsync();

// Оптимизированный запрос с учетом партиционирования
var userActiveSubscription = await context.Subscriptions
    .Where(s => s.UserId == userId)
    .Where(s => s.Status == SubscriptionStatus.Active)
    .Where(s => s.ExpiresAt > DateTime.UtcNow)
    .OrderByDescending(s => s.CreatedAt)
    .Select(s => new SubscriptionDto 
    {
        Id = s.Id,
        PlanName = s.Plan.Name,
        ExpiresAt = s.ExpiresAt
    })
    .FirstOrDefaultAsync();

public async Task<List<SubscriptionPlan>> GetActivePlansAsync()
{
    const string cacheKey = "active_subscription_plans";
    
    if (!_cache.TryGetValue(cacheKey, out List<SubscriptionPlan> plans))
    {
        plans = await _context.SubscriptionPlans
            .Where(p => p.IsActive)
            .OrderBy(p => p.BasePrice)
            .ToListAsync();
            
        _cache.Set(cacheKey, plans, TimeSpan.FromMinutes(15));
    }
    
    return plans;
}

public class SubscriptionService
{
  private readonly ISubscriptionRepository _repository;
  private readonly IPaymentService _paymentService;
  private readonly INotificationService _notifications;
  private readonly ILogger<SubscriptionService> _logger;
  
  public async Task<Result<Subscription>> CreateSubscriptionAsync(
      CreateSubscriptionRequest request)
  {
      try
      {
          await using var transaction = await _repository.BeginTransactionAsync();
          
          // Валидируем пользователя
          var user = await _repository.GetUserByIdAsync(request.UserId);
          if (user == null)
              return Result.Fail<Subscription>("User not found");
              
          // Проверяем существующие активные подписки
          var existingSubscription = await _repository
              .GetActiveSubscriptionAsync(request.UserId);
              
          if (existingSubscription != null && !request.AllowUpgrade)
              return Result.Fail<Subscription>("User already has active subscription");
          
          // Получаем план
          var plan = await _repository.GetPlanByIdAsync(request.PlanId);
          if (plan == null || !plan.IsActive)
              return Result.Fail<Subscription>("Invalid subscription plan");
          
          // Создаем подписку в статусе Pending
          var subscription = new Subscription
          {
              UserId = request.UserId,
              PlanId = request.PlanId,
              Status = SubscriptionStatus.Pending,
              CreatedAt = DateTime.UtcNow,
              Currency = plan.Currency,
              AmountToBePaid = CalculateAmount(plan, request.PromoCode)
          };
          
          await _repository.SaveSubscriptionAsync(subscription);
          
          // Обрабатываем платеж
          var paymentResult = await ProcessPaymentAsync(subscription, request.PaymentToken);
          if (!paymentResult.IsSuccess)
          {
              subscription.Status = SubscriptionStatus.Failed;
              subscription.FailureReason = paymentResult.Error;
              await _repository.UpdateSubscriptionAsync(subscription);
              await transaction.RollbackAsync();
              return Result.Fail<Subscription>(paymentResult.Error);
          }
          
          // Активируем подписку
          subscription.Status = SubscriptionStatus.Active;
          subscription.ActivatedAt = DateTime.UtcNow;
          subscription.ExpiresAt = CalculateExpirationDate(plan);
          subscription.ExternalPaymentId = paymentResult.Value.TransactionId;
          
          // Деактивируем старую подписку если есть
          if (existingSubscription != null)
          {
              await DeactivateSubscriptionAsync(existingSubscription, "Upgraded to new plan");
          }
          
          await _repository.UpdateSubscriptionAsync(subscription);
          await transaction.CommitAsync();
          
          // Отправляем уведомления
          await _notifications.SendWelcomeEmailAsync(user.Email, subscription);
          
          _logger.LogInformation("Subscription {SubscriptionId} created for user {UserId}", 
              subscription.Id, request.UserId);
              
          return Result.Success(subscription);
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Failed to create subscription for user {UserId}", request.UserId);
          return Result.Fail<Subscription>("Failed to create subscription");
      }
  }
}

private decimal CalculateAmount(SubscriptionPlan plan, string promoCode = null)
{
  decimal baseAmount = plan.BasePrice;
  
  // Применяем промокод
  if (!string.IsNullOrEmpty(promoCode))
  {
      var discount = await _repository.GetValidPromoCodeAsync(promoCode);
      if (discount != null)
      {
          baseAmount = discount.Type == DiscountType.Percentage 
              ? baseAmount * (1 - discount.Value / 100)
              : Math.Max(0, baseAmount - discount.Value);
      }
  }
  
  // Добавляем налоги
  var taxRate = await _taxService.GetTaxRateAsync(user.Country, plan.Category);
  var totalAmount = baseAmount * (1 + taxRate);
  
  return Math.Round(totalAmount, 2, MidpointRounding.AwayFromZero);
}

public interface ISubscriptionRepository
{
    Task<Subscription> GetByIdAsync(int id);
    Task<Subscription> GetActiveSubscriptionAsync(int userId);
    Task<List<Subscription>> GetUserSubscriptionsAsync(int userId);
    Task<List<Subscription>> GetExpiringSubscriptionsAsync(DateTime date);
    Task<Subscription> SaveAsync(Subscription subscription);
    Task<bool> UpdateAsync(Subscription subscription);
    Task<bool> CancelAsync(int subscriptionId, string reason);
    Task<IDbTransaction> BeginTransactionAsync();
}
 
public class SubscriptionRepository : ISubscriptionRepository
{
    private readonly SubscriptionDbContext _context;
    private readonly IMemoryCache _cache;
    private readonly ILogger<SubscriptionRepository> _logger;
 
    public SubscriptionRepository(
        SubscriptionDbContext context,
        IMemoryCache cache,
        ILogger<SubscriptionRepository> logger)
    {
        _context = context;
        _cache = cache;
        _logger = logger;
    }
 
    public async Task<Subscription> GetActiveSubscriptionAsync(int userId)
    {
        var cacheKey = $"active_subscription_{userId}";
        
        if (_cache.TryGetValue(cacheKey, out Subscription cachedSubscription))
        {
            return cachedSubscription;
        }
 
        var subscription = await _context.Subscriptions
            .Include(s => s.Plan)
            .Where(s => s.UserId == userId)
            .Where(s => s.Status == SubscriptionStatus.Active)
            .Where(s => s.ExpiresAt > DateTime.UtcNow)
            .OrderByDescending(s => s.CreatedAt)
            .FirstOrDefaultAsync();
 
        if (subscription != null)
        {
            _cache.Set(cacheKey, subscription, TimeSpan.FromMinutes(5));
        }
 
        return subscription;
    }
 
    public async Task<List<Subscription>> GetExpiringSubscriptionsAsync(DateTime date)
    {
        return await _context.Subscriptions
            .Where(s => s.Status == SubscriptionStatus.Active)
            .Where(s => s.ExpiresAt.Date == date.Date)
            .Include(s => s.User)
            .Include(s => s.Plan)
            .ToListAsync();
    }
}

public interface ISubscriptionManagementService
{
    Task<Result<SubscriptionDto>> CreateSubscriptionAsync(CreateSubscriptionCommand command);
    Task<Result<SubscriptionDto>> UpgradeSubscriptionAsync(UpgradeSubscriptionCommand command);
    Task<Result> CancelSubscriptionAsync(CancelSubscriptionCommand command);
    Task<Result<SubscriptionDto>> ReactivateSubscriptionAsync(int subscriptionId, int userId);
    Task<Result<decimal>> CalculateUpgradeCostAsync(int subscriptionId, int newPlanId);
    Task<List<SubscriptionDto>> GetUserSubscriptionHistoryAsync(int userId);
    Task<Result> ProcessRenewalAsync(int subscriptionId);
}
 
public class SubscriptionManagementService : ISubscriptionManagementService
{
    private readonly ISubscriptionRepository _subscriptionRepository;
    private readonly IPaymentService _paymentService;
    private readonly IUserRepository _userRepository;
    private readonly IPlanRepository _planRepository;
    private readonly INotificationService _notificationService;
    private readonly ISubscriptionCalculator _calculator;
    private readonly IEventPublisher _eventPublisher;
    private readonly ILogger<SubscriptionManagementService> _logger;
 
    public async Task<Result<SubscriptionDto>> UpgradeSubscriptionAsync(UpgradeSubscriptionCommand command)
    {
        try 
        {
            // Получаем текущую подписку
            var currentSubscription = await _subscriptionRepository.GetActiveSubscriptionAsync(command.UserId);
            if (currentSubscription == null)
                return Result.Fail<SubscriptionDto>("No active subscription found");
 
            // Проверяем новый план
            var newPlan = await _planRepository.GetByIdAsync(command.NewPlanId);
            if (newPlan == null || !newPlan.IsActive)
                return Result.Fail<SubscriptionDto>("Invalid plan selected");
 
            if (newPlan.Id == currentSubscription.PlanId)
                return Result.Fail<SubscriptionDto>("Already subscribed to this plan");
 
            // Рассчитываем стоимость апгрейда
            var upgradeCost = await _calculator.CalculateUpgradeCostAsync(
                currentSubscription, newPlan, DateTime.UtcNow);
 
            if (upgradeCost < 0)
                return Result.Fail<SubscriptionDto>("Downgrade not supported through upgrade endpoint");
 
            // Обрабатываем платеж если нужно доплатить
            PaymentResult paymentResult = null;
            if (upgradeCost > 0)
            {
                paymentResult = await _paymentService.ProcessPaymentAsync(new PaymentRequest
                {
                    Amount = upgradeCost,
                    Currency = newPlan.Currency,
                    PaymentToken = command.PaymentToken,
                    UserId = command.UserId,
                    Description = $"Upgrade to {newPlan.Name}"
                });
 
                if (!paymentResult.IsSuccess)
                    return Result.Fail<SubscriptionDto>($"Payment failed: {paymentResult.ErrorMessage}");
            }
 
            // Обновляем подписку
            using var transaction = await _subscriptionRepository.BeginTransactionAsync();
            
            currentSubscription.PlanId = command.NewPlanId;
            currentSubscription.UpdatedAt = DateTime.UtcNow;
            
            // Пересчитываем дату окончания
            var remainingTime = currentSubscription.ExpiresAt - DateTime.UtcNow;
            currentSubscription.ExpiresAt = DateTime.UtcNow.Add(
                _calculator.AdjustRemainingTime(remainingTime, currentSubscription.Plan, newPlan));
 
            await _subscriptionRepository.UpdateAsync(currentSubscription);
 
            // Записываем в историю
            await _subscriptionRepository.AddHistoryEntryAsync(new SubscriptionHistory
            {
                SubscriptionId = currentSubscription.Id,
                Action = SubscriptionAction.Upgraded,
                PreviousPlanId = currentSubscription.PlanId,
                NewPlanId = command.NewPlanId,
                Amount = upgradeCost,
                PaymentId = paymentResult?.TransactionId,
                CreatedAt = DateTime.UtcNow
            });
 
            await transaction.CommitAsync();
 
            // Публикуем событие
            await _eventPublisher.PublishAsync(new SubscriptionUpgraded
            {
                SubscriptionId = currentSubscription.Id,
                UserId = command.UserId,
                PreviousPlanId = currentSubscription.PlanId,
                NewPlanId = command.NewPlanId,
                UpgradeCost = upgradeCost
            });
 
            // Отправляем уведомление
            var user = await _userRepository.GetByIdAsync(command.UserId);
            await _notificationService.SendUpgradeConfirmationAsync(user.Email, currentSubscription, newPlan);
 
            return Result.Success(MapToDto(currentSubscription));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to upgrade subscription for user {UserId} to plan {PlanId}", 
                command.UserId, command.NewPlanId);
            return Result.Fail<SubscriptionDto>("Upgrade failed due to system error");
        }
    }
}

public interface IUnitOfWork : IDisposable
{
    ISubscriptionRepository Subscriptions { get; }
    IUserRepository Users { get; }
    IPaymentRepository Payments { get; }
    ISubscriptionHistoryRepository History { get; }
    
    Task<int> SaveChangesAsync();
    Task BeginTransactionAsync();
    Task CommitAsync();
    Task RollbackAsync();
}
 
public class UnitOfWork : IUnitOfWork
{
    private readonly SubscriptionDbContext _context;
    private IDbContextTransaction _transaction;
    private bool _disposed;
    
    private ISubscriptionRepository _subscriptions;
    private IUserRepository _users;
    private IPaymentRepository _payments;
    private ISubscriptionHistoryRepository _history;
 
    public UnitOfWork(SubscriptionDbContext context)
    {
        _context = context;
    }
 
    public ISubscriptionRepository Subscriptions => 
        _subscriptions ??= new SubscriptionRepository(_context);
        
    public IUserRepository Users => 
        _users ??= new UserRepository(_context);
        
    public IPaymentRepository Payments => 
        _payments ??= new PaymentRepository(_context);
        
    public ISubscriptionHistoryRepository History => 
        _history ??= new SubscriptionHistoryRepository(_context);
 
    public async Task BeginTransactionAsync()
    {
        _transaction = await _context.Database.BeginTransactionAsync();
    }
 
    public async Task CommitAsync()
    {
        try
        {
            await _context.SaveChangesAsync();
            if (_transaction != null)
            {
                await _transaction.CommitAsync();
            }
        }
        catch
        {
            await RollbackAsync();
            throw;
        }
    }
 
    public async Task RollbackAsync()
    {
        if (_transaction != null)
        {
            await _transaction.RollbackAsync();
        }
    }
 
    public async Task<int> SaveChangesAsync()
    {
        return await _context.SaveChangesAsync();
    }
 
    public void Dispose()
    {
        if (!_disposed)
        {
            _transaction?.Dispose();
            _context?.Dispose();
            _disposed = true;
        }
    }
}

public async Task<Result<Subscription>> CreateSubscriptionWithUnitOfWorkAsync(CreateSubscriptionRequest request)
{
    using var unitOfWork = _unitOfWorkFactory.Create();
    
    try
    {
        await unitOfWork.BeginTransactionAsync();
        
        // Создаем подписку
        var subscription = new Subscription
        {
            UserId = request.UserId,
            PlanId = request.PlanId,
            Status = SubscriptionStatus.Pending,
            CreatedAt = DateTime.UtcNow
        };
        
        await unitOfWork.Subscriptions.AddAsync(subscription);
        
        // Записываем платеж
        var payment = new Payment
        {
            UserId = request.UserId,
            Amount = request.Amount,
            Status = PaymentStatus.Processing,
            ExternalTransactionId = request.PaymentToken
        };
        
        await unitOfWork.Payments.AddAsync(payment);
        
        // Добавляем запись в историю
        var historyEntry = new SubscriptionHistory
        {
            SubscriptionId = subscription.Id,
            Action = "Created",
            Details = $"Subscription created for plan {request.PlanId}",
            CreatedAt = DateTime.UtcNow
        };
        
        await unitOfWork.History.AddAsync(historyEntry);
        
        // Обновляем статистику пользователя
        var user = await unitOfWork.Users.GetByIdAsync(request.UserId);
        user.LastSubscriptionDate = DateTime.UtcNow;
        user.TotalSubscriptions++;
        
        await unitOfWork.Users.UpdateAsync(user);
        
        // Фиксируем все изменения
        await unitOfWork.CommitAsync();
        
        return Result.Success(subscription);
    }
    catch (Exception ex)
    {
        await unitOfWork.RollbackAsync();
        _logger.LogError(ex, "Failed to create subscription for user {UserId}", request.UserId);
        return Result.Fail<Subscription>("Failed to create subscription");
    }
}

public enum SubscriptionStatus
{
    Pending,
    Active,
    Suspended,
    Canceled,
    Expired,
    Failed,
    PendingCancellation,
    Refunded
}
 
public interface ISubscriptionStateMachine
{
    Task<StateTransitionResult> TransitionAsync(Subscription subscription, SubscriptionStatus targetStatus, StateTransitionContext context);
    bool CanTransition(SubscriptionStatus currentStatus, SubscriptionStatus targetStatus);
    List<SubscriptionStatus> GetAllowedTransitions(SubscriptionStatus currentStatus);
}
 
public class SubscriptionStateMachine : ISubscriptionStateMachine
{
    private readonly Dictionary<SubscriptionStatus, List<SubscriptionStatus>> _allowedTransitions;
    private readonly Dictionary<(SubscriptionStatus, SubscriptionStatus), Func<Subscription, StateTransitionContext, Task<bool>>> _transitionGuards;
    private readonly Dictionary<(SubscriptionStatus, SubscriptionStatus), Func<Subscription, StateTransitionContext, Task>> _transitionActions;
    private readonly ILogger<SubscriptionStateMachine> _logger;
 
    public SubscriptionStateMachine(ILogger<SubscriptionStateMachine> logger)
    {
        _logger = logger;
        _allowedTransitions = InitializeTransitions();
        _transitionGuards = InitializeGuards();
        _transitionActions = InitializeActions();
    }
 
    private Dictionary<SubscriptionStatus, List<SubscriptionStatus>> InitializeTransitions()
    {
        return new Dictionary<SubscriptionStatus, List<SubscriptionStatus>>
        {
            [SubscriptionStatus.Pending] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Active, 
                SubscriptionStatus.Failed, 
                SubscriptionStatus.Canceled 
            },
            [SubscriptionStatus.Active] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Suspended, 
                SubscriptionStatus.PendingCancellation,
                SubscriptionStatus.Expired,
                SubscriptionStatus.Canceled 
            },
            [SubscriptionStatus.Suspended] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Active, 
                SubscriptionStatus.Canceled,
                SubscriptionStatus.Expired 
            },
            [SubscriptionStatus.PendingCancellation] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Canceled, 
                SubscriptionStatus.Active 
            },
            [SubscriptionStatus.Failed] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Pending, 
                SubscriptionStatus.Canceled 
            },
            [SubscriptionStatus.Expired] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Active, 
                SubscriptionStatus.Canceled 
            },
            [SubscriptionStatus.Canceled] = new List<SubscriptionStatus> 
            { 
                SubscriptionStatus.Pending 
            },
            [SubscriptionStatus.Refunded] = new List<SubscriptionStatus>()
        };
    }
}

private Dictionary<(SubscriptionStatus, SubscriptionStatus), Func<Subscription, StateTransitionContext, Task<bool>>> InitializeGuards()
{
    return new Dictionary<(SubscriptionStatus, SubscriptionStatus), Func<Subscription, StateTransitionContext, Task<bool>>>
    {
        [(SubscriptionStatus.Pending, SubscriptionStatus.Active)] = async (subscription, context) =>
        {
            // Можно активировать только если платеж прошел успешно
            return context.PaymentResult != null && context.PaymentResult.IsSuccess;
        },
        
        [(SubscriptionStatus.Active, SubscriptionStatus.Suspended)] = async (subscription, context) =>
        {
            // Приостановить можно только при проблемах с платежом или превышении лимитов
            return context.Reason == SuspensionReason.PaymentFailed || 
                   context.Reason == SuspensionReason.LimitExceeded;
        },
        
        [(SubscriptionStatus.Suspended, SubscriptionStatus.Active)] = async (subscription, context) =>
        {
            // Реактивировать можно только если проблемы решены
            var daysSuspended = (DateTime.UtcNow - subscription.SuspendedAt.Value).TotalDays;
            return daysSuspended <= 30 && context.PaymentResult?.IsSuccess == true;
        },
        
        [(SubscriptionStatus.PendingCancellation, SubscriptionStatus.Active)] = async (subscription, context) =>
        {
            // Отменить отмену можно только до конца биллингового периода
            return subscription.ExpiresAt > DateTime.UtcNow.AddDays(1);
        }
    };
}

public async Task<StateTransitionResult> TransitionAsync(Subscription subscription, SubscriptionStatus targetStatus, StateTransitionContext context)
{
    var currentStatus = subscription.Status;
    
    // Проверяем базовую допустимость перехода
    if (!CanTransition(currentStatus, targetStatus))
    {
        return StateTransitionResult.Failed($"Transition from {currentStatus} to {targetStatus} is not allowed");
    }
    
    // Выполняем guard проверки
    var guardKey = (currentStatus, targetStatus);
    if (_transitionGuards.ContainsKey(guardKey))
    {
        var canTransition = await _transitionGuards[guardKey](subscription, context);
        if (!canTransition)
        {
            return StateTransitionResult.Failed($"Guard condition failed for transition {currentStatus} -> {targetStatus}");
        }
    }
    
    // Сохраняем предыдущий статус для истории
    var previousStatus = subscription.Status;
    
    // Выполняем переход
    subscription.Status = targetStatus;
    subscription.StatusChangedAt = DateTime.UtcNow;
    subscription.StatusChangedBy = context.UserId;
    
    // Обновляем специфичные для статуса поля
    UpdateStatusSpecificFields(subscription, targetStatus, context);
    
    try
    {
        // Выполняем action'ы для данного перехода
        if (_transitionActions.ContainsKey(guardKey))
        {
            await _transitionActions[guardKey](subscription, context);
        }
        
        _logger.LogInformation("Subscription {SubscriptionId} transitioned from {PreviousStatus} to {NewStatus}", 
            subscription.Id, previousStatus, targetStatus);
            
        return StateTransitionResult.Success(subscription);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to execute transition actions for subscription {SubscriptionId}", subscription.Id);
        return StateTransitionResult.Failed($"Transition actions failed: {ex.Message}");
    }
}
 
private void UpdateStatusSpecificFields(Subscription subscription, SubscriptionStatus newStatus, StateTransitionContext context)
{
    switch (newStatus)
    {
        case SubscriptionStatus.Active:
            subscription.ActivatedAt = DateTime.UtcNow;
            subscription.SuspendedAt = null;
            subscription.CanceledAt = null;
            break;
            
        case SubscriptionStatus.Suspended:
            subscription.SuspendedAt = DateTime.UtcNow;
            subscription.SuspensionReason = context.Reason?.ToString();
            break;
            
        case SubscriptionStatus.Canceled:
            subscription.CanceledAt = DateTime.UtcNow;
            subscription.CancellationReason = context.CancellationReason;
            break;
            
        case SubscriptionStatus.Failed:
            subscription.FailedAt = DateTime.UtcNow;
            subscription.FailureReason = context.FailureReason;
            break;
    }
}

public class CreateSubscriptionRequest
{
    [Required(ErrorMessage = "User ID is required")]
    [Range(1, int.MaxValue, ErrorMessage = "User ID must be positive")]
    public int UserId { get; set; }
 
    [Required(ErrorMessage = "Plan ID is required")]  
    [Range(1, int.MaxValue, ErrorMessage = "Plan ID must be positive")]
    public int PlanId { get; set; }
 
    [Required(ErrorMessage = "Payment token is required")]
    [StringLength(255, MinimumLength = 10, ErrorMessage = "Payment token must be between 10 and 255 characters")]
    public string PaymentToken { get; set; }
 
    [Range(0.01, 999999.99, ErrorMessage = "Amount must be between 0.01 and 999999.99")]
    public decimal Amount { get; set; }
 
    [RegularExpression("^[A-Z]{3}$", ErrorMessage = "Currency must be a valid 3-letter ISO code")]
    public string Currency { get; set; }
 
    [EmailAddress(ErrorMessage = "Invalid email format")]
    public string UserEmail { get; set; }
}

[HttpPost]
public async Task<ActionResult<SubscriptionResponse>> CreateSubscription([FromBody] CreateSubscriptionRequest request)
{
    if (!ModelState.IsValid)
    {
        var errors = ModelState
            .Where(x => x.Value.Errors.Count > 0)
            .ToDictionary(
                kvp => kvp.Key,
                kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()
            );
            
        _logger.LogWarning("Validation failed for subscription creation: {@Errors}", errors);
        
        return BadRequest(new { 
            Message = "Validation failed", 
            Errors = errors 
        });
    }
 
    var result = await _subscriptionService.CreateSubscriptionAsync(request);
    
    return result.IsSuccess 
        ? Ok(result.Value) 
        : BadRequest(new { Message = result.ErrorMessage });
}

public class CreateSubscriptionValidator : AbstractValidator<CreateSubscriptionRequest>
{
    private readonly IPlanRepository _planRepository;
    private readonly IUserRepository _userRepository;
 
    public CreateSubscriptionValidator(IPlanRepository planRepository, IUserRepository userRepository)
    {
        _planRepository = planRepository;
        _userRepository = userRepository;
 
        RuleFor(x => x.UserId)
            .MustAsync(UserExistsAndActive)
            .WithMessage("User does not exist or is inactive");
 
        RuleFor(x => x.PlanId)
            .MustAsync(PlanExistsAndActive)
            .WithMessage("Selected plan is not available");
 
        RuleFor(x => x.Amount)
            .MustAsync(MatchesPlanPrice)
            .WithMessage("Amount does not match plan price");
 
        RuleFor(x => x.PaymentToken)
            .MustAsync(BeValidPaymentToken)
            .WithMessage("Invalid or expired payment token");
 
        When(x => !string.IsNullOrEmpty(x.UserEmail), () => {
            RuleFor(x => x.UserEmail)
                .MustAsync(MatchUserEmail)
                .WithMessage("Email does not match user account");
        });
    }
 
    private async Task<bool> UserExistsAndActive(int userId, CancellationToken token)
    {
        var user = await _userRepository.GetByIdAsync(userId);
        return user != null && !user.IsBlocked;
    }
 
    private async Task<bool> PlanExistsAndActive(int planId, CancellationToken token)
    {
        var plan = await _planRepository.GetByIdAsync(planId);
        return plan != null && plan.IsActive;
    }
 
    private async Task<bool> MatchesPlanPrice(CreateSubscriptionRequest request, decimal amount, ValidationContext<CreateSubscriptionRequest> context, CancellationToken token)
    {
        var plan = await _planRepository.GetByIdAsync(request.PlanId);
        if (plan == null) return false;
        
        var calculatedAmount = await CalculateFinalAmount(plan, request.UserId);
        return Math.Abs(amount - calculatedAmount) < 0.01m;
    }
}

[ApiController]
[Route("api/[controller]")]
[Authorize]
public class SubscriptionsController : ControllerBase
{
    private readonly ISubscriptionManagementService _subscriptionService;
    private readonly IMapper _mapper;
 
    [HttpGet]
    public async Task<ActionResult<List<SubscriptionDto>>> GetMySubscriptions()
    {
        var userId = GetCurrentUserId();
        var subscriptions = await _subscriptionService.GetUserSubscriptionsAsync(userId);
        
        return Ok(_mapper.Map<List<SubscriptionDto>>(subscriptions));
    }
 
    [HttpPost]
    public async Task<ActionResult<SubscriptionDto>> CreateSubscription([FromBody] CreateSubscriptionRequest request)
    {
        request.UserId = GetCurrentUserId();
        
        var result = await _subscriptionService.CreateSubscriptionAsync(request);
        if (!result.IsSuccess)
            return BadRequest(new { error = result.ErrorMessage });
            
        return CreatedAtAction(nameof(GetSubscription), 
            new { id = result.Value.Id }, 
            _mapper.Map<SubscriptionDto>(result.Value));
    }
 
    [HttpPut("{id}/cancel")]
    public async Task<ActionResult> CancelSubscription(int id, [FromBody] CancelSubscriptionRequest request)
    {
        var userId = GetCurrentUserId();
        var result = await _subscriptionService.CancelSubscriptionAsync(id, userId, request.Reason);
        
        return result.IsSuccess ? NoContent() : BadRequest(new { error = result.ErrorMessage });
    }
}

[ApiController]
[Route("api/v1/subscriptions")]
public class SubscriptionApiController : ControllerBase
{
  private readonly ISubscriptionService _subscriptionService;
  private readonly IMapper _mapper;
  
  [HttpGet("dashboard")]
  public async Task<ActionResult<SubscriptionDashboardDto>> GetDashboard()
  {
      var userId = GetCurrentUserId();
      
      var dashboard = await _subscriptionService.GetUserDashboardAsync(userId);
      
      return Ok(new SubscriptionDashboardDto
      {
          CurrentSubscription = _mapper.Map<CurrentSubscriptionDto>(dashboard.ActiveSubscription),
          UsageStatistics = _mapper.Map<UsageStatsDto>(dashboard.Usage),
          UpcomingPayments = _mapper.Map<List<UpcomingPaymentDto>>(dashboard.UpcomingPayments),
          RecommendedPlans = _mapper.Map<List<PlanDto>>(dashboard.RecommendedUpgrades)
      });
  }
  
  [HttpGet("plans")]
  public async Task<ActionResult<List<PublicPlanDto>>> GetAvailablePlans()
  {
      var userId = GetCurrentUserId();
      var plans = await _subscriptionService.GetAvailablePlansAsync(userId);
      
      return Ok(plans.Select(p => new PublicPlanDto
      {
          Id = p.Id,
          Name = p.Name,
          Description = p.Description,
          Price = p.GetPriceForUser(userId),
          Currency = p.Currency,
          BillingCycle = p.BillingCycle.ToString(),
          Features = p.Features.Select(f => f.Name).ToList(),
          IsCurrentPlan = p.Id == GetCurrentUserPlanId(),
          IsUpgrade = p.Price > GetCurrentPlanPrice(),
          DiscountPercentage = CalculateDiscount(p, userId)
      }));
  }
}

[HttpPost("preview")]
public async Task<ActionResult<SubscriptionPreviewDto>> PreviewSubscriptionChange([FromBody] ChangeSubscriptionRequest request)
{
  var userId = GetCurrentUserId();
  var preview = await _subscriptionService.PreviewChangeAsync(userId, request.NewPlanId, request.EffectiveDate);
  
  return Ok(new SubscriptionPreviewDto
  {
      CurrentPlan = preview.CurrentPlan.Name,
      NewPlan = preview.NewPlan.Name,
      ProratedAmount = preview.ProratedAmount,
      NextBillingDate = preview.NextBillingDate,
      ImmediateCharge = preview.ImmediateCharge,
      Savings = preview.EstimatedMonthlySavings,
      EffectiveDate = preview.EffectiveDate,
      CancellationPolicy = preview.CancellationTerms
  });
}

public interface IPaymentService
{
  Task<PaymentResult> ProcessPaymentAsync(PaymentRequest request);
  Task<PaymentResult> ProcessSubscriptionPaymentAsync(CreateSubscriptionPaymentRequest request);  
  Task<RefundResult> RefundPaymentAsync(string transactionId, decimal amount, string reason);
  Task<PaymentMethod> SavePaymentMethodAsync(int userId, string paymentToken);
  Task<bool> ValidateWebhookSignatureAsync(string payload, string signature);
  Task ProcessWebhookAsync(string eventType, string payload);
}
 
public class StripePaymentService : IPaymentService
{
  private readonly StripeClient _stripeClient;
  private readonly IPaymentRepository _paymentRepository;
  private readonly ISubscriptionRepository _subscriptionRepository;
  private readonly IConfiguration _configuration;
  private readonly ILogger<StripePaymentService> _logger;
 
  public async Task<PaymentResult> ProcessSubscriptionPaymentAsync(CreateSubscriptionPaymentRequest request)
  {
      try
      {
          // Создаем Payment Intent в Stripe
          var paymentIntentOptions = new PaymentIntentCreateOptions
          {
              Amount = (long)(request.Amount * 100), // Stripe работает в центах
              Currency = request.Currency.ToLower(),
              PaymentMethod = request.PaymentMethodId,
              CustomerId = request.StripeCustomerId,
              Confirm = true,
              Metadata = new Dictionary<string, string>
              {
                  ["user_id"] = request.UserId.ToString(),
                  ["subscription_id"] = request.SubscriptionId.ToString(),
                  ["plan_id"] = request.PlanId.ToString()
              },
              Description = $"Subscription to {request.PlanName}",
              ReceiptEmail = request.UserEmail
          };
 
          var service = new PaymentIntentService(_stripeClient);
          var paymentIntent = await service.CreateAsync(paymentIntentOptions);
 
          // Сохраняем платеж в нашей базе в статусе Processing
          var payment = new Payment
          {
              UserId = request.UserId,
              SubscriptionId = request.SubscriptionId,
              Amount = request.Amount,
              Currency = request.Currency,
              ExternalTransactionId = paymentIntent.Id,
              Status = PaymentStatus.Processing,
              PaymentMethodLast4 = GetLastFourDigits(request.PaymentMethodId),
              CreatedAt = DateTime.UtcNow,
              PaymentProvider = "Stripe"
          };
 
          await _paymentRepository.SaveAsync(payment);
 
          return paymentIntent.Status switch
          {
              "succeeded" => PaymentResult.Success(paymentIntent.Id, payment.Id),
              "requires_action" => PaymentResult.RequiresAction(paymentIntent.ClientSecret, payment.Id),
              "processing" => PaymentResult.Processing(paymentIntent.Id, payment.Id),
              _ => PaymentResult.Failed($"Unexpected status: {paymentIntent.Status}", payment.Id)
          };
      }
      catch (StripeException ex)
      {
          _logger.LogError(ex, "Stripe payment failed for user {UserId}, subscription {SubscriptionId}", 
              request.UserId, request.SubscriptionId);
              
          return PaymentResult.Failed($"Payment failed: {ex.StripeError?.Message ?? ex.Message}");
      }
  }
}

[HttpPost("webhooks/stripe")]
public async Task<IActionResult> StripeWebhook()
{
var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
var signature = Request.Headers["Stripe-Signature"];
 
try
{
    var stripeEvent = EventUtility.ConstructEvent(json, signature, _webhookSecret);
    
    // Проверяем, не обрабатывали ли мы уже это событие
    var existingWebhook = await _webhookRepository.GetByEventIdAsync(stripeEvent.Id);
    if (existingWebhook != null)
    {
        _logger.LogInformation("Webhook {EventId} already processed, skipping", stripeEvent.Id);
        return Ok();
    }
 
    // Сохраняем webhook для идемпотентности
    await _webhookRepository.SaveAsync(new WebhookEvent
    {
        EventId = stripeEvent.Id,
        EventType = stripeEvent.Type,
        ProcessedAt = DateTime.UtcNow,
        Payload = json
    });
 
    // Обрабатываем событие асинхронно
    await _backgroundTaskQueue.QueueBackgroundWorkItemAsync(async token =>
    {
        await ProcessStripeWebhookAsync(stripeEvent);
    });
 
    return Ok();
}
catch (StripeException ex)
{
    _logger.LogError(ex, "Invalid Stripe webhook signature");
    return BadRequest("Invalid signature");
}
}

[HttpPost("webhooks/payment")]
[AllowAnonymous]
public async Task<IActionResult> ProcessPaymentWebhook()
{
    var requestId = Guid.NewGuid().ToString();
    var body = await ReadRequestBodyAsync();
    var signature = Request.Headers["X-Payment-Signature"].FirstOrDefault();
    
    _logger.LogInformation("Received webhook {RequestId}, signature: {Signature}", requestId, signature);
    
    try
    {
        // Валидируем подпись
        if (!await _webhookValidator.ValidateSignatureAsync(body, signature))
        {
            _logger.LogWarning("Invalid webhook signature for request {RequestId}", requestId);
            return BadRequest("Invalid signature");
        }
        
        // Парсим payload
        var webhookEvent = JsonSerializer.Deserialize<WebhookPayload>(body);
        
        // Проверяем идемпотентность
        var existingEvent = await _webhookRepository.GetByEventIdAsync(webhookEvent.EventId);
        if (existingEvent != null)
        {
            _logger.LogInformation("Webhook {EventId} already processed, returning success", webhookEvent.EventId);
            return Ok();
        }
        
        // Сохраняем событие
        var webhookRecord = new WebhookRecord
        {
            EventId = webhookEvent.EventId,
            EventType = webhookEvent.Type,
            Payload = body,
            ReceivedAt = DateTime.UtcNow,
            ProcessingStatus = WebhookProcessingStatus.Pending,
            RequestId = requestId
        };
        
        await _webhookRepository.SaveAsync(webhookRecord);
        
        // Обрабатываем асинхронно
        await _backgroundProcessor.EnqueueAsync(new ProcessWebhookCommand
        {
            WebhookRecordId = webhookRecord.Id,
            EventType = webhookEvent.Type,
            Payload = body
        });
        
        return Ok();
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to process webhook {RequestId}", requestId);
        return StatusCode(500);
    }
}
 
public async Task ProcessWebhookInBackground(ProcessWebhookCommand command)
{
    var webhook = await _webhookRepository.GetByIdAsync(command.WebhookRecordId);
    
    try
    {
        webhook.ProcessingStatus = WebhookProcessingStatus.Processing;
        webhook.ProcessingStartedAt = DateTime.UtcNow;
        await _webhookRepository.UpdateAsync(webhook);
        
        var result = await ProcessWebhookByType(command.EventType, command.Payload);
        
        webhook.ProcessingStatus = result.IsSuccess 
            ? WebhookProcessingStatus.Completed 
            : WebhookProcessingStatus.Failed;
        webhook.ProcessingCompletedAt = DateTime.UtcNow;
        webhook.ErrorMessage = result.IsSuccess ? null : result.ErrorMessage;
        webhook.RetryCount = result.IsSuccess ? 0 : webhook.RetryCount + 1;
        
        await _webhookRepository.UpdateAsync(webhook);
    }
    catch (Exception ex)
    {
        webhook.ProcessingStatus = WebhookProcessingStatus.Failed;
        webhook.ErrorMessage = ex.Message;
        webhook.RetryCount++;
        await _webhookRepository.UpdateAsync(webhook);
        
        // Планируем повторную обработку если не превышен лимит
        if (webhook.RetryCount < 5)
        {
            var delay = TimeSpan.FromMinutes(Math.Pow(2, webhook.RetryCount));
            await _backgroundProcessor.EnqueueDelayedAsync(command, delay);
        }
    }
}

public class PaymentAuditLogger : IPaymentAuditLogger
{
  private readonly ILogger<PaymentAuditLogger> _logger;
  private readonly IAuditRepository _auditRepository;
  private readonly IUserContextProvider _userContext;
 
  public async Task LogPaymentAttempt(PaymentAttemptEvent paymentEvent)
  {
      var auditEntry = new PaymentAuditEntry
      {
          EventType = AuditEventType.PaymentAttempt,
          UserId = paymentEvent.UserId,
          SubscriptionId = paymentEvent.SubscriptionId,
          Amount = paymentEvent.Amount,
          Currency = paymentEvent.Currency,
          PaymentMethodFingerprint = HashPaymentMethod(paymentEvent.PaymentMethodId),
          IPAddress = _userContext.GetClientIP(),
          UserAgent = _userContext.GetUserAgent(),
          SessionId = _userContext.GetSessionId(),
          Timestamp = DateTime.UtcNow,
          CorrelationId = paymentEvent.CorrelationId,
          Metadata = new Dictionary<string, object>
          {
              ["payment_provider"] = paymentEvent.Provider,
              ["billing_country"] = paymentEvent.BillingCountry,
              ["plan_id"] = paymentEvent.PlanId,
              ["is_retry"] = paymentEvent.IsRetryAttempt,
              ["retry_count"] = paymentEvent.RetryCount
          }
      };
 
      await _auditRepository.SaveAuditEntryAsync(auditEntry);
      
      _logger.LogInformation(
          "Payment attempt logged: User {UserId}, Amount {Amount} {Currency}, Correlation {CorrelationId}",
          paymentEvent.UserId, 
          paymentEvent.Amount, 
          paymentEvent.Currency,
          paymentEvent.CorrelationId);
  }
 
  public async Task LogPaymentResult(PaymentResultEvent resultEvent)
  {
      var auditEntry = new PaymentAuditEntry
      {
          EventType = resultEvent.IsSuccess ? AuditEventType.PaymentSuccess : AuditEventType.PaymentFailure,
          UserId = resultEvent.UserId,
          SubscriptionId = resultEvent.SubscriptionId,
          ExternalTransactionId = resultEvent.ExternalTransactionId,
          Amount = resultEvent.Amount,
          Currency = resultEvent.Currency,
          ProcessingTimeMs = resultEvent.ProcessingTime.TotalMilliseconds,
          ErrorCode = resultEvent.ErrorCode,
          ErrorMessage = SanitizeErrorMessage(resultEvent.ErrorMessage),
          Timestamp = DateTime.UtcNow,
          CorrelationId = resultEvent.CorrelationId,
          Metadata = new Dictionary<string, object>
          {
              ["gateway_response_code"] = resultEvent.GatewayResponseCode,
              ["risk_score"] = resultEvent.RiskScore,
              ["processor_reference"] = resultEvent.ProcessorReference,
              ["decline_reason"] = resultEvent.DeclineReason
          }
      };
 
      await _auditRepository.SaveAuditEntryAsync(auditEntry);
  }
}

public class SubscriptionCorsConfiguration
{
  public void ConfigureCors(IServiceCollection services, IConfiguration configuration)
  {
      services.AddCors(options =>
      {
          options.AddPolicy("SubscriptionApiPolicy", builder =>
          {
              var allowedOrigins = configuration.GetSection("Cors:AllowedOrigins").Get<string[]>();
              var isProduction = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production";
              
              if (isProduction)
              {
                  // Продакшен: только явно разрешенные домены
                  builder
                      .WithOrigins(allowedOrigins)
                      .WithMethods("GET", "POST", "PUT", "DELETE", "PATCH")
                      .WithHeaders("Authorization", "Content-Type", "X-Requested-With", "X-Idempotency-Key")
                      .AllowCredentials()
                      .SetPreflightMaxAge(TimeSpan.FromMinutes(10));
              }
              else
              {
                  // Development: более гибкие правила но с ограничениями
                  builder
                      .SetIsOriginAllowed(origin =>
                      {
                          var uri = new Uri(origin);
                          return uri.Host == "localhost" || 
                                 uri.Host == "127.0.0.1" ||
                                 allowedOrigins.Contains(origin);
                      })
                      .AllowAnyMethod()
                      .AllowAnyHeader()
                      .AllowCredentials();
              }
          });
          
          // Отдельная политика для webhook endpoints
          options.AddPolicy("WebhookPolicy", builder =>
          {
              builder
                  .AllowAnyOrigin() // Webhook'и приходят от платежных систем
                  .WithMethods("POST")
                  .WithHeaders("Content-Type", "X-Stripe-Signature", "X-PayPal-Signature");
          });
      });
  }
}

[EnableRateLimiting("SubscriptionApiPolicy")]
[HttpPost("create")]
public async Task<ActionResult<SubscriptionDto>> CreateSubscription([FromBody] CreateSubscriptionRequest request)
{
  var clientIP = HttpContext.Connection.RemoteIpAddress?.ToString();
  var rateLimitKey = $"create_subscription:{clientIP}:{User.Identity.GetUserId()}";
  
  var isAllowed = await _rateLimiter.CheckLimitAsync(rateLimitKey, 3, TimeSpan.FromMinutes(5));
  if (!isAllowed)
  {
      _logger.LogWarning("Rate limit exceeded for subscription creation from IP {IP}", clientIP);
      return StatusCode(429, new { error = "Too many subscription attempts. Please try again later." });
  }
  
  var result = await _subscriptionService.CreateSubscriptionAsync(request);
  return result.IsSuccess ? Ok(result.Value) : BadRequest(result.ErrorMessage);
}

public class SubscriptionValidationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IServiceProvider _serviceProvider;
    private readonly IMemoryCache _cache;
    private readonly ILogger<SubscriptionValidationMiddleware> _logger;
    private readonly HashSet<string> _excludedPaths;
 
    public SubscriptionValidationMiddleware(
        RequestDelegate next,
        IServiceProvider serviceProvider,
        IMemoryCache cache,
        ILogger<SubscriptionValidationMiddleware> logger,
        IConfiguration configuration)
    {
        _next = next;
        _serviceProvider = serviceProvider;
        _cache = cache;
        _logger = logger;
        _excludedPaths = configuration.GetSection("SubscriptionMiddleware:ExcludedPaths")
            .Get<string[]>()?.ToHashSet() ?? new HashSet<string>();
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Пропускаем публичные endpoints
        if (ShouldSkipValidation(context))
        {
            await _next(context);
            return;
        }
 
        var userId = GetUserIdFromContext(context);
        if (userId == null)
        {
            await _next(context);
            return;
        }
 
        var subscriptionStatus = await GetUserSubscriptionStatusAsync(userId.Value);
        
        if (subscriptionStatus == SubscriptionValidationResult.Expired)
        {
            await HandleExpiredSubscription(context, userId.Value);
            return;
        }
        
        if (subscriptionStatus == SubscriptionValidationResult.Suspended)
        {
            await HandleSuspendedSubscription(context, userId.Value);
            return;
        }
 
        // Добавляем информацию о подписке в контекст для использования в контроллерах
        context.Items["UserSubscriptionStatus"] = subscriptionStatus;
        
        await _next(context);
    }
 
    private bool ShouldSkipValidation(HttpContext context)
    {
        var path = context.Request.Path.Value?.ToLowerInvariant();
        
        return path == null ||
               _excludedPaths.Any(excluded => path.StartsWith(excluded)) ||
               path.StartsWith("/api/auth/") ||
               path.StartsWith("/api/webhooks/") ||
               path.StartsWith("/health") ||
               context.Request.Method == "OPTIONS";
    }
}

private async Task<SubscriptionValidationResult> GetUserSubscriptionStatusAsync(int userId)
{
    var cacheKey = $"user_subscription_status_{userId}";
    
    if (_cache.TryGetValue(cacheKey, out SubscriptionValidationResult cachedResult))
    {
        return cachedResult;
    }
 
    using var scope = _serviceProvider.CreateScope();
    var subscriptionService = scope.ServiceProvider.GetRequiredService<ISubscriptionService>();
    
    var subscription = await subscriptionService.GetActiveSubscriptionAsync(userId);
    
    var result = subscription switch
    {
        null => SubscriptionValidationResult.NoSubscription,
        { Status: SubscriptionStatus.Active } when subscription.ExpiresAt > DateTime.UtcNow => 
            SubscriptionValidationResult.Active,
        { Status: SubscriptionStatus.Active } when subscription.ExpiresAt <= DateTime.UtcNow => 
            SubscriptionValidationResult.Expired,
        { Status: SubscriptionStatus.Suspended } => SubscriptionValidationResult.Suspended,
        _ => SubscriptionValidationResult.Invalid
    };
 
    // Кешируем результат с разным TTL в зависимости от статуса
    var cacheDuration = result switch
    {
        SubscriptionValidationResult.Active => TimeSpan.FromMinutes(5),
        SubscriptionValidationResult.Expired => TimeSpan.FromMinutes(1),
        SubscriptionValidationResult.Suspended => TimeSpan.FromMinutes(2),
        _ => TimeSpan.FromMinutes(10)
    };
 
    _cache.Set(cacheKey, result, cacheDuration);
    return result;
}
 
private async Task HandleExpiredSubscription(HttpContext context, int userId)
{
    _logger.LogInformation("Blocked access for user {UserId} with expired subscription", userId);
    
    if (context.Request.Path.StartsWithSegments("/api"))
    {
        // API запрос - возвращаем JSON с информацией об истечении
        context.Response.StatusCode = 402; // Payment Required
        context.Response.ContentType = "application/json";
        
        var response = new
        {
            error = "subscription_expired",
            message = "Your subscription has expired. Please renew to continue using this service.",
            renewal_url = "/billing/renew",
            grace_period_days = CalculateGracePeriodDays(userId)
        };
        
        await context.Response.WriteAsync(JsonSerializer.Serialize(response));
    }
    else
    {
        // Web запрос - редирект на страницу обновления подписки
        context.Response.Redirect("/subscription/expired");
    }
}

public interface ICrmIntegrationService
{
    Task SyncUserToCrmAsync(int userId, CrmSyncOptions options);
    Task SyncSubscriptionToCrmAsync(int subscriptionId);
    Task HandleSubscriptionStatusChangeAsync(int subscriptionId, SubscriptionStatus oldStatus, SubscriptionStatus newStatus);
    Task<CrmSyncResult> BulkSyncUsersAsync(IEnumerable<int> userIds);
    Task ProcessWebhookFromCrmAsync(string webhook, string payload);
}
 
public class SalesforceCrmService : ICrmIntegrationService
{
    private readonly ISalesforceClient _salesforceClient;
    private readonly IUserRepository _userRepository;
    private readonly ISubscriptionRepository _subscriptionRepository;
    private readonly ICrmMappingService _mappingService;
    private readonly ILogger<SalesforceCrmService> _logger;
 
    public async Task SyncSubscriptionToCrmAsync(int subscriptionId)
    {
        var subscription = await _subscriptionRepository.GetByIdWithDetailsAsync(subscriptionId);
        if (subscription == null) return;
 
        var crmContact = await FindOrCreateCrmContact(subscription.User);
        var crmOpportunity = await _mappingService.MapSubscriptionToOpportunity(subscription, crmContact);
 
        try
        {
            if (crmOpportunity.Id == null)
            {
                // Создаем новую возможность в CRM
                var createResult = await _salesforceClient.CreateOpportunityAsync(crmOpportunity);
                if (createResult.IsSuccess)
                {
                    await UpdateSubscriptionWithCrmId(subscriptionId, createResult.Id);
                    await CreateSubscriptionHistory(subscriptionId, "CRM_SYNC_CREATED", createResult.Id);
                }
            }
            else
            {
                // Обновляем существующую
                var updateResult = await _salesforceClient.UpdateOpportunityAsync(crmOpportunity);
                if (updateResult.IsSuccess)
                {
                    await CreateSubscriptionHistory(subscriptionId, "CRM_SYNC_UPDATED", crmOpportunity.Id);
                }
            }
        }
        catch (CrmApiException ex) when (ex.IsRateLimit)
        {
            // Откладываем синхронизацию при превышении лимитов
            await _backgroundQueue.EnqueueDelayedAsync(
                new SyncSubscriptionCommand(subscriptionId), 
                TimeSpan.FromMinutes(15));
        }
    }
 
    private async Task<CrmContact> FindOrCreateCrmContact(ApplicationUser user)
    {
        // Ищем существующий контакт по email
        var existingContact = await _salesforceClient.FindContactByEmailAsync(user.Email);
        if (existingContact != null)
        {
            return existingContact;
        }
 
        // Создаем новый контакт
        var newContact = new CrmContact
        {
            Email = user.Email,
            FirstName = user.FirstName,
            LastName = user.LastName,
            Company = user.CompanyName ?? "Individual",
            Source = "Subscription System",
            CreatedDate = user.CreatedAt,
            CustomFields = new Dictionary<string, object>
            {
                ["Subscription_User_Id__c"] = user.Id,
                ["First_Subscription_Date__c"] = user.FirstSubscriptionDate,
                ["Total_Lifetime_Value__c"] = await CalculateLifetimeValue(user.Id)
            }
        };
 
        var createResult = await _salesforceClient.CreateContactAsync(newContact);
        return createResult.IsSuccess ? createResult.Contact : null;
    }
}

public async Task<ConflictResolutionResult> ResolveDataConflict(DataConflict conflict)
{
    var strategy = _conflictStrategies[conflict.FieldName];
    
    return strategy switch
    {
        ConflictStrategy.CrmWins => await ApplyCrmData(conflict),
        ConflictStrategy.SubscriptionWins => await ApplySubscriptionData(conflict),
        ConflictStrategy.MostRecent => await ApplyMostRecentData(conflict),
        ConflictStrategy.ManualReview => await QueueForManualReview(conflict),
        _ => await ApplyDefaultStrategy(conflict)
    };
}
 
private async Task ProcessBidirectionalSync()
{
    // Синхронизируем изменения из CRM в subscription system
    var crmChanges = await _salesforceClient.GetChangedRecordsSince(_lastSyncTime);
    foreach (var change in crmChanges)
    {
        var subscriptionUserId = change.GetField("Subscription_User_Id__c");
        if (subscriptionUserId != null)
        {
            await ProcessCrmChangeInSubscriptionSystem(change, subscriptionUserId);
        }
    }
 
    // Синхронизируем изменения из subscription system в CRM  
    var subscriptionChanges = await _subscriptionRepository.GetChangedSubscriptionsSince(_lastSyncTime);
    foreach (var subscription in subscriptionChanges)
    {
        await SyncSubscriptionToCrmAsync(subscription.Id);
    }
}

// ОПАСНО - уязвимо для SQL-инъекций
public async Task<List<Subscription>> SearchSubscriptions(string userEmail, string planName)
{
    var sql = $"SELECT * FROM Subscriptions s INNER JOIN Users u ON s.UserId = u.Id WHERE u.Email LIKE '%{userEmail}%' AND s.PlanName LIKE '%{planName}%'";
    return await _context.Subscriptions.FromSqlRaw(sql).ToListAsync();
}
 
// БЕЗОПАСНО - использует параметризованные запросы
public async Task<List<Subscription>> SearchSubscriptionsSafe(string userEmail, string planName)
{
    return await _context.Subscriptions
        .Where(s => s.User.Email.Contains(userEmail) && s.Plan.Name.Contains(planName))
        .ToListAsync();
}
 
// Если raw SQL неизбежен - используем параметры
public async Task<List<Subscription>> GetSubscriptionsByCustomQuery(string status, decimal minAmount)
{
    var sql = "SELECT * FROM Subscriptions WHERE Status = {0} AND Amount >= {1}";
    return await _context.Subscriptions
        .FromSqlRaw(sql, status, minAmount)
        .ToListAsync();
}

// Модель с автоматическим HTML-кодированием
public class SubscriptionCancellationRequest
{
    [Required]
    [MaxLength(500)]
    [RegularExpression(@"^[a-zA-Z0-9\s.,!?-]+$", ErrorMessage = "Invalid characters in reason")]
    public string CancellationReason { get; set; }
    
    [HtmlSanitize] // Custom attribute для санитизации
    public string AdditionalComments { get; set; }
}
 
// Custom validation attribute для санитизации HTML
public class HtmlSanitizeAttribute : ValidationAttribute
{
    public override bool IsValid(object value)
    {
        if (value is string stringValue)
        {
            var sanitized = HtmlSanitizer.Sanitize(stringValue);
            return sanitized == stringValue;
        }
        return true;
    }
}
 
// В контроллере - дополнительная валидация
[HttpPost]
public async Task<ActionResult> CancelSubscription([FromBody] SubscriptionCancellationRequest request)
{
    // Санитизация входных данных
    request.CancellationReason = HtmlEncoder.Default.Encode(request.CancellationReason ?? string.Empty);
    request.AdditionalComments = SanitizeUserInput(request.AdditionalComments);
    
    var result = await _subscriptionService.CancelSubscriptionAsync(request);
    return result.IsSuccess ? Ok() : BadRequest(result.ErrorMessage);
}
 
private string SanitizeUserInput(string input)
{
    if (string.IsNullOrEmpty(input)) return string.Empty;
    
    // Удаляем потенциально опасные теги и атрибуты
    var sanitizer = new HtmlSanitizer();
    sanitizer.AllowedTags.Clear();
    sanitizer.AllowedAttributes.Clear();
    
    return sanitizer.Sanitize(input);
}

public class SubscriptionCacheService : ISubscriptionCacheService
{
  private readonly IMemoryCache _memoryCache;
  private readonly IDistributedCache _distributedCache;
  private readonly ISubscriptionRepository _repository;
  private readonly ILogger<SubscriptionCacheService> _logger;
  private readonly CacheInvalidationService _invalidationService;
 
  public async Task<Subscription> GetActiveSubscriptionAsync(int userId)
  {
      // L1 Cache - Memory Cache (самый быстрый)
      var memoryCacheKey = $"subscription:active:{userId}";
      if (_memoryCache.TryGetValue(memoryCacheKey, out Subscription memoryResult))
      {
          return memoryResult;
      }
 
      // L2 Cache - Distributed Cache (Redis)
      var distributedCacheKey = $"sub:active:{userId}";
      var cachedData = await _distributedCache.GetStringAsync(distributedCacheKey);
      
      if (!string.IsNullOrEmpty(cachedData))
      {
          var subscription = JsonSerializer.Deserialize<Subscription>(cachedData);
          
          // Обновляем L1 cache
          _memoryCache.Set(memoryCacheKey, subscription, TimeSpan.FromMinutes(2));
          return subscription;
      }
 
      // Cache miss - идем в базу данных
      var dbSubscription = await _repository.GetActiveSubscriptionAsync(userId);
      
      if (dbSubscription != null)
      {
          // Кешируем в оба уровня
          var serialized = JsonSerializer.Serialize(dbSubscription);
          await _distributedCache.SetStringAsync(distributedCacheKey, serialized, new DistributedCacheEntryOptions
          {
              AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
          });
          
          _memoryCache.Set(memoryCacheKey, dbSubscription, TimeSpan.FromMinutes(2));
      }
 
      return dbSubscription;
  }
 
  public async Task InvalidateUserSubscriptionAsync(int userId)
  {
      var tasks = new List<Task>
      {
          _distributedCache.RemoveAsync($"sub:active:{userId}"),
          _distributedCache.RemoveAsync($"sub:all:{userId}"),
          _distributedCache.RemoveAsync($"sub:history:{userId}")
      };
 
      // Инвалидируем локальный кеш
      _memoryCache.Remove($"subscription:active:{userId}");
      _memoryCache.Remove($"subscriptions:all:{userId}");
 
      await Task.WhenAll(tasks);
      
      // Уведомляем другие instances о необходимости инвалидации
      await _invalidationService.BroadcastInvalidationAsync(userId);
  }
}