// Base class with common behavior
public abstract class Vehicle {
    private String brand;
    private String model;
    private int year;
    protected double currentSpeed;

    protected Vehicle(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.currentSpeed = 0.0;
    }

    // Template method pattern
    public final void start() {
        performSafetyCheck();
        startEngine();
        System.out.println(brand + " " + model + " started");
    }

    // Hook method for subclasses
    protected void performSafetyCheck() {
        System.out.println("Performing basic safety check");
    }

    // Abstract method - must be implemented
    protected abstract void startEngine();

    public void accelerate(double speed) {
        currentSpeed += speed;
        System.out.println("Current speed: " + currentSpeed);
    }

    public void brake(double reduction) {
        currentSpeed = Math.max(0, currentSpeed - reduction);
        System.out.println("Current speed: " + currentSpeed);
    }

    // Getters
    public String getBrand() { return brand; }
    public String getModel() { return model; }
    public int getYear() { return year; }
    public double getCurrentSpeed() { return currentSpeed; }
}

// Concrete implementation
public class Car extends Vehicle {
    private int numberOfDoors;
    private boolean isSunroofOpen;

    public Car(String brand, String model, int year, int numberOfDoors) {
        super(brand, model, year);
        this.numberOfDoors = numberOfDoors;
        this.isSunroofOpen = false;
    }

    @Override
    protected void startEngine() {
        System.out.println("Car engine started with ignition");
    }

    @Override
    protected void performSafetyCheck() {
        super.performSafetyCheck();
        System.out.println("Checking doors are closed");
        System.out.println("Checking seatbelts");
    }

    public void openSunroof() {
        if (currentSpeed == 0) {
            isSunroofOpen = true;
            System.out.println("Sunroof opened");
        } else {
            System.out.println("Stop the car before opening sunroof");
        }
    }

    public int getNumberOfDoors() {
        return numberOfDoors;
    }
}

// Another concrete implementation
public class Motorcycle extends Vehicle {
    private boolean hasWindshield;

    public Motorcycle(String brand, String model, int year, boolean hasWindshield) {
        super(brand, model, year);
        this.hasWindshield = hasWindshield;
    }

    @Override
    protected void startEngine() {
        System.out.println("Motorcycle engine started with kick/button");
    }

    @Override
    public void accelerate(double speed) {
        // Override to add motorcycle-specific behavior
        if (currentSpeed + speed > 200) {
            System.out.println("Warning: Maximum safe speed exceeded!");
        }
        super.accelerate(speed);
    }

    public boolean hasWindshield() {
        return hasWindshield;
    }
}

from abc import ABC, abstractmethod
from typing import List, Optional
from datetime import datetime

class Employee(ABC):
    """Abstract base class for all employees."""

    def __init__(self, employee_id: str, name: str, email: str, hire_date: datetime):
        self._employee_id = employee_id
        self._name = name
        self._email = email
        self._hire_date = hire_date
        self._is_active = True

    @property
    def employee_id(self) -> str:
        return self._employee_id

    @property
    def name(self) -> str:
        return self._name

    @property
    def email(self) -> str:
        return self._email

    @property
    def hire_date(self) -> datetime:
        return self._hire_date

    @property
    def years_of_service(self) -> int:
        return (datetime.now() - self._hire_date).days // 365

    # Template method
    def process_payroll(self) -> float:
        """Process payroll - template method."""
        if not self._is_active:
            raise ValueError("Cannot process payroll for inactive employee")

        base_pay = self.calculate_pay()
        bonus = self.calculate_bonus()
        deductions = self.calculate_deductions()

        total_pay = base_pay + bonus - deductions
        self.record_payment(total_pay)
        return total_pay

    # Abstract methods - must be implemented by subclasses
    @abstractmethod
    def calculate_pay(self) -> float:
        """Calculate base pay."""
        pass

    # Hook methods with default implementation
    def calculate_bonus(self) -> float:
        """Calculate bonus - can be overridden."""
        return 0.0

    def calculate_deductions(self) -> float:
        """Calculate deductions - can be overridden."""
        return 0.0

    def record_payment(self, amount: float) -> None:
        """Record payment."""
        print(f"Recording payment of ${amount:.2f} for {self._name}")

    def deactivate(self) -> None:
        """Deactivate employee."""
        self._is_active = False


class SalariedEmployee(Employee):
    """Employee paid a fixed salary."""

    def __init__(
        self,
        employee_id: str,
        name: str,
        email: str,
        hire_date: datetime,
        annual_salary: float
    ):
        super().__init__(employee_id, name, email, hire_date)
        self._annual_salary = annual_salary

    def calculate_pay(self) -> float:
        """Calculate monthly salary."""
        return self._annual_salary / 12

    def calculate_bonus(self) -> float:
        """Annual bonus based on years of service."""
        return self._annual_salary * 0.01 * self.years_of_service


class HourlyEmployee(Employee):
    """Employee paid by the hour."""

    def __init__(
        self,
        employee_id: str,
        name: str,
        email: str,
        hire_date: datetime,
        hourly_rate: float
    ):
        super().__init__(employee_id, name, email, hire_date)
        self._hourly_rate = hourly_rate
        self._hours_worked = 0.0

    def log_hours(self, hours: float) -> None:
        """Log hours worked this period."""
        if hours < 0:
            raise ValueError("Hours cannot be negative")
        self._hours_worked += hours

    def calculate_pay(self) -> float:
        """Calculate pay based on hours worked."""
        regular_hours = min(self._hours_worked, 40)
        overtime_hours = max(0, self._hours_worked - 40)

        regular_pay = regular_hours * self._hourly_rate
        overtime_pay = overtime_hours * self._hourly_rate * 1.5

        return regular_pay + overtime_pay

    def record_payment(self, amount: float) -> None:
        """Record payment and reset hours."""
        super().record_payment(amount)
        self._hours_worked = 0.0


class CommissionEmployee(SalariedEmployee):
    """Employee with base salary plus commission."""

    def __init__(
        self,
        employee_id: str,
        name: str,
        email: str,
        hire_date: datetime,
        annual_salary: float,
        commission_rate: float
    ):
        super().__init__(employee_id, name, email, hire_date, annual_salary)
        self._commission_rate = commission_rate
        self._sales_this_period = 0.0

    def record_sale(self, amount: float) -> None:
        """Record a sale for commission calculation."""
        if amount <= 0:
            raise ValueError("Sale amount must be positive")
        self._sales_this_period += amount

    def calculate_pay(self) -> float:
        """Calculate base salary plus commission."""
        base = super().calculate_pay()
        commission = self._sales_this_period * self._commission_rate
        return base + commission

    def record_payment(self, amount: float) -> None:
        """Record payment and reset sales."""
        super().record_payment(amount)
        self._sales_this_period = 0.0

// Abstract base class
abstract class Shape {
  protected readonly id: string;
  protected color: string;

  constructor(color: string) {
    this.id = crypto.randomUUID();
    this.color = color;
  }

  // Abstract methods
  abstract area(): number;
  abstract perimeter(): number;
  abstract draw(): void;

  // Concrete methods
  getColor(): string {
    return this.color;
  }

  setColor(color: string): void {
    this.color = color;
  }

  describe(): string {
    return `${this.constructor.name} (${this.color}): Area = ${this.area().toFixed(2)}, Perimeter = ${this.perimeter().toFixed(2)}`;
  }
}

// Concrete implementations
class Circle extends Shape {
  private radius: number;

  constructor(color: string, radius: number) {
    super(color);
    if (radius <= 0) {
      throw new Error("Radius must be positive");
    }
    this.radius = radius;
  }

  area(): number {
    return Math.PI * this.radius ** 2;
  }

  perimeter(): number {
    return 2 * Math.PI * this.radius;
  }

  draw(): void {
    console.log(`Drawing a ${this.color} circle with radius ${this.radius}`);
  }

  getRadius(): number {
    return this.radius;
  }
}

class Rectangle extends Shape {
  private width: number;
  private height: number;

  constructor(color: string, width: number, height: number) {
    super(color);
    if (width <= 0 || height <= 0) {
      throw new Error("Dimensions must be positive");
    }
    this.width = width;
    this.height = height;
  }

  area(): number {
    return this.width * this.height;
  }

  perimeter(): number {
    return 2 * (this.width + this.height);
  }

  draw(): void {
    console.log(`Drawing a ${this.color} rectangle ${this.width}x${this.height}`);
  }

  isSquare(): boolean {
    return this.width === this.height;
  }
}

class Triangle extends Shape {
  private sideA: number;
  private sideB: number;
  private sideC: number;

  constructor(color: string, sideA: number, sideB: number, sideC: number) {
    super(color);
    if (!this.isValidTriangle(sideA, sideB, sideC)) {
      throw new Error("Invalid triangle dimensions");
    }
    this.sideA = sideA;
    this.sideB = sideB;
    this.sideC = sideC;
  }

  private isValidTriangle(a: number, b: number, c: number): boolean {
    return a + b > c && b + c > a && a + c > b;
  }

  area(): number {
    // Heron's formula
    const s = this.perimeter() / 2;
    return Math.sqrt(s * (s - this.sideA) * (s - this.sideB) * (s - this.sideC));
  }

  perimeter(): number {
    return this.sideA + this.sideB + this.sideC;
  }

  draw(): void {
    console.log(`Drawing a ${this.color} triangle`);
  }
}

// Component interfaces
interface Engine {
    void start();
    void stop();
    int getHorsepower();
}

interface Transmission {
    void shiftUp();
    void shiftDown();
    String getType();
}

interface GPS {
    void navigate(String destination);
    String getCurrentLocation();
}

// Concrete component implementations
class V6Engine implements Engine {
    private final int horsepower;
    private boolean running;

    public V6Engine(int horsepower) {
        this.horsepower = horsepower;
        this.running = false;
    }

    @Override
    public void start() {
        running = true;
        System.out.println("V6 engine started");
    }

    @Override
    public void stop() {
        running = false;
        System.out.println("V6 engine stopped");
    }

    @Override
    public int getHorsepower() {
        return horsepower;
    }
}

class ElectricEngine implements Engine {
    private final int horsepower;
    private boolean running;
    private int batteryLevel;

    public ElectricEngine(int horsepower) {
        this.horsepower = horsepower;
        this.batteryLevel = 100;
        this.running = false;
    }

    @Override
    public void start() {
        if (batteryLevel > 0) {
            running = true;
            System.out.println("Electric engine started silently");
        } else {
            System.out.println("Battery depleted!");
        }
    }

    @Override
    public void stop() {
        running = false;
        System.out.println("Electric engine stopped");
    }

    @Override
    public int getHorsepower() {
        return horsepower;
    }

    public int getBatteryLevel() {
        return batteryLevel;
    }
}

class AutomaticTransmission implements Transmission {
    private int currentGear;

    public AutomaticTransmission() {
        this.currentGear = 1;
    }

    @Override
    public void shiftUp() {
        if (currentGear < 8) {
            currentGear++;
            System.out.println("Automatically shifted to gear " + currentGear);
        }
    }

    @Override
    public void shiftDown() {
        if (currentGear > 1) {
            currentGear--;
            System.out.println("Automatically shifted to gear " + currentGear);
        }
    }

    @Override
    public String getType() {
        return "Automatic";
    }
}

class ManualTransmission implements Transmission {
    private int currentGear;

    public ManualTransmission() {
        this.currentGear = 1;
    }

    @Override
    public void shiftUp() {
        if (currentGear < 6) {
            currentGear++;
            System.out.println("Manually shifted to gear " + currentGear);
        }
    }

    @Override
    public void shiftDown() {
        if (currentGear > 1) {
            currentGear--;
            System.out.println("Manually shifted to gear " + currentGear);
        }
    }

    @Override
    public String getType() {
        return "Manual";
    }
}

// Composed car class
public class ComposedCar {
    private final Engine engine;
    private final Transmission transmission;
    private final GPS gps;  // Optional component
    private final String brand;
    private final String model;

    // Builder for flexible construction
    public static class Builder {
        private Engine engine;
        private Transmission transmission;
        private GPS gps;
        private String brand;
        private String model;

        public Builder brand(String brand) {
            this.brand = brand;
            return this;
        }

        public Builder model(String model) {
            this.model = model;
            return this;
        }

        public Builder engine(Engine engine) {
            this.engine = engine;
            return this;
        }

        public Builder transmission(Transmission transmission) {
            this.transmission = transmission;
            return this;
        }

        public Builder gps(GPS gps) {
            this.gps = gps;
            return this;
        }

        public ComposedCar build() {
            if (engine == null || transmission == null) {
                throw new IllegalStateException("Engine and transmission required");
            }
            return new ComposedCar(this);
        }
    }

    private ComposedCar(Builder builder) {
        this.engine = builder.engine;
        this.transmission = builder.transmission;
        this.gps = builder.gps;
        this.brand = builder.brand;
        this.model = builder.model;
    }

    // Delegate to components
    public void start() {
        engine.start();
        System.out.println(brand + " " + model + " is ready to drive");
    }

    public void stop() {
        engine.stop();
    }

    public void shiftUp() {
        transmission.shiftUp();
    }

    public void shiftDown() {
        transmission.shiftDown();
    }

    public void navigateTo(String destination) {
        if (gps != null) {
            gps.navigate(destination);
        } else {
            System.out.println("GPS not available");
        }
    }

    public String getSpecs() {
        return String.format("%s %s - %d HP %s transmission",
            brand, model, engine.getHorsepower(), transmission.getType());
    }
}

// Usage
ComposedCar sportsCar = new ComposedCar.Builder()
    .brand("Porsche")
    .model("911")
    .engine(new V6Engine(450))
    .transmission(new ManualTransmission())
    .build();

ComposedCar electricCar = new ComposedCar.Builder()
    .brand("Tesla")
    .model("Model 3")
    .engine(new ElectricEngine(283))
    .transmission(new AutomaticTransmission())
    .build();