# Procedural approach -- works fine for 1 student
student_name    = "Aarav Sharma"
student_roll    = 101
student_marks   = [88, 92, 75, 90, 85]
student_course  = "Computer Science"

def calculate_average(marks):
    return sum(marks) / len(marks)

def get_grade(average):
    if average >= 85:
        return "Distinction"
    elif average >= 60:
        return "First Class"
    else:
        return "Pass"

avg   = calculate_average(student_marks)
grade = get_grade(avg)
print(f"{student_name} -- Average: {avg:.1f}, Grade: {grade}")

# Things start getting messy fast
student1_name   = "Aarav Sharma"
student1_roll   = 101
student1_marks  = [88, 92, 75, 90, 85]
student1_course = "Computer Science"

student2_name   = "Priya Patel"
student2_roll   = 102
student2_marks  = [95, 88, 91, 87, 93]
student2_course = "Electronics"

# For 500 students, this approach completely falls apart
# You end up with 2000 variables and no structure

class Student:
    def __init__(self, name, roll, marks, course):
        self.name   = name
        self.roll   = roll
        self.marks  = marks
        self.course = course

    def average(self):
        return sum(self.marks) / len(self.marks)

    def grade(self):
        avg = self.average()
        if avg >= 85:   return "Distinction"
        elif avg >= 60: return "First Class"
        else:           return "Pass"

# Create as many students as you need -- all organised, all consistent
s1 = Student("Aarav Sharma",  101, [88, 92, 75, 90, 85], "Computer Science")
s2 = Student("Priya Patel",   102, [95, 88, 91, 87, 93], "Electronics")
s3 = Student("Rohan Verma",   103, [65, 70, 68, 72, 60], "Mechanical")

for student in [s1, s2, s3]:
    print(f"{student.name} -- Avg: {student.average():.1f}, Grade: {student.grade()}")

# The 'class' keyword defines a new blueprint
# Class names use PascalCase (capital first letter of each word)

class BankAccount:
    pass   # 'pass' means empty body -- valid Python, does nothing yet

# Creating an object is called "instantiation"
# You call the class like a function

account1 = BankAccount()
account2 = BankAccount()

# These are two separate objects -- completely independent
print(type(account1))           # <class '__main__.BankAccount'>
print(account1 is account2)     # False -- different objects in memory

print(isinstance(account1, BankAccount))   # True
print(type(account1).__name__)             # BankAccount

class BankAccount:

    def __init__(self, account_holder, account_number, balance=0):
        """
        Called automatically when a new BankAccount is created.

        Parameters:
            account_holder (str): Name of the account holder
            account_number (str): Unique account number
            balance (float):      Starting balance (default 0)
        """
        # These are instance attributes -- each object gets its own copy
        self.account_holder  = account_holder
        self.account_number  = account_number
        self.balance         = balance

# Creating objects now initialises their data
acc1 = BankAccount("Aarav Sharma",  "SBI001234", 15000)
acc2 = BankAccount("Priya Patel",   "SBI005678", 50000)
acc3 = BankAccount("Rohan Verma",   "SBI009012")         # balance defaults to 0

# Each object has its own independent data
print(acc1.account_holder)   # Aarav Sharma
print(acc2.balance)          # 50000
print(acc3.balance)          # 0

acc1 = BankAccount("Aarav Sharma", "SBI001234", 15000)

BankAccount.__init__(acc1, "Aarav Sharma", "SBI001234", 15000)

# You can name it anything, but 'self' is universal convention
# Never deviate from this convention in real code

class Demo:
    def __init__(this_object, value):   # 'this_object' works but never do this
        this_object.value = value

class Student:

    def __init__(self, name, roll, course):
        # Each student object gets its own name, roll, and course
        self.name   = name
        self.roll   = roll
        self.course = course
        self.marks  = []          # starts empty for every new student
        self.active = True        # all students start active

# Two students -- completely independent attribute sets
s1 = Student("Sneha Iyer",   201, "Data Science")
s2 = Student("Karan Singh",  202, "Cybersecurity")

s1.marks.append(88)   # only s1's marks list is affected
print(s1.marks)       # [88]
print(s2.marks)       # []   -- s2 is unaffected

s1 = Student("Sneha Iyer", 201, "Data Science")

# Valid but not recommended -- other code won't know this attribute exists
s1.hometown = "Chennai"

# Preferred: define all attributes in __init__, even if they start as None
class Student:
    def __init__(self, name, roll, course):
        self.name     = name
        self.roll     = roll
        self.course   = course
        self.hometown = None    # known attribute, just not set yet

class BankAccount:

    def __init__(self, account_holder, account_number, balance=0):
        self.account_holder = account_holder
        self.account_number = account_number
        self.balance        = balance
        self.transactions   = []   # list to track all transactions

    def deposit(self, amount):
        """Add money to the account."""
        if amount <= 0:
            raise ValueError("Deposit amount must be positive.")
        self.balance += amount
        self.transactions.append(("deposit", amount))
        print(f"Rs.{amount:,} deposited. New balance: Rs.{self.balance:,}")

    def withdraw(self, amount):
        """Remove money from the account if sufficient balance exists."""
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive.")
        if amount > self.balance:
            print(f"Insufficient balance. Available: Rs.{self.balance:,}")
            return False
        self.balance -= amount
        self.transactions.append(("withdrawal", amount))
        print(f"Rs.{amount:,} withdrawn. New balance: Rs.{self.balance:,}")
        return True

    def get_statement(self):
        """Print a summary of all transactions."""
        print(f"\n--- Statement for {self.account_holder} ---")
        print(f"Account: {self.account_number}")
        for txn_type, amount in self.transactions:
            symbol = "+" if txn_type == "deposit" else "-"
            print(f"  {symbol} Rs.{amount:,}  ({txn_type})")
        print(f"Current Balance: Rs.{self.balance:,}")
        print("-" * 40)

    def __str__(self):
        """String representation -- what print(account) shows."""
        return (f"BankAccount({self.account_holder}, "
                f"Acc: {self.account_number}, "
                f"Balance: Rs.{self.balance:,})")


# Using the methods
acc = BankAccount("Meera Nair", "HDFC00456", 10000)

acc.deposit(5000)
acc.deposit(2500)
acc.withdraw(3000)
acc.withdraw(20000)   # insufficient balance
acc.get_statement()

print(acc)   # calls __str__

class Student:

    def __init__(self, name, marks):
        self.name  = name
        self.marks = marks   # list of marks across 5 subjects

    def average(self):
        """Calculate average marks."""
        return sum(self.marks) / len(self.marks)

    def grade(self):
        """Determine grade based on average."""
        avg = self.average()   # calling another method using self
        if avg >= 85:   return "Distinction"
        elif avg >= 60: return "First Class"
        elif avg >= 40: return "Pass"
        else:           return "Fail"

    def report(self):
        """Print full report -- calls both average() and grade()."""
        print(f"Student : {self.name}")
        print(f"Marks   : {self.marks}")
        print(f"Average : {self.average():.1f}")
        print(f"Grade   : {self.grade()}")

s = Student("Arjun Kumar", [88, 92, 75, 90, 85])
s.report()

class Employee:
    def __init__(self, name, salary):
        self.name   = name    # instance variable -- unique to each Employee
        self.salary = salary  # instance variable -- unique to each Employee

e1 = Employee("Vikram Nair",   85000)
e2 = Employee("Ananya Sharma", 72000)

# Each employee has their own name and salary
print(e1.name)    # Vikram Nair
print(e2.salary)  # 72000

class Employee:

    # Class variables -- shared by ALL Employee objects
    company_name = "Codeverra Technologies"
    employee_count = 0
    ANNUAL_BONUS_RATE = 0.10   # 10% bonus, same for all

    def __init__(self, name, salary, department):
        # Instance variables -- unique to each Employee
        self.name       = name
        self.salary     = salary
        self.department = department

        # Modify the class variable to track how many employees exist
        Employee.employee_count += 1   # use class name, not self, for clarity

    def annual_bonus(self):
        """Calculate bonus using the shared class variable."""
        return self.salary * Employee.ANNUAL_BONUS_RATE

    def company_info(self):
        """Access class variable through self -- also works."""
        return f"{self.name} works at {self.company_name}"
        # self.company_name works but Employee.company_name is clearer


# Creating employees
e1 = Employee("Vikram Nair",   85000, "Engineering")
e2 = Employee("Ananya Sharma", 72000, "Product")
e3 = Employee("Suresh Kumar",  68000, "Sales")

print(Employee.employee_count)   # 3  -- class variable updated by all three
print(e1.employee_count)         # 3  -- accessible via instance too
print(e2.employee_count)         # 3  -- same value for everyone

print(e1.company_info())   # Vikram Nair works at Codeverra Technologies
print(e2.company_info())   # Ananya Sharma works at Codeverra Technologies

print(f"Vikram's bonus: Rs.{e1.annual_bonus():,}")   # Rs.8,500
print(f"Ananya's bonus: Rs.{e2.annual_bonus():,}")   # Rs.7,200

class Employee:
    company_name   = "Codeverra Technologies"
    employee_count = 0

    def __init__(self, name):
        self.name = name
        Employee.employee_count += 1

e1 = Employee("Vikram")
e2 = Employee("Ananya")

# DANGEROUS -- this does NOT modify the class variable
# It creates a NEW instance variable on e1 that shadows the class variable
e1.company_name = "New Company"

print(e1.company_name)     # "New Company"  -- e1's own instance variable
print(e2.company_name)     # "Codeverra Technologies"  -- still the class variable
print(Employee.company_name) # "Codeverra Technologies" -- class variable unchanged

# CORRECT way to update a class variable (affects all objects)
Employee.company_name = "Codeverra Pvt Ltd"
print(e1.company_name)   # still "New Company" -- e1 has its own instance variable now
print(e2.company_name)   # "Codeverra Pvt Ltd" -- uses the updated class variable

class Student:
    def __init__(self, name, marks):
        self.name  = name
        self.marks = marks

    def average(self):        # instance method
        return sum(self.marks) / len(self.marks)

class Student:

    # Class variable
    institution = "Codeverra Institute, Pune"

    def __init__(self, name, roll, marks):
        self.name  = name
        self.roll  = roll
        self.marks = marks

    @classmethod
    def from_csv_string(cls, csv_string):
        """
        Alternative constructor -- create a Student from a CSV line.
        Usage: Student.from_csv_string("Aarav,101,88,92,75,90,85")
        """
        parts  = csv_string.split(",")
        name   = parts[0].strip()
        roll   = int(parts[1].strip())
        marks  = [int(m.strip()) for m in parts[2:]]
        return cls(name, roll, marks)   # cls(...) is same as Student(...)

    @classmethod
    def from_dict(cls, data_dict):
        """Alternative constructor -- create from a dictionary."""
        return cls(data_dict["name"], data_dict["roll"], data_dict["marks"])

    @classmethod
    def set_institution(cls, new_name):
        """Modify the class variable for all students."""
        cls.institution = new_name

    def __str__(self):
        avg = sum(self.marks) / len(self.marks)
        return f"Student({self.name}, Roll: {self.roll}, Avg: {avg:.1f})"


# Using regular constructor
s1 = Student("Aarav Sharma", 101, [88, 92, 75, 90, 85])

# Using class method constructors -- much cleaner for real data pipelines
s2 = Student.from_csv_string("Priya Patel, 102, 95, 88, 91, 87, 93")
s3 = Student.from_dict({"name": "Rohan Verma", "roll": 103, "marks": [72, 68, 75, 70, 65]})

print(s1)   # Student(Aarav Sharma, Roll: 101, Avg: 86.0)
print(s2)   # Student(Priya Patel, Roll: 102, Avg: 90.8)
print(s3)   # Student(Rohan Verma, Roll: 103, Avg: 70.0)

print(Student.institution)        # Codeverra Institute, Pune
Student.set_institution("Codeverra Academy, Mumbai")
print(Student.institution)        # Codeverra Academy, Mumbai
print(s1.institution)             # Codeverra Academy, Mumbai (class var updated)

class TemperatureConverter:
    """A utility class for temperature conversions."""

    @staticmethod
    def celsius_to_fahrenheit(c):
        """Convert Celsius to Fahrenheit."""
        return (c * 9/5) + 32

    @staticmethod
    def fahrenheit_to_celsius(f):
        """Convert Fahrenheit to Celsius."""
        return (f - 32) * 5/9

    @staticmethod
    def celsius_to_kelvin(c):
        """Convert Celsius to Kelvin."""
        return c + 273.15


# Static methods can be called on the class directly -- no object needed
print(TemperatureConverter.celsius_to_fahrenheit(37))   # 98.6  (body temp)
print(TemperatureConverter.celsius_to_fahrenheit(0))    # 32.0
print(TemperatureConverter.celsius_to_kelvin(100))      # 373.15

# Also callable via an instance, though the class version is more common
tc = TemperatureConverter()
print(tc.fahrenheit_to_celsius(98.6))   # 37.0

class Student:

    institution = "Codeverra Institute"

    def __init__(self, name, marks):
        self.name  = name
        self.marks = marks

    def average(self):
        return sum(self.marks) / len(self.marks)

    @staticmethod
    def is_valid_mark(mark):
        """
        Check if a mark is in the valid range (0-100).
        Does not need any student data -- pure utility.
        """
        return 0 <= mark <= 100

    @staticmethod
    def letter_grade(average):
        """
        Convert a numeric average to a letter grade.
        Useful as a standalone utility -- does not need self or cls.
        """
        if average >= 85: return "A"
        if average >= 70: return "B"
        if average >= 55: return "C"
        if average >= 40: return "D"
        return "F"


# Validate marks before creating a student
raw_marks = [88, 105, 72, -5, 90]   # two invalid marks
valid_marks = [m for m in raw_marks if Student.is_valid_mark(m)]
print(valid_marks)   # [88, 72, 90]

s = Student("Divya Menon", valid_marks)
print(Student.letter_grade(s.average()))   # B

# Custom exceptions are just classes that inherit from Exception
class InsufficientFundsError(Exception):
    """Raised when a withdrawal exceeds the available balance."""
    pass


class InvalidAmountError(Exception):
    """Raised when a transaction amount is zero or negative."""
    pass


class AccountFrozenError(Exception):
    """Raised when a transaction is attempted on a frozen account."""
    pass

class InsufficientFundsError(Exception):
    """Raised when a withdrawal exceeds the available balance."""

    def __init__(self, requested, available):
        self.requested = requested
        self.available = available
        # Always call super().__init__() with a helpful message
        super().__init__(
            f"Cannot withdraw Rs.{requested:,}. "
            f"Available balance: Rs.{available:,}. "
            f"Shortfall: Rs.{requested - available:,}."
        )


class InvalidAmountError(Exception):
    """Raised when a transaction amount is zero or negative."""

    def __init__(self, amount, operation):
        self.amount    = amount
        self.operation = operation
        super().__init__(
            f"Invalid {operation} amount: Rs.{amount}. "
            f"Amount must be greater than zero."
        )


class AccountFrozenError(Exception):
    """Raised when a transaction is attempted on a frozen account."""

    def __init__(self, account_number):
        self.account_number = account_number
        super().__init__(
            f"Account {account_number} is frozen. "
            f"Contact your branch to resolve this."
        )

class BankAccount:

    def __init__(self, holder, account_number, balance=0):
        self.holder         = holder
        self.account_number = account_number
        self.balance        = balance
        self.is_frozen      = False

    def freeze(self):
        self.is_frozen = True
        print(f"Account {self.account_number} has been frozen.")

    def deposit(self, amount):
        if self.is_frozen:
            raise AccountFrozenError(self.account_number)
        if amount <= 0:
            raise InvalidAmountError(amount, "deposit")
        self.balance += amount
        return self.balance

    def withdraw(self, amount):
        if self.is_frozen:
            raise AccountFrozenError(self.account_number)
        if amount <= 0:
            raise InvalidAmountError(amount, "withdrawal")
        if amount > self.balance:
            raise InsufficientFundsError(amount, self.balance)
        self.balance -= amount
        return self.balance


# Using the account with proper exception handling
acc = BankAccount("Aarav Sharma", "SBI001234", 10000)

# Test InsufficientFundsError
try:
    acc.withdraw(25000)
except InsufficientFundsError as e:
    print(f"Transaction failed: {e}")
    print(f"Requested: Rs.{e.requested:,}")
    print(f"Available: Rs.{e.available:,}")

# Test AccountFrozenError
acc.freeze()
try:
    acc.deposit(5000)
except AccountFrozenError as e:
    print(f"Transaction failed: {e}")

# Test InvalidAmountError
acc2 = BankAccount("Priya Patel", "HDFC005678", 50000)
try:
    acc2.deposit(-1000)
except InvalidAmountError as e:
    print(f"Transaction failed: {e}")

# Create a base exception for your entire application
class CodevenaError(Exception):
    """Base exception for all Codeverra application errors."""
    pass


# All domain-specific exceptions inherit from your base
class StudentError(CodevenaError):
    """Base for all student-related errors."""
    pass


class EnrollmentError(StudentError):
    """Raised when enrollment fails."""
    pass


class EnrollmentLimitError(EnrollmentError):
    """Raised when a course is full."""

    def __init__(self, course_name, limit):
        super().__init__(
            f"Course '{course_name}' is full. Maximum enrollment: {limit}."
        )


class PrerequisiteError(EnrollmentError):
    """Raised when prerequisite courses are not completed."""

    def __init__(self, course_name, missing):
        super().__init__(
            f"Cannot enroll in '{course_name}'. "
            f"Missing prerequisites: {', '.join(missing)}."
        )


# Now you can catch at different levels of specificity
try:
    raise PrerequisiteError("Machine Learning", ["Python Basics", "Statistics"])
except EnrollmentError as e:
    print(f"Enrollment failed: {e}")   # catches PrerequisiteError too
except StudentError as e:
    print(f"Student error: {e}")
except CodevenaError as e:
    print(f"Application error: {e}")

# Without encapsulation -- dangerous
acc = BankAccount("Aarav", "SBI001", 10000)
acc.balance = -999999   # nothing stops this -- corrupted state
acc.balance = "hello"   # also valid Python -- completely wrong type

class CricketPlayer:

    def __init__(self, name, team, runs, is_contracted):
        self.name           = name         # public -- access freely
        self.team           = team         # public
        self._runs          = runs         # protected -- internal use
        self.__is_contracted = is_contracted  # private -- name-mangled

    def get_runs(self):
        """Public method to access protected attribute."""
        return self._runs

    def is_available(self):
        """Public method to check private attribute."""
        return self.__is_contracted

player = CricketPlayer("Rohit Sharma", "Mumbai Indians", 9825, True)

# Public -- fine
print(player.name)            # Rohit Sharma
print(player.team)            # Mumbai Indians

# Protected -- accessible but signals "please do not"
print(player._runs)           # 9825  -- works but is bad practice

# Private -- name-mangled, harder to reach
# print(player.__is_contracted) # AttributeError!

# Python mangles the name to _ClassName__attribute
print(player._CricketPlayer__is_contracted)   # True -- but never do this

# Use the public methods instead
print(player.get_runs())      # 9825
print(player.is_available())  # True

class BankAccount:

    def __init__(self, holder, balance):
        self.holder   = holder    # public
        self._log     = []        # protected -- internal transaction log
        self.__balance = balance  # private -- name mangled to _BankAccount__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount          # accessed freely inside the class
            self._log.append(f"+{amount}")
        else:
            raise ValueError("Amount must be positive")

    def get_balance(self):
        """Public interface to read the private balance."""
        return self.__balance


acc = BankAccount("Priya Patel", 50000)
acc.deposit(10000)
print(acc.get_balance())   # 60000

# acc.__balance  -->  AttributeError
# acc._BankAccount__balance  -->  60000 (works but is a violation of intent)

class Circle:
    def __init__(self, radius):
        self.radius = radius   # public -- anyone can set radius = -5

c = Circle(7)
c.radius = -10   # nothing stops this -- physically meaningless

import math

class Circle:

    def __init__(self, radius):
        # Note: calls the setter below (not direct assignment)
        self.radius = radius

    @property
    def radius(self):
        """Getter -- called when you READ circle.radius"""
        return self.__radius

    @radius.setter
    def radius(self, value):
        """Setter -- called when you WRITE circle.radius = value"""
        if value <= 0:
            raise ValueError(f"Radius must be positive. Got: {value}")
        self.__radius = value   # store in private attribute

    @property
    def diameter(self):
        """Computed property -- no setter because it is derived."""
        return self.__radius * 2

    @property
    def area(self):
        """Computed property."""
        return round(math.pi * self.__radius ** 2, 4)

    @property
    def circumference(self):
        """Computed property."""
        return round(2 * math.pi * self.__radius, 4)


c = Circle(7)
print(c.radius)         # 7       -- calls the getter
print(c.diameter)       # 14      -- computed property
print(c.area)           # 153.938
print(c.circumference)  # 43.9823

c.radius = 10           # calls the setter -- validated
print(c.area)           # 314.1593

c.radius = -5           # ValueError: Radius must be positive. Got: -5

# diameter has no setter -- it is read-only
c.diameter = 20         # AttributeError: can't set attribute

class Employee:

    # Class variable: valid department names
    VALID_DEPARTMENTS = {"Engineering", "Product", "Sales", "HR", "Marketing", "Finance"}

    def __init__(self, name, salary, department):
        # These all go through their setters for validation
        self.name       = name
        self.salary     = salary
        self.department = department

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, value):
        if not isinstance(value, str) or not value.strip():
            raise ValueError("Name must be a non-empty string.")
        self.__name = value.strip().title()   # clean and normalise

    @property
    def salary(self):
        return self.__salary

    @salary.setter
    def salary(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError("Salary must be a number.")
        if value < 15000:
            raise ValueError(f"Salary cannot be below Rs.15,000. Got: Rs.{value:,}")
        self.__salary = float(value)

    @salary.deleter
    def salary(self):
        """Called when you do: del employee.salary"""
        print(f"Salary record for {self.__name} has been cleared.")
        self.__salary = None

    @property
    def department(self):
        return self.__department

    @department.setter
    def department(self, value):
        if value not in Employee.VALID_DEPARTMENTS:
            raise ValueError(
                f"'{value}' is not a valid department. "
                f"Choose from: {sorted(Employee.VALID_DEPARTMENTS)}"
            )
        self.__department = value

    @property
    def annual_salary(self):
        """Read-only computed property."""
        if self.__salary is None:
            return None
        return self.__salary * 12

    def __str__(self):
        return (f"Employee({self.__name}, "
                f"Dept: {self.__department}, "
                f"Salary: Rs.{self.__salary:,.0f}/month)")


# All validation happens automatically through setters
emp = Employee("vikram nair", 85000, "Engineering")
print(emp)              # Employee(Vikram Nair, Dept: Engineering, Salary: Rs.85,000/month)
print(emp.annual_salary) # 1020000.0

emp.salary = 95000      # valid -- goes through setter
print(emp.salary)       # 95000.0

try:
    emp.salary = 5000   # invalid
except ValueError as e:
    print(e)            # Salary cannot be below Rs.15,000. Got: Rs.5,000

try:
    emp.department = "Accounts"  # invalid
except ValueError as e:
    print(e)

del emp.salary          # calls the deleter
print(emp.annual_salary) # None

class Animal:
    """Parent class -- defines common behaviour for all animals."""

    def __init__(self, name, species, age):
        self.name    = name
        self.species = species
        self.age     = age

    def breathe(self):
        print(f"{self.name} is breathing.")

    def eat(self, food):
        print(f"{self.name} is eating {food}.")

    def describe(self):
        print(f"{self.name} is a {self.age}-year-old {self.species}.")


class Dog(Animal):
    """Child class -- inherits everything from Animal, adds dog-specific behaviour."""

    def __init__(self, name, age, breed):
        # Call the parent __init__ to set up the inherited attributes
        super().__init__(name, species="Dog", age=age)
        self.breed = breed   # dog-specific attribute

    def bark(self):
        print(f"{self.name} says: Woof!")

    def fetch(self, item):
        print(f"{self.name} fetched the {item}!")


class Cat(Animal):
    """Another child class of Animal."""

    def __init__(self, name, age, is_indoor):
        super().__init__(name, species="Cat", age=age)
        self.is_indoor = is_indoor

    def meow(self):
        print(f"{self.name} says: Meow!")

    def purr(self):
        print(f"{self.name} is purring...")


# Creating objects
tommy = Dog("Tommy",  3, "Labrador")
whiskers = Cat("Whiskers", 5, is_indoor=True)

# Inherited methods -- available without redefining
tommy.describe()         # Tommy is a 3-year-old Dog.
tommy.breathe()          # Tommy is breathing.
tommy.eat("chicken")     # Tommy is eating chicken.

# Dog-specific methods
tommy.bark()             # Tommy says: Woof!
tommy.fetch("ball")      # Tommy fetched the ball!

# Cat-specific methods
whiskers.meow()
whiskers.purr()
whiskers.describe()      # Whiskers is a 5-year-old Cat.

# isinstance() checks inheritance hierarchy
print(isinstance(tommy, Dog))     # True
print(isinstance(tommy, Animal))  # True  -- Dog IS-AN Animal
print(isinstance(tommy, Cat))     # False

class Vehicle:
    """Base class for all vehicles."""

    def __init__(self, make, model, year, fuel_type):
        self.make      = make
        self.model     = model
        self.year      = year
        self.fuel_type = fuel_type
        self.speed     = 0   # all vehicles start at rest

    def accelerate(self, amount):
        self.speed += amount
        print(f"{self.make} {self.model} accelerating to {self.speed} km/h")

    def brake(self, amount):
        self.speed = max(0, self.speed - amount)
        print(f"{self.make} {self.model} slowing to {self.speed} km/h")

    def __str__(self):
        return f"{self.year} {self.make} {self.model} ({self.fuel_type})"


class ElectricVehicle(Vehicle):
    """Electric vehicles -- inherits from Vehicle, adds battery management."""

    def __init__(self, make, model, year, battery_kwh, range_km):
        # Call Vehicle.__init__ for the shared attributes
        super().__init__(make, model, year, fuel_type="Electric")
        # Add EV-specific attributes
        self.battery_kwh    = battery_kwh
        self.range_km       = range_km
        self.charge_percent = 100   # starts fully charged

    def charge(self, percent):
        self.charge_percent = min(100, self.charge_percent + percent)
        print(f"{self.make} {self.model} charged to {self.charge_percent}%")

    def estimated_range(self):
        return self.range_km * (self.charge_percent / 100)

    def __str__(self):
        # Extend the parent's __str__ with EV-specific info
        base = super().__str__()
        return f"{base} | Battery: {self.battery_kwh}kWh | Range: {self.range_km}km"


class Tata_Nexon_EV(ElectricVehicle):
    """Specific model -- inherits from ElectricVehicle."""

    # Tata Nexon EV Long Range specs
    DEFAULT_BATTERY = 40.5   # kWh
    DEFAULT_RANGE   = 465    # km (claimed)

    def __init__(self, year, color):
        super().__init__(
            make="Tata", model="Nexon EV",
            year=year,
            battery_kwh=self.DEFAULT_BATTERY,
            range_km=self.DEFAULT_RANGE
        )
        self.color = color

    def __str__(self):
        return f"{super().__str__()} | Color: {self.color}"


# Using the hierarchy
nexon = Tata_Nexon_EV(2024, "Pristine White")
print(nexon)
nexon.accelerate(60)
nexon.accelerate(40)
nexon.brake(30)

print(f"Estimated remaining range: {nexon.estimated_range():.0f}km")

# All three are True -- full hierarchy
print(isinstance(nexon, Tata_Nexon_EV))    # True
print(isinstance(nexon, ElectricVehicle))  # True
print(isinstance(nexon, Vehicle))          # True

class Shape:
    """Base class for geometric shapes."""

    def __init__(self, colour="white"):
        self.colour = colour

    def area(self):
        """To be overridden by each specific shape."""
        raise NotImplementedError("Subclasses must implement area()")

    def describe(self):
        print(f"I am a {self.__class__.__name__} with area {self.area():.2f} sq units.")


class Rectangle(Shape):

    def __init__(self, length, width, colour="white"):
        super().__init__(colour)
        self.length = length
        self.width  = width

    def area(self):
        """Override parent's area() with rectangle-specific formula."""
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)


class Circle(Shape):

    def __init__(self, radius, colour="white"):
        import math
        super().__init__(colour)
        self.radius = radius
        self._pi    = math.pi

    def area(self):
        """Override parent's area() with circle-specific formula."""
        return self._pi * self.radius ** 2


class Triangle(Shape):

    def __init__(self, base, height, colour="white"):
        super().__init__(colour)
        self.base   = base
        self.height = height

    def area(self):
        """Override parent's area() with triangle-specific formula."""
        return 0.5 * self.base * self.height


# Each shape uses its own area() method
r = Rectangle(8, 5)
c = Circle(7)
t = Triangle(6, 4)

r.describe()   # I am a Rectangle with area 40.00 sq units.
c.describe()   # I am a Circle with area 153.94 sq units.
t.describe()   # I am a Triangle with area 12.00 sq units.

class PaymentGateway:
    """Base class for all payment methods."""

    def __init__(self, name):
        self.name = name

    def process_payment(self, amount):
        """Each subclass implements this differently."""
        raise NotImplementedError

    def refund(self, amount, reason):
        """Each subclass implements this differently."""
        raise NotImplementedError


class UPIPayment(PaymentGateway):

    def __init__(self, upi_id):
        super().__init__("UPI")
        self.upi_id = upi_id

    def process_payment(self, amount):
        print(f"Processing Rs.{amount:,} via UPI ({self.upi_id})")
        print(f"  Sending payment request to {self.upi_id}...")
        print(f"  Payment of Rs.{amount:,} successful via UPI.")
        return True

    def refund(self, amount, reason):
        print(f"Initiating UPI refund of Rs.{amount:,} to {self.upi_id}")
        print(f"  Reason: {reason}")
        print(f"  Refund will reflect in 1-3 business days.")


class NetBankingPayment(PaymentGateway):

    def __init__(self, bank_name, account_last4):
        super().__init__("Net Banking")
        self.bank_name      = bank_name
        self.account_last4  = account_last4

    def process_payment(self, amount):
        print(f"Processing Rs.{amount:,} via {self.bank_name} Net Banking")
        print(f"  Account ending: ****{self.account_last4}")
        print(f"  Payment of Rs.{amount:,} successful via Net Banking.")
        return True

    def refund(self, amount, reason):
        print(f"Initiating Net Banking refund of Rs.{amount:,}")
        print(f"  To: {self.bank_name} account ****{self.account_last4}")
        print(f"  Reason: {reason}")
        print(f"  Refund will reflect in 5-7 business days.")


class WalletPayment(PaymentGateway):

    def __init__(self, wallet_name, wallet_balance):
        super().__init__(wallet_name)
        self.wallet_balance = wallet_balance

    def process_payment(self, amount):
        if amount > self.wallet_balance:
            print(f"Insufficient wallet balance. Available: Rs.{self.wallet_balance:,}")
            return False
        self.wallet_balance -= amount
        print(f"Processing Rs.{amount:,} via {self.name} Wallet")
        print(f"  Remaining wallet balance: Rs.{self.wallet_balance:,}")
        return True

    def refund(self, amount, reason):
        self.wallet_balance += amount
        print(f"Rs.{amount:,} refunded to {self.name} Wallet")
        print(f"  New balance: Rs.{self.wallet_balance:,}")


# THE POWER OF POLYMORPHISM:
# This function works with ANY payment gateway -- present or future
def checkout(order_total, payment_method):
    """
    Process a payment -- does not care which gateway is used.
    All gateways have process_payment() -- polymorphism handles the rest.
    """
    print(f"\n--- Checkout: Rs.{order_total:,} ---")
    success = payment_method.process_payment(order_total)
    if success:
        print("Order confirmed!")
    else:
        print("Payment failed. Please try another method.")


# Create different payment methods
upi      = UPIPayment("aarav@okaxis")
netbank  = NetBankingPayment("HDFC Bank", "4521")
paytm    = WalletPayment("Paytm", 2000)

# Same function call -- completely different behaviour
checkout(1299, upi)
checkout(5499, netbank)
checkout(1299, paytm)
checkout(3500, paytm)   # insufficient balance

# Iterate over a mixed list of payment objects
print("\n--- All payment methods ---")
all_methods = [upi, netbank, paytm]
for method in all_methods:
    # process_payment is called on each -- Python picks the right version
    method.process_payment(100)

class Printer:
    def print_document(self, text):
        print(f"[Printer]: {text}")

class EmailSender:
    def print_document(self, text):
        print(f"[Email]: Sending '{text}' to inbox...")

class SMSService:
    def print_document(self, text):
        print(f"[SMS]: Sending '{text}' as SMS...")

# None of these inherit from a common base class
# But they all have print_document() -- duck typing makes them interchangeable
def distribute_report(report_text, *output_channels):
    for channel in output_channels:
        channel.print_document(report_text)

printer = Printer()
email   = EmailSender()
sms     = SMSService()

distribute_report("Q3 Sales Report", printer, email, sms)