public abstract class Employee
{
    private string _name;
    private decimal _salary;

    protected Employee(string name, decimal salary)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("Ім'я не може бути порожнім");
        if (salary <= 0)
            throw new ArgumentException("Зарплата має бути додатною");

        _name = name;
        _salary = salary;
    }

    public string Name => _name;
    public decimal Salary => _salary;

    public abstract decimal CalculateBonus();

    public void DisplayInfo()
    {
        Console.WriteLine($"Працівник: {Name}");
        Console.WriteLine($"Зарплата: {Salary:C}");
        Console.WriteLine($"Бонус: {CalculateBonus():C}");
        Console.WriteLine($"Загалом: {Salary + CalculateBonus():C}");
    }
}

public class Manager : Employee
{
    public Manager(string name, decimal salary) : base(name, salary) { }

    public override decimal CalculateBonus()
    {
        return Salary * 0.20m;
    }
}

public class Developer : Employee
{
    public Developer(string name, decimal salary) : base(name, salary) { }

    public override decimal CalculateBonus()
    {
        return Salary * 0.15m;
    }
}

public class Intern : Employee
{
    public Intern(string name, decimal salary) : base(name, salary) { }

    public override decimal CalculateBonus()
    {
        return Salary * 0.05m;
    }
}

// Використання - демонстрація поліморфізму
List<Employee> employees = new()
{
    new Manager("Іван Петренко", 50000),
    new Developer("Марія Коваль", 40000),
    new Intern("Олег Сидоренко", 15000)
};

foreach (var employee in employees)
{
    employee.DisplayInfo();
    Console.WriteLine();
}

public abstract class Vehicle
{
    public string Brand { get; set; }

    public virtual void Start()
    {
        Console.WriteLine($"{Brand}: Двигун запущено");
    }

    public virtual void Stop()
    {
        Console.WriteLine($"{Brand}: Двигун зупинено");
    }

    public abstract int GetMaxSpeed();
}

public class Car : Vehicle
{
    public override void Start()
    {
        Console.WriteLine($"{Brand}: Провертаю ключ, двигун заводиться");
        base.Start();
    }

    // Sealed override - далі не можна override
    public sealed override void Stop()
    {
        Console.WriteLine($"{Brand}: Натискаю кнопку Stop/Start");
        base.Stop();
    }

    public override int GetMaxSpeed() => 200;
}

public class Motorcycle : Vehicle
{
    public override void Start()
    {
        Console.WriteLine($"{Brand}: Кікстартер! Врум-врум!");
    }

    public override void Stop()
    {
        Console.WriteLine($"{Brand}: Вимикаю на ходу (небезпечно!)");
    }

    public override int GetMaxSpeed() => 180;
}

public class ElectricCar : Car
{
    // ❌ Не можна override sealed метод
    // public override void Stop() { }  // ПОМИЛКА CS0239

    // ✅ Але можна приховати через new (не рекомендується)
    public new void Stop()
    {
        Console.WriteLine($"{Brand}: Електричний Silent Stop");
    }

    public override int GetMaxSpeed() => 250;
}

// Демонстрація поліморфізму
List<Vehicle> vehicles = new()
{
    new Car { Brand = "Toyota" },
    new Motorcycle { Brand = "Harley-Davidson" },
    new ElectricCar { Brand = "Tesla" }
};

foreach (var vehicle in vehicles)
{
    vehicle.Start();
    Console.WriteLine($"Макс. швид швидкість: {vehicle.GetMaxSpeed()} км/год");
    vehicle.Stop();
    Console.WriteLine();
}

// Демонстрація різниці між override і new
Vehicle electricAsVehicle = new ElectricCar { Brand = "Tesla" };
electricAsVehicle.Stop(); // Викличе Car.Stop (sealed override)

ElectricCar electricAsConcrete = (ElectricCar)electricAsVehicle;
electricAsConcrete.Stop(); // Викличе ElectricCar.Stop (new)

// Інтерфейси
public interface IPaymentMethod
{
    bool ProcessPayment(decimal amount);
    string GetPaymentDetails();
}

public interface IRefundable
{
    bool Refund(decimal amount);
}

// Abstract базовий клас
public abstract class PaymentMethod
{
    private List<(DateTime Date, decimal Amount, bool Success)> _transactionHistory = new();

    protected abstract bool ValidatePayment(decimal amount);

    protected void LogTransaction(decimal amount, bool success)
    {
        _transactionHistory.Add((DateTime.Now, amount, success));
        Console.WriteLine($"[LOG] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - " +
            $"{amount:C} - {(success ? "SUCCESS" : "FAILED")}");
    }

    public void PrintHistory()
    {
        Console.WriteLine("Історія транзакцій:");
        foreach (var (date, amount, success) in _transactionHistory)
        {
            Console.WriteLine($"  {date:yyyy-MM-dd HH:mm:ss}: {amount:C} - " +
                $"{(success ? "✓" : "✗")}");
        }
    }
}

// Конкретні реалізації
public class CreditCardPayment : PaymentMethod, IPaymentMethod, IRefundable
{
    public string CardNumber { get; set; }
    public string CardHolder { get; set; }
    private decimal _availableCredit = 10000;

    public bool ProcessPayment(decimal amount)
    {
        if (!ValidatePayment(amount))
        {
            LogTransaction(amount, false);
            return false;
        }

        _availableCredit -= amount;
        LogTransaction(amount, true);
        Console.WriteLine($"Оплата {amount:C} карткою успішна. " +
            $"Залишок кредиту: {_availableCredit:C}");
        return true;
    }

    protected override bool ValidatePayment(decimal amount)
    {
        if (amount <= 0)
        {
            Console.WriteLine("Сума має бути додатною");
            return false;
        }

        if (amount > _availableCredit)
        {
            Console.WriteLine($"Недостатньо кредиту. Доступно: {_availableCredit:C}");
            return false;
        }

        return true;
    }

    public bool Refund(decimal amount)
    {
        if (amount <= 0) return false;

        _availableCredit += amount;
        Console.WriteLine($"Повернення {amount:C} на картку. " +
            $"Кредит: {_availableCredit:C}");
        return true;
    }

    public string GetPaymentDetails()
    {
        return $"Credit Card: **** **** **** {CardNumber?[^4..]}, " +
            $"Власник: {CardHolder}";
    }
}

public class CashPayment : PaymentMethod, IPaymentMethod
{
    private decimal _cashInHand;

    public CashPayment(decimal initialCash)
    {
        _cashInHand = initialCash;
    }

    public bool ProcessPayment(decimal amount)
    {
        if (!ValidatePayment(amount))
        {
            LogTransaction(amount, false);
            return false;
        }

        _cashInHand -= amount;
        LogTransaction(amount, true);
        Console.WriteLine($"Оплата готівкою {amount:C} успішна. " +
            $"Решта: {_cashInHand:C}");
        return true;
    }

    protected override bool ValidatePayment(decimal amount)
    {
        if (amount <= 0)
        {
            Console.WriteLine("Сума має бути додатною");
            return false;
        }

        if (amount > _cashInHand)
        {
            Console.WriteLine($"Недостатньо готівки. Є: {_cashInHand:C}");
            return false;
        }

        return true;
    }

    public string GetPaymentDetails()
    {
        return $"Cash Payment, Available: {_cashInHand:C}";
    }
}

public class CryptoPayment : PaymentMethod, IPaymentMethod
{
    public string WalletAddress { get; set; }
    private decimal _balance = 5;

    public bool ProcessPayment(decimal amount)
    {
        if (!ValidatePayment(amount))
        {
            LogTransaction(amount, false);
            return false;
        }

        _balance -= amount * 0.01m; // Конвертація USD -> BTC (умовно)
        LogTransaction(amount, true);
        Console.WriteLine($"Криптоплатіж {amount:C} успішний. " +
            $"Баланс гаманця: {_balance:F8} BTC");
        return true;
    }

    protected override bool ValidatePayment(decimal amount)
    {
        decimal btcAmount = amount * 0.01m;

        if (amount <= 0)
        {
            Console.WriteLine("Сума має бути додатною");
            return false;
        }

        if (btcAmount > _balance)
        {
            Console.WriteLine($"Недостатньо BTC. Баланс: {_balance:F8} BTC");
            return false;
        }

        return true;
    }

    public string GetPaymentDetails()
    {
        return $"Crypto Wallet: {WalletAddress}, Balance: {_balance:F8} BTC";
    }
}

// Демонстрація використання
class PaymentProcessor
{
    public static void ProcessOrder(List<IPaymentMethod> payments, decimal totalAmount)
    {
        Console.WriteLine($"Обробка замовлення на суму: {totalAmount:C}\n");

        foreach (var payment in payments)
        {
            Console.WriteLine($"Спосіб оплати: {payment.GetPaymentDetails()}");

            bool success = payment.ProcessPayment(totalAmount);

            if (success && payment is IRefundable refundable)
            {
                Console.WriteLine("Цей метод підтримує повернення коштів");
                // Тестове повернення
                refundable.Refund(totalAmount * 0.1m);
            }

            if (payment is PaymentMethod pm)
            {
                pm.PrintHistory();
            }

            Console.WriteLine(new string('-', 60));
        }
    }
}

// Використання
var payments = new List<IPaymentMethod>
{
    new CreditCardPayment
    {
        CardNumber = "1234567890123456",
        CardHolder = "Іван Петренко"
    },
    new CashPayment(500),
    new CryptoPayment
    {
        WalletAddress = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    }
};

PaymentProcessor.ProcessOrder(payments, 250);