/// <summary>
/// Відповідальність: Робота з базою даних користувачів
/// </summary>
public class UserRepository
{
    private readonly string _connectionString;

    public UserRepository(string connectionString)
    {
        _connectionString = connectionString;
    }

    public void Save(User user)
    {
        using var connection = new SqlConnection(_connectionString);
        connection.Open();

        using var command = new SqlCommand(
            "INSERT INTO Users (Id, Email, Name) VALUES (@Id, @Email, @Name)",
            connection
        );

        command.Parameters.AddWithValue("@Id", user.Id);
        command.Parameters.AddWithValue("@Email", user.Email);
        command.Parameters.AddWithValue("@Name", user.Name);

        command.ExecuteNonQuery();
    }

    public User? GetById(Guid id)
    {
        // Логіка отримання користувача
        return null; // Для прикладу
    }
}

/// <summary>
/// Відповідальність: Валідація даних користувача
/// </summary>
public class UserValidator
{
    public ValidationResult Validate(User user)
    {
        var errors = new List<string>();

        if (string.IsNullOrWhiteSpace(user.Email))
            errors.Add("Email не може бути порожнім");

        if (!user.Email.Contains("@"))
            errors.Add("Email повинен містити символ '@'");

        if (string.IsNullOrWhiteSpace(user.Name))
            errors.Add("Ім'я не може бути порожнім");

        return new ValidationResult
        {
            IsValid = errors.Count == 0,
            Errors = errors
        };
    }
}

public record ValidationResult
{
    public bool IsValid { get; init; }
    public IReadOnlyList<string> Errors { get; init; } = Array.Empty<string>();
}

/// <summary>
/// Відповідальність: Відправка email повідомлень
/// </summary>
public class EmailService
{
    private readonly SmtpClient _smtpClient;

    public EmailService(string smtpServer)
    {
        _smtpClient = new SmtpClient(smtpServer);
    }

    public void SendWelcomeEmail(User user)
    {
        var message = new MailMessage
        {
            To = { user.Email },
            Subject = "Ласкаво просимо!",
            Body = $"Привіт, {user.Name}! Дякуємо за реєстрацію."
        };

        _smtpClient.Send(message);
    }
}

/// <summary>
/// Відповідальність: Логування подій системи
/// </summary>
public class Logger
{
    private readonly string _logFilePath;

    public Logger(string logFilePath)
    {
        _logFilePath = logFilePath;
    }

    public void Log(string message)
    {
        var logEntry = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] {message}";
        File.AppendAllText(_logFilePath, logEntry + Environment.NewLine);
    }

    public void LogInfo(string message) => Log($"INFO: {message}");
    public void LogWarning(string message) => Log($"WARNING: {message}");
    public void LogError(string message) => Log($"ERROR: {message}");
}

/// <summary>
/// Відповідальність: Оркестрація бізнес-логіки користувача
/// Координує роботу інших сервісів
/// </summary>
public class UserService
{
    private readonly UserRepository _repository;
    private readonly UserValidator _validator;
    private readonly EmailService _emailService;
    private readonly Logger _logger;

    public UserService(
        UserRepository repository,
        UserValidator validator,
        EmailService emailService,
        Logger logger)
    {
        _repository = repository;
        _validator = validator;
        _emailService = emailService;
        _logger = logger;
    }

    public Result RegisterUser(User user)
    {
        // 1. Валідація
        var validationResult = _validator.Validate(user);
        if (!validationResult.IsValid)
        {
            _logger.LogWarning($"Помилка валідації користувача: {user.Email}");
            return Result.Failure(validationResult.Errors);
        }

        // 2. Збереження
        try
        {
            _repository.Save(user);
            _logger.LogInfo($"Користувач збережений: {user.Email}");
        }
        catch (Exception ex)
        {
            _logger.LogError($"Помилка збереження: {ex.Message}");
            return Result.Failure("Не вдалося зберегти користувача");
        }

        // 3. Відправка email
        try
        {
            _emailService.SendWelcomeEmail(user);
            _logger.LogInfo($"Вітальний email відправлений: {user.Email}");
        }
        catch (Exception ex)
        {
            _logger.LogWarning($"Не вдалося відправити email: {ex.Message}");
            // Не фейлимо всю операцію через проблеми з email
        }

        return Result.Success();
    }
}

public record Result
{
    public bool IsSuccess { get; init; }
    public IReadOnlyList<string> Errors { get; init; } = Array.Empty<string>();

    public static Result Success() => new() { IsSuccess = true };
    public static Result Failure(params string[] errors) =>
        new() { IsSuccess = false, Errors = errors };
    public static Result Failure(IEnumerable<string> errors) =>
        new() { IsSuccess = false, Errors = errors.ToList() };
}

/// <summary>
/// Абстракція для методів оплати
/// </summary>
public interface IPaymentMethod
{
    string Name { get; }
    void ProcessPayment(Order order);
    bool ValidatePayment(Order order);
}

/// <summary>
/// Конкретна реалізація: оплата кредитною карткою
/// </summary>
public class CreditCardPayment : IPaymentMethod
{
    public string Name => "Кредитна картка";

    public void ProcessPayment(Order order)
    {
        Console.WriteLine($"Обробка платежу на суму {order.TotalAmount:C} кредитною карткою");

        // Специфічна логіка для кредитних карток
        ConnectToPaymentGateway();
        AuthorizeCard(order.Amount);
        CapturePayment(order.Amount);
    }

    public bool ValidatePayment(Order order)
    {
        // Валідація номера картки, CVV, тощо
        return true; // Спрощено для прикладу
    }

    private void ConnectToPaymentGateway() { /* ... */ }
    private void AuthorizeCard(decimal amount) { /* ... */ }
    private void CapturePayment(decimal amount) { /* ... */ }
}

/// <summary>
/// Конкретна реалізація: оплата через PayPal
/// </summary>
public class PayPalPayment : IPaymentMethod
{
    public string Name => "PayPal";

    public void ProcessPayment(Order order)
    {
        Console.WriteLine($"Обробка платежу на суму {order.TotalAmount:C} через PayPal");

        // Специфічна логіка для PayPal
        RedirectToPayPal(order);
        HandlePayPalCallback();
    }

    public bool ValidatePayment(Order order)
    {
        // Валідація PayPal аккаунта
        return true; // Спрощено для прикладу
    }

    private void RedirectToPayPal(Order order) { /* ... */ }
    private void HandlePayPalCallback() { /* ... */ }
}

/// <summary>
/// Конкретна реалізація: оплата Bitcoin
/// </summary>
public class BitcoinPayment : IPaymentMethod
{
    public string Name => "Bitcoin";

    public void ProcessPayment(Order order)
    {
        Console.WriteLine($"Обробка платежу на суму {order.TotalAmount:C} через Bitcoin");

        // Специфічна логіка для Bitcoin
        GenerateWalletAddress();
        WaitForConfirmations();
    }

    public bool ValidatePayment(Order order)
    {
        // Валідація Bitcoin транзакції
        return true; // Спрощено для прикладу
    }

    private void GenerateWalletAddress() { /* ... */ }
    private void WaitForConfirmations() { /* ... */ }
}

/// <summary>
/// Процесор платежів, закритий для модифікації
/// Нові методи додаються через створення нових класів
/// </summary>
public class PaymentProcessor
{
    private readonly IPaymentMethod _paymentMethod;

    public PaymentProcessor(IPaymentMethod paymentMethod)
    {
        _paymentMethod = paymentMethod;
    }

    public void ProcessOrder(Order order)
    {
        if (!_paymentMethod.ValidatePayment(order))
        {
            throw new InvalidOperationException(
                $"Платіж через {_paymentMethod.Name} не пройшов валідацію"
            );
        }

        _paymentMethod.ProcessPayment(order);
        Console.WriteLine($"Замовлення #{order.Id} успішно оброблено через {_paymentMethod.Name}");
    }
}

// Використання
var order = new Order
{
    Id = Guid.NewGuid(),
    TotalAmount = 100.50m
};

// Оплата кредитною карткою
var creditCardProcessor = new PaymentProcessor(new CreditCardPayment());
creditCardProcessor.ProcessOrder(order);

// Оплата через PayPal
var paypalProcessor = new PaymentProcessor(new PayPalPayment());
paypalProcessor.ProcessOrder(order);

// Додаємо Apple Pay БЕЗ зміни PaymentProcessor!
var applePayProcessor = new PaymentProcessor(new ApplePayPayment());
applePayProcessor.ProcessOrder(order);

/// <summary>
/// Базовий клас: прямокутник
/// Інваріант: Width та Height можуть бути незалежними
/// </summary>
public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }

    public int CalculateArea()
    {
        return Width * Height;
    }
}

/// <summary>
/// Квадрат — це прямокутник, де Width == Height. Звучить логічно, чи не так?
/// Але це ПОРУШУЄ LSP!
/// </summary>
public class Square : Rectangle
{
    // Порушення: змінюємо інваріант базового класу
    // У базовому класі Width і Height незалежні, тут — ні
    public override int Width
    {
        get => base.Width;
        set
        {
            base.Width = value;
            base.Height = value; // Побічний ефект!
        }
    }

    public override int Height
    {
        get => base.Height;
        set
        {
            base.Width = value;  // Побічний ефект!
            base.Height = value;
        }
    }
}

/// <summary>
/// Клієнтський код, який працює з Rectangle
/// </summary>
public class GeometryService
{
    public void TestRectangle(Rectangle rect)
    {
        rect.Width = 5;
        rect.Height = 10;

        // Очікуємо: 5 * 10 = 50
        Console.WriteLine($"Площа: {rect.CalculateArea()}");
    }
}

// Використання
var geometry = new GeometryService();

var rectangle = new Rectangle();
geometry.TestRectangle(rectangle); // Виведе: Площа: 50 ✓

var square = new Square();
geometry.TestRectangle(square);    // Виведе: Площа: 100 ✗
// Замість очікуваних 50, отримуємо 100!
// LSP ПОРУШЕНО: Square не може замінити Rectangle

/// <summary>
/// Абстракція для геометричних фігур
/// </summary>
public interface IShape
{
    int CalculateArea();
    string GetDescription();
}

/// <summary>
/// Прямокутник із незалежними сторонами
/// </summary>
public class Rectangle : IShape
{
    public int Width { get; set; }
    public int Height { get; set; }

    public int CalculateArea() => Width * Height;

    public string GetDescription() => $"Прямокутник {Width}x{Height}";
}

/// <summary>
/// Квадрат із однією стороною
/// НЕ успадковується від Rectangle!
/// </summary>
public class Square : IShape
{
    public int Side { get; set; }

    public int CalculateArea() => Side * Side;

    public string GetDescription() => $"Квадрат {Side}x{Side}";
}

/// <summary>
/// Клієнтський код тепер працює через абстракцію
/// </summary>
public class GeometryService
{
    public void ProcessShape(IShape shape)
    {
        Console.WriteLine(shape.GetDescription());
        Console.WriteLine($"Площа: {shape.CalculateArea()}");
    }
}

// Використання
var geometry = new GeometryService();

var rect = new Rectangle { Width = 5, Height = 10 };
geometry.ProcessShape(rect); // Прямокутник 5x10, Площа: 50

var square = new Square { Side = 10 };
geometry.ProcessShape(square); // Квадрат 10x10, Площа: 100

// LSP ДОТРИМАНО: обидва типи коректно реалізують IShape

/// <summary>
/// Role Interface: здатність працювати
/// </summary>
public interface IWorkable
{
    void Work();
}

/// <summary>
/// Role Interface: потреба в їжі
/// </summary>
public interface IFeedable
{
    void Eat();
}

/// <summary>
/// Role Interface: потреба в сні
/// </summary>
public interface ISleepable
{
    void Sleep();
}

/// <summary>
/// Role Interface: отримання оплати
/// </summary>
public interface IPayable
{
    void TakeSalary();
}

/// <summary>
/// Role Interface: облік робочого часу
/// </summary>
public interface ITimeTrackable
{
    void FileTimeSheet();
}

/// <summary>
/// Робот імплементує лише те, що йому потрібно
/// </summary>
public class Robot : IWorkable, ITimeTrackable
{
    public void Work()
    {
        Console.WriteLine("Робот працює 24/7");
    }

    public void FileTimeSheet()
    {
        Console.WriteLine("Робот реєструє робочий час");
    }
}

/// <summary>
/// Людина імплементує всі потрібні інтерфейси
/// </summary>
public class Human : IWorkable, IFeedable, ISleepable, IPayable, ITimeTrackable
{
    public void Work()
    {
        Console.WriteLine("Людина працює");
    }

    public void Eat()
    {
        Console.WriteLine("Людина обідає");
    }

    public void Sleep()
    {
        Console.WriteLine("Людина спить");
    }

    public void TakeSalary()
    {
        Console.WriteLine("Людина отримує зарплату");
    }

    public void FileTimeSheet()
    {
        Console.WriteLine("Людина заповнює timesheet");
    }
}

/// <summary>
/// Менеджер працює з різними аспектами через окремі інтерфейси
/// </summary>
public class WorkManager
{
    public void ManageWork(IWorkable worker)
    {
        worker.Work();
    }

    public void ProvideLunch(IFeedable worker)
    {
        worker.Eat();
    }

    public void ProcessPayroll(IPayable employee)
    {
        employee.TakeSalary();
    }

    public void CollectTimesheets(ITimeTrackable worker)
    {
        worker.FileTimeSheet();
    }
}

/// <summary>
/// Абстракція, визначена HIGH-LEVEL модулем
/// </summary>
public interface IOrderRepository
{
    void Save(Order order);
    Order? GetById(Guid id);
    IEnumerable<Order> GetAll();
}

/// <summary>
/// High-level модуль залежить від абстракції
/// </summary>
public class OrderService
{
    private readonly IOrderRepository _repository;

    // Залежність ін'єктується ззовні (Dependency Injection)
    public OrderService(IOrderRepository repository)
    {
        _repository = repository;
    }

    public void ProcessOrder(Order order)
    {
        // Бізнес-логіка
        order.Status = OrderStatus.Confirmed;

        // Збереження через абстракцію
        _repository.Save(order);
    }
}

/// <summary>
/// Low-level модуль реалізує абстракцію
/// </summary>
public class SqlOrderRepository : IOrderRepository
{
    private readonly string _connectionString;

    public SqlOrderRepository(string connectionString)
    {
        _connectionString = connectionString;
    }

    public void Save(Order order)
    {
        using var connection = new SqlConnection(_connectionString);
        connection.Open();

        var command = new SqlCommand(
            "INSERT INTO Orders (Id, Status, Amount) VALUES (@Id, @Status, @Amount)",
            connection
        );

        command.Parameters.AddWithValue("@Id", order.Id);
        command.Parameters.AddWithValue("@Status", order.Status);
        command.Parameters.AddWithValue("@Amount", order.Amount);

        command.ExecuteNonQuery();
    }

    public Order? GetById(Guid id)
    {
        // Реалізація SQL запиту
        return null; // Спрощено
    }

    public IEnumerable<Order> GetAll()
    {
        // Реалізація SQL запиту
        return new List<Order>(); // Спрощено
    }
}

/// <summary>
/// Альтернативна реалізація — легко додати!
/// OrderService НЕ потребує змін
/// </summary>
public class MongoOrderRepository : IOrderRepository
{
    private readonly IMongoCollection<Order> _collection;

    public MongoOrderRepository(IMongoDatabase database)
    {
        _collection = database.GetCollection<Order>("orders");
    }

    public void Save(Order order)
    {
        _collection.InsertOne(order);
    }

    public Order? GetById(Guid id)
    {
        return _collection.Find(o => o.Id == id).FirstOrDefault();
    }

    public IEnumerable<Order> GetAll()
    {
        return _collection.Find(_ => true).ToList();
    }
}

/// <summary>
/// Реалізація для тестування
/// </summary>
public class InMemoryOrderRepository : IOrderRepository
{
    private readonly List<Order> _orders = new();

    public void Save(Order order)
    {
        _orders.Add(order);
    }

    public Order? GetById(Guid id)
    {
        return _orders.FirstOrDefault(o => o.Id == id);
    }

    public IEnumerable<Order> GetAll()
    {
        return _orders;
    }
}

// Production: SQL
var sqlRepository = new SqlOrderRepository("connection_string");
var orderService = new OrderService(sqlRepository);
orderService.ProcessOrder(new Order { /* ... */ });

// Production: MongoDB
var mongoRepository = new MongoOrderRepository(mongoDatabase);
var orderService2 = new OrderService(mongoRepository);
orderService2.ProcessOrder(new Order { /* ... */ });

// Testing
var testRepository = new InMemoryOrderRepository();
var orderService3 = new OrderService(testRepository);
// Легко тестувати без реальної БД!

/// <summary>
/// Єдине джерело знань про валідацію email
/// </summary>
public static class EmailValidator
{
    public static void Validate(string email)
    {
        if (string.IsNullOrEmpty(email))
            throw new ArgumentException("Email не може бути порожнім", nameof(email));

        if (!email.Contains("@"))
            throw new ArgumentException("Email має містити @", nameof(email));

        // Додаткова валідація через regex
        var emailRegex = new Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$");
        if (!emailRegex.IsMatch(email))
            throw new ArgumentException("Некоректний формат email", nameof(email));
    }

    public static bool IsValid(string email)
    {
        try
        {
            Validate(email);
            return true;
        }
        catch
        {
            return false;
        }
    }
}

/// <summary>
/// Використання єдиного джерела валідації
/// </summary>
public class UserService
{
    public void CreateUser(string email, string password)
    {
        EmailValidator.Validate(email); // Використовуємо загальний метод
        // Створення користувача
    }

    public void UpdateUserEmail(Guid userId, string newEmail)
    {
        EmailValidator.Validate(newEmail); // Використовуємо загальний метод
        // Оновлення email
    }

    public void SendInvitation(string email)
    {
        EmailValidator.Validate(email); // Використовуємо загальний метод
        // Відправка запрошення
    }
}

{
    "EmailSettings": {
        "SmtpServer": "smtp.gmail.com",
        "SmtpPort": 587,
        "EnableSsl": true
    },
    "NotificationSettings": {
        "SmtpServer": "smtp.gmail.com",
        "SmtpPort": 587,
        "EnableSsl": true
    },
    "ReportSettings": {
        "SmtpServer": "smtp.gmail.com",
        "SmtpPort": 587,
        "EnableSsl": true
    }
}

{
    "SmtpSettings": {
        "Server": "smtp.gmail.com",
        "Port": 587,
        "EnableSsl": true
    },
    "EmailSettings": {
        "SmtpSettingsReference": "SmtpSettings"
    },
    "NotificationSettings": {
        "SmtpSettingsReference": "SmtpSettings"
    },
    "ReportSettings": {
        "SmtpSettingsReference": "SmtpSettings"
    }
}