Case Study: Parking Lot System

from enum import Enum
from datetime import datetime
from typing import Optional, Dict, List
from dataclasses import dataclass
import uuid

class VehicleType(Enum):
    MOTORCYCLE = 1
    CAR = 2
    TRUCK = 3

class SpotType(Enum):
    COMPACT = 1     # Fits motorcycle, car
    REGULAR = 2     # Fits motorcycle, car
    LARGE = 3       # Fits all vehicles

class TicketStatus(Enum):
    ACTIVE = 1
    PAID = 2
    LOST = 3

# Pricing per hour
HOURLY_RATES = {
    VehicleType.MOTORCYCLE: 1.0,
    VehicleType.CAR: 2.0,
    VehicleType.TRUCK: 4.0
}

class Vehicle:
    def __init__(self, license_plate: str, vehicle_type: VehicleType):
        self.license_plate = license_plate
        self.vehicle_type = vehicle_type
    
    def can_fit_in(self, spot_type: SpotType) -> bool:
        """Check if vehicle fits in spot type -- Polymorphism: each subclass defines its own fitting logic"""
        raise NotImplementedError

class Motorcycle(Vehicle):
    def __init__(self, license_plate: str):
        super().__init__(license_plate, VehicleType.MOTORCYCLE)
    
    def can_fit_in(self, spot_type: SpotType) -> bool:
        return True  # Motorcycle fits anywhere

class Car(Vehicle):
    def __init__(self, license_plate: str):
        super().__init__(license_plate, VehicleType.CAR)
    
    def can_fit_in(self, spot_type: SpotType) -> bool:
        return spot_type in [SpotType.COMPACT, SpotType.REGULAR, SpotType.LARGE]

class Truck(Vehicle):
    def __init__(self, license_plate: str):
        super().__init__(license_plate, VehicleType.TRUCK)
    
    def can_fit_in(self, spot_type: SpotType) -> bool:
        return spot_type == SpotType.LARGE  # Only large spots

class ParkingSpot:
    def __init__(self, spot_id: str, floor_number: int, spot_type: SpotType):
        self.id = spot_id
        self.floor_number = floor_number
        self.spot_type = spot_type
        self._vehicle: Optional[Vehicle] = None
        self._is_available = True
    
    @property
    def is_available(self) -> bool:
        return self._is_available
    
    def can_fit(self, vehicle: Vehicle) -> bool:
        """Check if vehicle can park here"""
        return self._is_available and vehicle.can_fit_in(self.spot_type)
    
    def assign_vehicle(self, vehicle: Vehicle) -> bool:
        """Park a vehicle in this spot"""
        if not self.can_fit(vehicle):
            return False
        
        self._vehicle = vehicle
        self._is_available = False
        return True
    
    def remove_vehicle(self) -> Optional[Vehicle]:
        """Remove vehicle from spot"""
        vehicle = self._vehicle
        self._vehicle = None
        self._is_available = True
        return vehicle

@dataclass
class ParkingTicket:
    id: str
    license_plate: str
    spot_id: str
    floor_number: int
    entry_time: datetime
    exit_time: Optional[datetime] = None
    status: TicketStatus = TicketStatus.ACTIVE
    
    @staticmethod
    def create(vehicle: Vehicle, spot: ParkingSpot) -> 'ParkingTicket':
        return ParkingTicket(
            id=str(uuid.uuid4()),
            license_plate=vehicle.license_plate,
            spot_id=spot.id,
            floor_number=spot.floor_number,
            entry_time=datetime.now()
        )
    
    def calculate_fee(self, vehicle_type: VehicleType) -> float:
        """Calculate parking fee based on duration"""
        if self.exit_time is None:
            self.exit_time = datetime.now()
        
        duration = self.exit_time - self.entry_time
        hours = max(1, int(duration.total_seconds() / 3600) + 1)  # Round up
        
        return hours * HOURLY_RATES[vehicle_type]

class Floor:
    def __init__(self, floor_number: int):
        self.floor_number = floor_number
        self.spots: Dict[SpotType, List[ParkingSpot]] = {
            SpotType.COMPACT: [],
            SpotType.REGULAR: [],
            SpotType.LARGE: []
        }
    
    def add_spot(self, spot: ParkingSpot):
        """Add a parking spot to this floor"""
        self.spots[spot.spot_type].append(spot)
    
    def get_available_count(self, spot_type: SpotType) -> int:
        """Get count of available spots of given type"""
        return sum(1 for spot in self.spots[spot_type] if spot.is_available)
    
    def find_available_spot(self, vehicle: Vehicle) -> Optional[ParkingSpot]:
        """Find first available spot that fits the vehicle"""
        # Try to find the smallest suitable spot
        for spot_type in SpotType:
            for spot in self.spots[spot_type]:
                if spot.can_fit(vehicle):
                    return spot
        return None
    
    def get_display_info(self) -> dict:
        """Get floor availability for display"""
        return {
            "floor": self.floor_number,
            "compact_available": self.get_available_count(SpotType.COMPACT),
            "regular_available": self.get_available_count(SpotType.REGULAR),
            "large_available": self.get_available_count(SpotType.LARGE)
        }

import threading

class ParkingLot:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self, name: str, num_floors: int):
        if hasattr(self, '_initialized'):
            return
        
        self.name = name
        self.floors: List[Floor] = []
        self.active_tickets: Dict[str, ParkingTicket] = {}  # ticket_id -> ticket
        self.vehicle_to_spot: Dict[str, ParkingSpot] = {}   # license -> spot
        self._lock = threading.Lock()
        self._initialized = True
        
        # Initialize floors
        for i in range(num_floors):
            self.floors.append(Floor(i + 1))
    
    def add_spots(self, floor_number: int, spot_type: SpotType, count: int):
        """Add parking spots to a floor"""
        floor = self.floors[floor_number - 1]
        for i in range(count):
            spot_id = f"F{floor_number}-{spot_type.name[0]}{i+1}"
            spot = ParkingSpot(spot_id, floor_number, spot_type)
            floor.add_spot(spot)
    
    def park_vehicle(self, vehicle: Vehicle) -> Optional[ParkingTicket]:
        """Park a vehicle and return ticket"""
        with self._lock:
            # Check if vehicle already parked
            if vehicle.license_plate in self.vehicle_to_spot:
                raise ValueError("Vehicle already parked")
            
            # Find available spot
            spot = self._find_available_spot(vehicle)
            if spot is None:
                return None  # No spot available
            
            # Assign vehicle to spot
            spot.assign_vehicle(vehicle)
            
            # Create ticket
            ticket = ParkingTicket.create(vehicle, spot)
            self.active_tickets[ticket.id] = ticket
            self.vehicle_to_spot[vehicle.license_plate] = spot
            
            return ticket
    
    def unpark_vehicle(self, ticket_id: str) -> Optional[float]:
        """Unpark vehicle and return fee"""
        with self._lock:
            ticket = self.active_tickets.get(ticket_id)
            if ticket is None or ticket.status != TicketStatus.ACTIVE:
                return None
            
            # Get spot and vehicle
            spot = self.vehicle_to_spot.get(ticket.license_plate)
            if spot is None:
                return None
            
            vehicle = spot.remove_vehicle()
            
            # Calculate fee
            fee = ticket.calculate_fee(vehicle.vehicle_type)
            ticket.status = TicketStatus.PAID
            
            # Cleanup
            del self.vehicle_to_spot[ticket.license_plate]
            
            return fee
    
    def _find_available_spot(self, vehicle: Vehicle) -> Optional[ParkingSpot]:
        """Find nearest available spot for vehicle"""
        for floor in self.floors:
            spot = floor.find_available_spot(vehicle)
            if spot:
                return spot
        return None
    
    def get_availability(self) -> List[dict]:
        """Get availability info for all floors"""
        return [floor.get_display_info() for floor in self.floors]