# Простейший пример наследования

class Animal:  # Родительский класс (Базовый)
    def __init__(self, name):
        self.name = name

    def breathe(self):
        print(f"{self.name} дышит воздухом.")

class Dog(Animal):  # Дочерний класс (Подкласс)
    def bark(self):
        print(f"{self.name} говорит: Гав-гав!")

# Создаем экземпляр дочернего класса
my_dog = Dog("Рекс")
my_dog.breathe()  # Унаследованный метод
my_dog.bark()     # Собственный метод

class Employee:
    def __init__(self, name, base_salary):
        self.name = name
        self.base_salary = base_salary

    def calculate_bonus(self):
        return self.base_salary * 0.10  # Базовый бонус 10%

    def get_info(self):
        return f"Сотрудник {self.name}, ЗП: {self.base_salary}"

class Manager(Employee):
    # ПЕРЕОПРЕДЕЛЕНИЕ __init__, чтобы добавить новый атрибут department
    def __init__(self, name, base_salary, department):
        # ОШИБКА ДЖУНИОРА:
        # self.name = name
        # self.base_salary = base_salary
        # Это дублирование кода и нарушение DRY!

        # ПРАВИЛЬНЫЙ ПОДХОД:
        super().__init__(name, base_salary)  # Вызов __init__ родителя
        self.department = department         # Инициализация собственного атрибута

    # ПЕРЕОПРЕДЕЛЕНИЕ метода calculate_bonus
    def calculate_bonus(self):
        # Менеджер получает 20% вместо 10%
        return self.base_salary * 0.20

# Тестирование
emp = Employee("Иван", 50000)
man = Manager("Анна", 80000, "IT-отдел")

print(f"{emp.name} бонус: {emp.calculate_bonus()}") # Выведет 5000.0
print(f"{man.name} бонус: {man.calculate_bonus()}") # Выведет 16000.0

# Пример расширения метода (не только __init__)

class DataProcessor:
    def process(self, data):
        print(f"Базовая обработка данных: {data}")
        return data.lower()

class LoggingDataProcessor(DataProcessor):
    def process(self, data):
        # 1. Добавляем собственную логику ДО родительской
        print(f"[LOG] Начало обработки данных в {__import__('datetime').datetime.now()}")
        
        # 2. Делегируем основную работу родителю с помощью super()
        result = super().process(data)
        
        # 3. Добавляем собственную логику ПОСЛЕ родительской
        print("[LOG] Обработка успешно завершена.")
        return result

# Использование
processor = LoggingDataProcessor()
cleaned = processor.process("СЕКРЕТНЫЕ ДАННЫЕ")
# Вывод:
# [LOG] Начало обработки данных в ...
# Базовая обработка данных: СЕКРЕТНЫЕ ДАННЫЕ
# [LOG] Обработка успешно завершена.

# Демонстрация проблемы ромба и MRO

class A:
    def say_hello(self):
        print("Привет от A")

class B(A):
    def say_hello(self):
        print("Привет от B")
        super().say_hello()

class C(A):
    def say_hello(self):
        print("Привет от C")
        super().say_hello()

class D(B, C):  # Множественное наследование
    def say_hello(self):
        print("Привет от D")
        super().say_hello()

obj_d = D()
print("--- Вызов say_hello() ---")
obj_d.say_hello()

print("\n--- Порядок MRO класса D ---")
for cls in D.__mro__:
    print(cls.__name__)

# Вывод вызова:
# Привет от D
# Привет от B
# Привет от C
# Привет от A

# Вывод MRO:
# D -> B -> C -> A -> object

# Пример использования паттерна Mixin
import json

# --- Это Миксин (Примесь) ---
class ToDictMixin:
    """Миксин, добавляющий возможность превратить объект в словарь."""
    def to_dict(self):
        # Используем __dict__ для получения всех атрибутов экземпляра
        return self.__dict__

# --- Это Миксин (Примесь) ---
class JSONMixin:
    """Миксин, добавляющий сериализацию в JSON. 
    Ожидает, что у объекта есть метод to_dict()"""
    def to_json(self):
        return json.dumps(self.to_dict(), ensure_ascii=False)

# --- Это Основной базовый класс ---
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# --- Целевой класс ---
# Миксины слева, базовый класс справа
class Employee(JSONMixin, ToDictMixin, Person):
    def __init__(self, name, age, salary):
        super().__init__(name, age) # Вызов Person.__init__
        self.salary = salary

# Тестируем
emp = Employee("Виктор", 35, 150000)
# Метод to_json пришел из JSONMixin, который под капотом вызвал
# метод to_dict из ToDictMixin. Код чист и модулен.
print(emp.to_json()) 
# Вывод: {"name": "Виктор", "age": 35, "salary": 150000}

class Vehicle: pass
class Car(Vehicle): pass
class ElectricCar(Car): pass
class Bicycle: pass

# Создаем объекты
my_tesla = ElectricCar()
my_bike = Bicycle()

# 1. Сравнение type() против isinstance()
print("--- Проверка объектов ---")
print(type(my_tesla) == Vehicle)      # False! type() не понимает наследование
print(isinstance(my_tesla, Vehicle))  # True! Тесла - это транспортное средство
print(isinstance(my_tesla, Car))      # True!
print(isinstance(my_bike, Vehicle))   # False. Велосипед не наследован от Vehicle

# 2. Проверка иерархии классов с issubclass()
print("\n--- Проверка классов ---")
print(issubclass(ElectricCar, Vehicle)) # True. Косвенное наследование через Car
print(issubclass(Car, Car))             # True. Класс является своим подклассом
print(issubclass(Bicycle, Vehicle))     # False.

# 3. Практическое применение (Полиморфизм)
def service_vehicle(v):
    if not isinstance(v, Vehicle):
        raise TypeError("Эта станция обслуживает только транспортные средства (Vehicle)!")
    print(f"Обслуживание {v.__class__.__name__} завершено.")

service_vehicle(my_tesla) # Успешно
# service_vehicle(my_bike) # Выдаст TypeError, так как Bicycle не Vehicle

from abc import ABC, abstractmethod

# 1. Создаем абстрактный базовый класс
class PaymentGateway(ABC):
    
    @abstractmethod
    def process_payment(self, amount):
        """Этот метод ОБЯЗАТЕЛЬНО должен быть переопределен в дочках."""
        pass
        
    @abstractmethod
    def refund(self, amount):
        """Обязательный метод для возврата средств."""
        pass
        
    def generate_receipt(self):
        """Обычный метод. Дочки унаследуют его как есть, переопределять не обязательно."""
        print("Генерация базового чека...")

# 2. Пытаемся создать класс с ошибкой (забыли метод refund)
class BadCryptoGateway(PaymentGateway):
    def process_payment(self, amount):
        print(f"Оплата {amount} в крипте.")

# ОШИБКА произойдет прямо здесь, при попытке создать экземпляр:
# TypeError: Can't instantiate abstract class BadCryptoGateway with abstract method refund
# gateway = BadCryptoGateway() 

# 3. Правильная реализация (контракт выполнен)
class StripeGateway(PaymentGateway):
    def process_payment(self, amount):
        print(f"Stripe: Обработка платежа на ${amount}")
        
    def refund(self, amount):
        print(f"Stripe: Возврат ${amount}")

# Это сработает
stripe = StripeGateway()
stripe.process_payment(100)
stripe.generate_receipt() # Унаследован от ABC

# Проектирование иерархии исключений для игры

# 1. Базовое исключение для всего проекта
class GameError(Exception):
    """Базовый класс для всех ошибок игры."""
    pass

# 2. Специфичные исключения (наследуются от базового)
class InventoryFullError(GameError):
    """Вызывается, когда инвентарь переполнен."""
    def __init__(self, item_name, max_capacity):
        self.item_name = item_name
        message = f"Невозможно добавить '{item_name}'. Инвентарь полон (макс: {max_capacity})!"
        super().__init__(message) # Передаем строку в базовый Exception

class NotEnoughManaError(GameError):
    """Вызывается, когда не хватает маны для заклинания."""
    pass # Можно оставить пустым, если не нужна сложная логика в __init__


# 3. Использование исключений в логике
def cast_spell(mana_cost, current_mana):
    if current_mana < mana_cost:
        # Выбрасываем (raise) собственную ошибку
        raise NotEnoughManaError("Слишком мало маны для огненного шара!")
    print("Магия применена!")

# 4. Обработка (перехват) исключений
try:
    cast_spell(50, 10)
except InventoryFullError as e:
    print(f"Ошибка инвентаря: {e}")
except GameError as e:
    # Перехватит NotEnoughManaError, так как она наследуется от GameError
    # Это полиморфизм в обработке исключений!
    print(f"Внутриигровая ошибка: {e}")
except Exception as e:
    # Перехватит непредвиденные питоновские ошибки (например TypeError)
    print(f"Системная ошибка: {e}")

# Демонстрация работы __slots__ при наследовании

class Point2D:
    # Запрещаем создание словаря, жестко фиксируем атрибуты x и y
    __slots__ = ('x', 'y')
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point3D(Point2D):
    # ПРАВИЛЬНО: добавляем только новый атрибут 'z'. 
    # x и y будут взяты из родительских слотов.
    __slots__ = ('z',)
    
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z

class BadPoint(Point2D):
    # ОШИБКА ДЖУНИОРА: забыли объявить __slots__ в дочернем классе.
    # Теперь у объекта появится полноценный __dict__, пожирающий память.
    pass

# Тестирование
p3 = Point3D(1, 2, 3)
print(f"p3: x={p3.x}, y={p3.y}, z={p3.z}")
# print(p3.__dict__)  # Вызовет AttributeError: 'Point3D' object has no attribute '__dict__'

bad_p = BadPoint(10, 20)
bad_p.color = "red" # Это сработает, так как появился __dict__
print("У BadPoint появился словарь:", bad_p.__dict__) # Выведет: {'color': 'red'}