// Структурний підхід - важко підтримувати
string car1Brand = "Toyota";
int car1Year = 2020;
decimal car1Price = 25000;

string car2Brand = "Honda";
int car2Year = 2021;
decimal car2Price = 28000;

void PrintCarInfo(string brand, int year, decimal price)
{
    Console.WriteLine($"{brand} ({year}): ${price}");
}

// Цей простий клас...
public class Wizard { }

// ...насправді виглядає так для компілятора:
public class Wizard : System.Object { }

var gandalf1 = new Wizard { Name = "Гендальф", Mana = 100 };
var gandalf2 = new Wizard { Name = "Гендальф", Mana = 100 };

Console.WriteLine(gandalf1.Equals(gandalf2)); // Вивід: false
// Це два різні об'єкти в пам'яті, хоча їх дані ідентичні.

object wizard = new Wizard { Name = "Радагаст", Mana = 70 };

// Ми не знаємо конкретний тип, лише те, що це object
Type objectType = wizard.GetType();

Console.WriteLine($"Ім'я типу: {objectType.Name}"); // Wizard
Console.WriteLine($"Повний шлях: {objectType.FullName}"); // YourApp.Wizard
Console.WriteLine($"Збірка: {objectType.Assembly.GetName().Name}");

// Можна навіть перевірити його публічні властивості
Console.WriteLine("\nВластивості:");
foreach (var prop in objectType.GetProperties())
{
    Console.WriteLine($"- {prop.Name} (тип: {prop.PropertyType.Name})");
}

// Вивід:
// Властивості:
// - Name (тип: String)
// - Mana (тип: Int32)

// Базовий клас (Base class, Parent class, Superclass)
public class Animal
{
    public string Name { get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name} їсть");
    }
}

// Похідний клас (Derived class, Child class, Subclass)
public class Dog : Animal  // Наслідує Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} гавкає: Гав-гав!");
    }
}

// Використання
var dog = new Dog { Name = "Рекс" };
dog.Eat();  // Успадкований метод
dog.Bark(); // Власний метод

public class Animal
{
    public string Name { get; }
    public int Age { get; }

    public Animal(string name, int age)
    {
        Name = name;
        Age = age;
        Console.WriteLine($"Animal конструктор: {name}");
    }
}

public class Dog : Animal
{
    public string Breed { get; }

    // Конструктор похідного класу викликає базовий через :base()
    public Dog(string name, int age, string breed) : base(name, age)
    {
        Breed = breed;
        Console.WriteLine($"Dog конструктор: {breed}");
    }
}

// Порядок виклику:
var dog = new Dog("Рекс", 3, "Німецька вівчарка");
// Вивід:
// Animal конструктор: Рекс
// Dog конструктор: Німецька вівчарка

public class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Тварина видає звук");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        base.MakeSound(); // Виклик методу базового класу
        Console.WriteLine("Гав-гав!");
    }
}

var dog = new Dog();
dog.MakeSound();
// Вивід:
// Тварина видає звук
// Гав-гав!

// ❌ Це НЕ працює - множинне успадкування класів заборонено
public class FlyingFish : Fish, Bird  // ПОМИЛКА КОМПІЛЯЦІЇ
{
}

// ✅ Це працює - один базовий клас + множинні інтерфейси
public class FlyingFish : Fish, IFlyable, ISwimmable
{
}

// Якщо Square успадковує Rectangle
public class Rectangle { public virtual int Width { get; set; } public virtual int Height { get; set; } }
public class Square : Rectangle
{
    public override int Width { set { base.Width = value; base.Height = value; } }
    public override int Height { set { base.Width = value; base.Height = value; } }
}

// Це ламає логіку для коду, який очікує Rectangle:
Rectangle r = new Square();
r.Width = 5;
r.Height = 10;
// Для прямокутника площа має бути 50, але для квадрата вона стане 100 (бо Height=10 встановить і Width=10).

public class Animal
{
    // Virtual метод - може бути перевизначений
    public virtual void MakeSound()
    {
        Console.WriteLine("Тварина видає звук");
    }
}

public class Dog : Animal
{
    // Override - перевизначення віртуального методу
    public override void MakeSound()
    {
        Console.WriteLine("Гав-гав!");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Мяу!");
    }
}

// Поліморфна поведінка
Animal animal1 = new Dog();
Animal animal2 = new Cat();

animal1.MakeSound(); // Гав-гав! (викликається Dog.MakeSound)
animal2.MakeSound(); // Мяу! (викликається Cat.MakeSound)

public sealed class FinalClass
{
    public void DoSomething() { }
}

// ❌ ПОМИЛКА КОМПІЛЯЦІЇ
public class Derived : FinalClass  // CS0509: cannot derive from sealed type
{
}

public class A
{
    public virtual void DoWork()
    {
        Console.WriteLine("A.DoWork");
    }
}

public class B : A
{
    public override void DoWork()
    {
        Console.WriteLine("B.DoWork");
    }
}

public class C : B
{
    // Sealed override - зупиняє ланцюжок перевизначення
    public sealed override void DoWork()
    {
        Console.WriteLine("C.DoWork");
    }
}

public class D : C
{
    // ❌ ПОМИЛКА - не можна override sealed метод
    // public override void DoWork() { }
}

public abstract class Shape
{
    // Звичайна властивість
    public string Color { get; set; }

    // Abstract метод - БЕЗ реалізації
    public abstract double CalculateArea();

    // Abstract властивість
    public abstract double Perimeter { get; }

    // Звичайний метод з реалізацією
    public void Display()
    {
        Console.WriteLine($"Фігура кольору {Color} з площею {CalculateArea()}");
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }

    // ОБОВ'ЯЗКОВО override abstract методу
    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }

    public override double Perimeter => 2 * Math.PI * Radius;
}

// Використання
Shape shape = new Circle { Color = "Червоний", Radius = 5 };
shape.Display(); // Викликається конкретна реалізація CalculateArea()

// Інтерфейс - тільки оголошення
public interface IDrawable
{
    void Draw();
    void Resize(double scale);
}

public interface IColorable
{
    string Color { get; set; }
}

// Клас може реалізовувати МНОЖИННІ інтерфейси
public class Circle : IDrawable, IColorable
{
    public string Color { get; set; }

    // Реалізація IDrawable
    public void Draw()
    {
        Console.WriteLine($"Малюю коло кольору {Color}");
    }

    public void Resize(double scale)
    {
        Console.WriteLine($"Змінюю розмір на {scale}");
    }
}

public interface ILogger
{
    void Log(string message);

    // Default реалізація в інтерфейсі
    void LogError(string error)
    {
        Log($"ERROR: {error}");
    }
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    // LogError вже є - не обов'язково override
}

// ENCAPSULATION: Приховування деталей
public abstract class BankAccount  // ABSTRACTION: Абстрактний контракт
{
    private decimal _balance;  // ENCAPSULATION: Приватне поле

    public string AccountNumber { get; }

    protected BankAccount(string accountNumber, decimal initialBalance)
    {
        AccountNumber = accountNumber;
        _balance = initialBalance;
    }

    public decimal Balance => _balance;

    // ABSTRACTION: Abstract метод для різних типів рахунків
    public abstract decimal CalculateInterest();

    // POLYMORPHISM: Virtual метод
    public virtual void Deposit(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Сума має бути додатною");
        _balance += amount;
    }
}

// INHERITANCE: Успадкування від BankAccount
public class SavingsAccount : BankAccount
{
    private decimal _interestRate;

    public SavingsAccount(string accountNumber, decimal initialBalance, decimal interestRate)
        : base(accountNumber, initialBalance)
    {
        _interestRate = interestRate;
    }

    // ABSTRACTION: Реалізація абстрактного методу
    public override decimal CalculateInterest()
    {
        return Balance * _interestRate / 100;
    }

    // POLYMORPHISM: Override методу
    public override void Deposit(decimal amount)
    {
        base.Deposit(amount);  // INHERITANCE: Виклик базового методу
        Console.WriteLine($"Нарахований бонус: {amount * 0.01m:C}");
    }
}

public class CheckingAccount : BankAccount
{
    public CheckingAccount(string accountNumber, decimal initialBalance)
        : base(accountNumber, initialBalance) { }

    public override decimal CalculateInterest() => 0; // Немає відсотків
}

public class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Звук");
    }
}

public class Dog : Animal
{
    // ❌ УВАГА: Компілятор видасть попередження CS0114
    public void MakeSound()  // Забули override!
    {
        Console.WriteLine("Гав");
    }
}

Animal animal = new Dog();
animal.MakeSound(); // "Звук" - викликається Animal, а не Dog!

public sealed class FinalClass
{
    public void DoWork() { }
}

// ❌ ПОМИЛКА CS0509: cannot derive from sealed type 'FinalClass'
public class DerivedClass : FinalClass
{
}

// ❌ Неправильно - інтерфейс для IS-A відношення
public interface IVehicle  // Краще abstract class
{
    string Brand { get; }
    void Start();
}

// ✅ Правильно
public abstract class Vehicle  // IS-A: Car IS-A Vehicle
{
    public string Brand { get; protected set; }
    public abstract void Start();
}

public interface IDriveable  // CAN-DO: Car CAN-DO Drive
{
    void Drive();
}

public abstract class Shape
{
    public abstract double Area { get; }
}

// ❌ ПОМИЛКА CS0534: 'Circle' does not implement inherited abstract member
public class Circle : Shape
{
    public double Radius { get; set; }
    // Забули override Area!
}

// ✅ Правильно
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area => Math.PI * Radius * Radius;
}