// Інтерфейси — "контракти" між класами
public interface ILogger { void Log(string message); }
public interface IOrderRepository { void Save(Order order); }
public interface IEmailService { void Send(string to, string body); }

// OrderService з Constructor Injection
public class OrderService
{
    // Приватні поля, що зберігають залежності.
    // Readonly — гарантує, що після конструктора їх не можна замінити.
    private readonly IOrderRepository _repository;
    private readonly IEmailService _emailService;
    private readonly ILogger _logger;

    // Конструктор є "публічним контрактом": оголошує чого потребує клас.
    // Це єдине місце, де залежності "вводяться" (inject) у клас.
    public OrderService(
        IOrderRepository repository,
        IEmailService emailService,
        ILogger logger)
    {
        // Guard clauses — захист від null
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _emailService = emailService ?? throw new ArgumentNullException(nameof(emailService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    // Методи використовують залежності але не знають про їх конкретний тип
    public void PlaceOrder(Order order)
    {
        _logger.Log($"Placing order {order.Id}...");
        _repository.Save(order);
        _emailService.Send(order.CustomerEmail, $"Замовлення #{order.Id} прийнято!");
        _logger.Log($"Order {order.Id} placed successfully.");
    }
}

[TestMethod]
public void PlaceOrder_ShouldSaveAndSendEmail()
{
    // Arrange: явно і зрозуміло
    var mockRepo = new Mock<IOrderRepository>();
    var mockEmail = new Mock<IEmailService>();
    var mockLogger = new Mock<ILogger>();

    // Передаємо моки — клас їх не "помітить"!
    var service = new OrderService(
        mockRepo.Object,
        mockEmail.Object,
        mockLogger.Object);

    var order = new Order { Id = 1, CustomerEmail = "test@test.com" };

    // Act
    service.PlaceOrder(order);

    // Assert
    mockRepo.Verify(r => r.Save(order), Times.Once);
    mockEmail.Verify(e => e.Send("test@test.com", It.IsAny<string>()), Times.Once);
}

// ❌ Конструктор з 8+ параметрами — сигнал про проблему!
public class ComplexOrderService
{
    public ComplexOrderService(
        IOrderRepository repository,
        IEmailService emailService,
        ILogger logger,
        IInventoryService inventory,
        IPaymentGateway payment,
        INotificationService notifications,
        IShippingService shipping,
        IAuditService audit)   // 8 параметрів!
    { /* ... */ }
}

// ✅ Краще: згрупуємо пов'язані залежності
public record OrderProcessingContext(
    IInventoryService Inventory,
    IPaymentGateway Payment,
    IShippingService Shipping);

public class OrderService
{
    public OrderService(
        IOrderRepository repository,
        IEmailService emailService,
        ILogger logger,
        OrderProcessingContext processingCtx)  // Тепер 4 параметри
    { /* ... */ }
}

// Property Injection — для необов'язкових залежностей
public class OrderProcessor
{
    // ОБОВ'ЯЗКОВІ залежності — через конструктор
    private readonly IOrderRepository _repository;
    private readonly IPaymentGateway _payment;

    public OrderProcessor(IOrderRepository repository, IPaymentGateway payment)
    {
        _repository = repository;
        _payment = payment;
    }

    // НЕОБОВ'ЯЗКОВА залежність — через властивість.
    // Клас може існувати і без логера (буде просто без логування).
    // Null Object Pattern: NullLogger нічого не робить, але не кидає null exception.
    public ILogger Logger { get; set; } = NullLogger.Instance;

    public void ProcessOrder(Order order)
    {
        Logger.Log($"Processing order {order.Id}");  // Безпечно навіть без реального логера
        _payment.Charge(order.Total);
        _repository.Save(order);
        Logger.Log($"Order {order.Id} processed");
    }
}

// Null Object Pattern для Logger
public class NullLogger : ILogger
{
    public static readonly NullLogger Instance = new();
    public void Log(string message) { }  // Нічого не робить
}

// Використання без логера
var processor = new OrderProcessor(repository, payment);
// Logger = NullLogger автоматично — не кидає exception!

// Додаємо логер за потреби
processor.Logger = new ConsoleLogger();

// У тесті: встановлюємо мок після створення
var processor = new OrderProcessor(mockRepo, mockPayment);
processor.Logger = mockLogger; // Необов'язково для роботи!

// У DI контейнері Microsoft DI не підтримує Property Injection нативно.
// Але можна через factory:
services.AddScoped<OrderProcessor>(sp =>
{
    var processor = new OrderProcessor(
        sp.GetRequiredService<IOrderRepository>(),
        sp.GetRequiredService<IPaymentGateway>());
    processor.Logger = sp.GetService<ILogger>() ?? NullLogger.Instance; // Property injection!
    return processor;
});

// ❌ Проблема 1: Неповний стан об'єкта
var processor = new OrderProcessor(repository, payment);
// processor.Logger не встановлено — але об'єкт "живе" без проблем

// ❌ Проблема 2: Залежності можуть бути змінені після створення
processor.Logger = new ConsoleLogger();
// ... якийсь код ...
processor.Logger = null; // ← Хтось обнулив! NullReferenceException!

// ❌ Проблема 3: Незрозуміло, яке мінімальне вимога до класу
// (що обов'язкове, що необов'язкове — доводиться читати всю документацію)

public class DataProcessor
{
    // Немає залежності від ILogger у полях класу!
    // Основна логіка не потребує логування.

    public void ProcessData(DataSet data)
    {
        // Бізнес логіка без логування
        foreach (var row in data.Rows)
            TransformRow(row);
    }

    // !!! Method Injection — логер передається тільки сюди
    // Цей метод потребує налагодження в конкретних сценаріях
    public void ProcessDataWithLogging(DataSet data, ILogger logger)
    {
        logger.Log("Processing started");

        foreach (var row in data.Rows)
        {
            logger.Log($"Processing row {row.Id}");
            TransformRow(row);
        }

        logger.Log("Processing complete");
    }

    private void TransformRow(DataRow row) { /* ... */ }
}

[ApiController]
[Route("api/[controller]")]
public class ReportController : ControllerBase
{
    // Загальні залежності — через конструктор (завжди потрібні)
    private readonly ILogger<ReportController> _logger;

    public ReportController(ILogger<ReportController> logger)
    {
        _logger = logger;
    }

    // [FromServices] injection — залежність тільки для цього ендпоінту
    // Не потрібно "тягнути" IReportGenerator у конструктор якщо він рідко використовується!
    [HttpGet("monthly")]
    public async Task<IActionResult> GetMonthlyReport(
        [FromServices] IReportGenerator reportGenerator,  // Method Injection!
        [FromQuery] int month,
        [FromQuery] int year)
    {
        _logger.LogInformation("Generating {Month}/{Year} report", month, year);
        var report = await reportGenerator.GenerateMonthlyAsync(month, year);
        return Ok(report);
    }

    [HttpGet("annual")]
    public async Task<IActionResult> GetAnnualReport(
        [FromServices] IAnnualReportGenerator annualGenerator,  // Інша залежність!
        [FromQuery] int year)
    {
        var report = await annualGenerator.GenerateAsync(year);
        return Ok(report);
    }
}

// ❌ Проблема: не можна передати параметри при Resolve через DI
services.AddScoped<IEmailService, SmtpEmailService>();
// SmtpEmailService потребує конкретний email одержувача — але звідки його взяти?

var emailService = provider.GetRequiredService<IEmailService>();
// До кого надсилати? Контейнер не знає контекст виконання!

// Варіант 1: Factory інтерфейс
public interface IEmailServiceFactory
{
    IEmailService CreateForRecipient(string recipientEmail);
}

public class EmailServiceFactory : IEmailServiceFactory
{
    private readonly ILogger _logger;
    private readonly SmtpConfig _config;

    // Factory сама отримує залежності через DI!
    public EmailServiceFactory(ILogger logger, SmtpConfig config)
    {
        _logger = logger;
        _config = config;
    }

    public IEmailService CreateForRecipient(string recipientEmail)
    {
        _logger.Log($"Creating email service for {recipientEmail}");
        return new SmtpEmailService(_config, recipientEmail);
    }
}

// Реєстрація
services.AddSingleton<IEmailServiceFactory, EmailServiceFactory>();

// Використання
public class OrderService
{
    private readonly IEmailServiceFactory _emailFactory;

    public OrderService(IEmailServiceFactory emailFactory)
    {
        _emailFactory = emailFactory;
    }

    public void PlaceOrder(Order order)
    {
        // Динамічно створюємо сервіс з потрібним одержувачем
        var emailService = _emailFactory.CreateForRecipient(order.CustomerEmail);
        emailService.Send("Ваше замовлення прийнято!");
    }
}

// Реєстрація: Func як factory
services.AddTransient<IEmailService, SmtpEmailService>();
services.AddSingleton<Func<IEmailService>>(sp =>
    () => sp.GetRequiredService<IEmailService>());

// Використання — Func<T> inject як залежність!
public class NotificationService
{
    private readonly Func<IEmailService> _emailFactory;

    public NotificationService(Func<IEmailService> emailFactory)
    {
        _emailFactory = emailFactory;
    }

    public void Notify(string to, string message)
    {
        // Кожного разу отримуємо новий Transient email сервіс
        var email = _emailFactory();
        email.Send(to, message);
    }
}

// Базовий сервіс
public class SqlOrderRepository : IOrderRepository
{
    public void Save(Order order) { /* SQL INSERT */ }
    public Order Get(int id) { /* SQL SELECT */ return null!; }
}

// Decorator: додає логування без зміни SqlOrderRepository!
public class LoggingOrderRepository : IOrderRepository
{
    private readonly IOrderRepository _inner;  // Реальний репозиторій
    private readonly ILogger _logger;

    // Приймає "внутрішній" сервіс через конструктор — це теж DI!
    public LoggingOrderRepository(IOrderRepository inner, ILogger logger)
    {
        _inner = inner;
        _logger = logger;
    }

    public void Save(Order order)
    {
        _logger.Log($"[BEFORE] Saving order {order.Id}");
        _inner.Save(order);  // Делегуємо реальній реалізації
        _logger.Log($"[AFTER] Order {order.Id} saved");
    }

    public Order Get(int id)
    {
        _logger.Log($"[BEFORE] Getting order {id}");
        var result = _inner.Get(id);
        _logger.Log($"[AFTER] Got order {id}: {result?.Status}");
        return result;
    }
}

// Реєстрація з Decorator через Scrutor (бібліотека розширення для Microsoft DI)
// PM> Install-Package Scrutor
services.AddScoped<IOrderRepository, SqlOrderRepository>();
services.Decorate<IOrderRepository, LoggingOrderRepository>();  // Огортаємо!

// Або вручну через factory
services.AddScoped<SqlOrderRepository>();
services.AddScoped<IOrderRepository>(sp =>
{
    var inner = sp.GetRequiredService<SqlOrderRepository>();
    var logger = sp.GetRequiredService<ILogger>();
    return new LoggingOrderRepository(inner, logger);  // Decorator вручну
});

OrderService → LoggingOrderRepository → CachingOrderRepository → SqlOrderRepository
                  (decorator)              (decorator)              (реальна БД)