// Цей клас — як та "електрик з генератором"
public class OrderService
{
    private readonly EmailService _emailService;

    public OrderService()
    {
        // Клас сам "приносить свій генератор" — створює залежність
        _emailService = new EmailService("smtp.gmail.com", 587);
    }

    public void PlaceOrder(Order order)
    {
        // Обробка замовлення...
        _emailService.Send(order.CustomerEmail, "Ваше замовлення прийнято!");
    }
}

public class ReportGenerator  // Клас A
{
    private readonly DatabaseConnection _db;   // Залежність 1
    private readonly PdfRenderer _pdf;         // Залежність 2
    private readonly EmailSender _email;       // Залежність 3

    public ReportGenerator()
    {
        _db    = new DatabaseConnection("Server=...");  // Створює залежність 1
        _pdf   = new PdfRenderer();                     // Створює залежність 2
        _email = new EmailSender("smtp.company.com");   // Створює залежність 3
    }
}

// ❌ Low Cohesion - клас робить все підряд
public class UserManager
{
    public void CreateUser(string name) { /* ... */ }
    public void SendWelcomeEmail(string email) { /* ... */ }   // ← Чому email тут?
    public void GenerateReport() { /* ... */ }                 // ← Чому звіт тут?
    public void BackupDatabase() { /* ... */ }                 // ← Чому бекап тут?
    public void OptimizeImages() { /* ... */ }                 // ← Повний безлад!
}

// ✅ High Cohesion - кожен клас має свою відповідальність
public class UserService          { public void CreateUser(string name) { /* ... */ } }
public class EmailService         { public void SendWelcomeEmail(string email) { /* ... */ } }
public class ReportService        { public void GenerateReport() { /* ... */ } }
public class DatabaseBackupService { public void BackupDatabase() { /* ... */ } }

// Уявіть, що це реальний код в продакшені...

public class UserService
{
    private readonly SqlUserRepository _userRepo;
    private readonly SmtpEmailService _emailService;

    public UserService()
    {
        // Hard-coded рядок підключення — де конфіг?
        _userRepo = new SqlUserRepository("Server=192.168.1.100;Database=UsersDB;User=sa;Password=1234;");
        // Hard-coded SMTP — що коли зміниться поштовий провайдер?
        _emailService = new SmtpEmailService("mail.company.com", 25, false);
    }
}

public class OrderService
{
    private readonly SqlOrderRepository _orderRepo;
    private readonly SmtpEmailService _emailService;  // ← Ще один екземпляр!

    public OrderService()
    {
        // Той самий рядок підключення — дублювання!
        _orderRepo = new SqlOrderRepository("Server=192.168.1.100;Database=OrdersDB;User=sa;Password=1234;");
        _emailService = new SmtpEmailService("mail.company.com", 25, false); // ← Ще один!
    }
}

public class NotificationService
{
    private readonly SmtpEmailService _emailService; // ← І ще один!

    public NotificationService()
    {
        _emailService = new SmtpEmailService("mail.company.com", 25, false); // ← Скільки можна?
    }
}

// Як написати Unit тест для OrderService?
[Test]
public void PlaceOrder_ShouldSendEmail_WhenOrderIsPlaced()
{
    var service = new OrderService();
    // ПРОБЛЕМА: OrderService у конструкторі РЕАЛЬНО підключиться до БД
    // і РЕАЛЬНО спробує надіслати email через SMTP!
    // Тест буде залежати від зовнішніх систем і буде нестабільним.

    service.PlaceOrder(new Order { Email = "test@example.com" });

    // Як перевірити, що email БУЛО надіслано? Ніяк, не перехопити!
}

// Кращe, але все ще tight coupling
public class OrderService
{
    private readonly SqlOrderRepository _orderRepo;
    private readonly SmtpEmailService _emailService;

    public OrderService()
    {
        // Тепер читаємо з конфіга — хоч якийсь прогрес
        var connStr = ConfigurationManager.ConnectionStrings["OrdersDB"].ConnectionString;
        var smtpHost = ConfigurationManager.AppSettings["SmtpHost"];

        _orderRepo = new SqlOrderRepository(connStr);
        _emailService = new SmtpEmailService(smtpHost, 587);
    }
}

// Статична фабрика для створення сервісів
public static class ServiceFactory
{
    public static IEmailService CreateEmailService()
    {
        if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Testing")
            return new FakeEmailService(); // Для тестів
        else
            return new SmtpEmailService("mail.company.com", 587);
    }

    public static IOrderRepository CreateOrderRepository()
    {
        if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Testing")
            return new InMemoryOrderRepository(); // Для тестів
        else
            return new SqlOrderRepository(GetConnectionString());
    }
}

// Тепер OrderService використовує фабрику
public class OrderService
{
    private readonly IEmailService _emailService;
    private readonly IOrderRepository _orderRepo;

    public OrderService()
    {
        _emailService = ServiceFactory.CreateEmailService(); // Все ще залежить від фабрики!
        _orderRepo = ServiceFactory.CreateOrderRepository();
    }
}

// 🎉 Dependency Injection у чистому вигляді
public class OrderService
{
    private readonly IEmailService _emailService;
    private readonly IOrderRepository _orderRepo;

    // Конструктор "оголошує контракт": надайте мені ці два об'єкти,
    // і я зможу виконувати свою роботу
    public OrderService(IEmailService emailService, IOrderRepository orderRepo)
    {
        _emailService = emailService;
        _orderRepo = orderRepo;
    }

    public void PlaceOrder(Order order)
    {
        _orderRepo.Save(order);
        _emailService.Send(order.Email, "Замовлення прийнято!");
    }
}

// Хтось ззовні має зібрати граф залежностей вручну
var orderRepo = new SqlOrderRepository(connectionString);
var emailService = new SmtpEmailService("mail.company.com", 587);
var orderService = new OrderService(emailService, orderRepo); // Передаємо залежності!

// Реальний приклад складного графу залежностей
var logger = new Logger(logConfig);
var dbConnection = new SqlConnection(connStr);
var unitOfWork = new UnitOfWork(dbConnection, logger);
var userRepo = new SqlUserRepository(unitOfWork, logger);
var orderRepo = new SqlOrderRepository(unitOfWork, logger);
var inventoryService = new InventoryService(orderRepo, logger);
var paymentGateway = new StripePaymentGateway(stripeApiKey, logger);
var emailService = new SmtpEmailService(smtpConfig, logger);
var notificationService = new NotificationService(emailService, userRepo, logger);
var orderService = new OrderService(orderRepo, inventoryService, paymentGateway, notificationService, logger);
// ... і ще 50 таких рядків

// ❌ ПОРУШЕННЯ DIP
// OrderService (висший рівень) залежить від SmtpEmailService (нижчий рівень — деталь)
public class OrderService
{
    private SmtpEmailService _email; // ← Залежність від конкретики!

    public OrderService()
    {
        _email = new SmtpEmailService(); // ← OrderService знає як створити email сервіс
    }
}

// ✅ ДОТРИМАННЯ DIP
// Обидва модулі залежать від абстракції IEmailService
public interface IEmailService          // ← Абстракція
{
    void Send(string to, string body);
}

public class SmtpEmailService : IEmailService  // Деталь залежить від абстракції
{
    public void Send(string to, string body) { /* SMTP логіка */ }
}

public class OrderService                      // Висший рівень залежить від абстракції
{
    private readonly IEmailService _email;     // ← Залежність від абстракції!

    public OrderService(IEmailService email)   // ← Деталь передається ззовні
    {
        _email = email;
    }
}

// Конструктор без параметрів — "закритий ящик"
// Споживач класу не знає, які ресурси він використовує
public class OrderService()
{
    // Магія всередині... клас сам знаходить те, що йому потрібно
}

// Конструктор з параметрами — "відкритий контракт"
// Споживач чітко бачить: "цьому класу потрібен репозиторій і email сервіс"
public class OrderService(IOrderRepository repository, IEmailService emailService)
{
    // Нічого зайвого
}

// Program.cs — "Composition Root" (місце, де всe збирається)
// Тут ми вручну будуємо граф залежностей

static void Main(string[] args)
{
    // Ручна побудова графу залежностей (Pure DI)
    var logger = new ConsoleLogger(LogLevel.Information);
    var connStr = "Server=localhost;Database=ShopDB;";
    var dbContext = new AppDbContext(connStr);

    var userRepository = new SqlUserRepository(dbContext, logger);
    var orderRepository = new SqlOrderRepository(dbContext, logger);

    var emailConfig = new EmailConfig { Host = "smtp.company.com", Port = 587 };
    var emailService = new SmtpEmailService(emailConfig, logger);

    var paymentGateway = new StripePaymentGateway("sk_live_...", logger);
    var inventoryService = new InventoryService(orderRepository, logger);

    var notificationService = new NotificationService(emailService, userRepository, logger);

    var orderService = new OrderService(
        orderRepository,
        inventoryService,
        paymentGateway,
        notificationService,
        logger
    );

    var app = new Application(orderService, userRepository, logger);
    app.Run();
}

// З мікроскопічним власним контейнером (ми побудуємо такий у наступній статті!)
var container = new SimpleContainer();

// Реєстрація (один раз на старті)
container.Register<ILogger, ConsoleLogger>();
container.Register<IOrderRepository, SqlOrderRepository>();
container.Register<IEmailService, SmtpEmailService>();
container.Register<IPaymentGateway, StripePaymentGateway>();
container.Register<OrderService, OrderService>();

// Resolve (контейнер будує весь граф автоматично)
var orderService = container.Resolve<OrderService>();
// За лаштунками: контейнер сам знайшов всі залежності OrderService,
// залежності залежностей, і зібрав весь граф!

orderService.PlaceOrder(new Order { /* ... */ });

// Program.cs — ЄДИНЕ місце, де будується граф залежностей
var builder = WebApplication.CreateBuilder(args);

// Composition Root: реєструємо всі залежності
builder.Services.AddSingleton<ILogger, ConsoleLogger>();
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddScoped<IEmailService, SmtpEmailService>();
builder.Services.AddScoped<IPaymentGateway, StripePaymentGateway>();
builder.Services.AddScoped<OrderService>();

var app = builder.Build();
app.Run();

// Все інше — БІЗНЕС ЛОГІКА, яка НІЧОГО не знає про контейнер!

public class PaymentController
{
    public IActionResult ProcessPayment(decimal amount)
    {
        var db = new NpgsqlConnection("Host=db.internal;Database=payments;Username=admin;Password=secret");
        db.Open();
        var cmd = new NpgsqlCommand($"INSERT INTO payments VALUES ({amount})", db);
        cmd.ExecuteNonQuery();

        var client = new HttpClient();
        var response = client.PostAsync("https://stripe.com/api/charge",
            new StringContent($"amount={amount}&currency=usd")).Result;

        var smtp = new SmtpClient("smtp.gmail.com");
        smtp.Send("noreply@company.com", "customer@example.com",
            "Payment received", $"Amount: {amount}");

        return Ok("Payment processed");
    }
}