1class AuctionObserver(ABC):
2    @abstractmethod
3    def on_update(self, auction: 'Auction', message: str):
4        pass

1class User(AuctionObserver):
2    def __init__(self, name: str):
3        self.id = str(uuid.uuid4())
4        self.name = name
5
6    def get_id(self) -> str:
7        return self.id
8
9    def get_name(self) -> str:
10        return self.name
11
12    def on_update(self, auction: 'Auction', message: str):
13        print(f"--- Notification for {self.name} ---")
14        print(f"Auction: {auction.get_item_name()}")
15        print(f"Message: {message}")
16        print("---------------------------\n")

1class AuctionState(Enum):
2    PENDING = "PENDING"
3    ACTIVE = "ACTIVE"
4    CLOSED = "CLOSED"

1class Bid:
2    def __init__(self, bidder: User, amount: Decimal):
3        self.bidder = bidder
4        self.amount = amount
5        self.timestamp = datetime.now()
6
7    def get_bidder(self) -> User:
8        return self.bidder
9
10    def get_amount(self) -> Decimal:
11        return self.amount
12
13    def get_timestamp(self) -> datetime:
14        return self.timestamp
15
16    def __lt__(self, other: 'Bid') -> bool:
17        if self.amount != other.amount:
18            return self.amount < other.amount
19        return self.timestamp > other.timestamp
20
21    def __eq__(self, other: 'Bid') -> bool:
22        return self.amount == other.amount and self.timestamp == other.timestamp
23
24    def __le__(self, other: 'Bid') -> bool:
25        return self < other or self == other
26
27    def __gt__(self, other: 'Bid') -> bool:
28        return not self <= other
29
30    def __ge__(self, other: 'Bid') -> bool:
31        return not self < other
32
33    def __ne__(self, other: 'Bid') -> bool:
34        return not self == other
35
36    def __str__(self) -> str:
37        return f"Bidder: {self.bidder.get_name()}, Amount: {self.amount:.2f}, Time: {self.timestamp}"

1class Auction:
2    def __init__(self, item_name: str, description: str, starting_price: Decimal, end_time: datetime):
3        self.id = str(uuid.uuid4())
4        self.item_name = item_name
5        self.description = description
6        self.starting_price = starting_price
7        self.end_time = end_time
8        self.bids: List[Bid] = []
9        self.observers: Set[AuctionObserver] = set()
10        self.state = AuctionState.ACTIVE
11        self.winning_bid: Optional[Bid] = None
12        self._lock = threading.RLock()
13
14    def place_bid(self, bidder: User, amount: Decimal):
15        with self._lock:
16            if self.state != AuctionState.ACTIVE:
17                raise Exception("Auction is not active.")
18            if datetime.now() > self.end_time:
19                self.end_auction()
20                raise Exception("Auction has already ended.")
21
22            highest_bid = self.get_highest_bid()
23            current_max_amount = self.starting_price if highest_bid is None else highest_bid.get_amount()
24
25            if amount <= current_max_amount:
26                raise ValueError("Bid must be higher than the current highest bid.")
27
28            previous_highest_bidder = highest_bid.get_bidder() if highest_bid is not None else None
29
30            new_bid = Bid(bidder, amount)
31            self.bids.append(new_bid)
32            self.add_observer(bidder)
33
34            print(f"SUCCESS: {bidder.get_name()} placed a bid of ${amount:.2f} on '{self.item_name}'.")
35
36            if previous_highest_bidder is not None and previous_highest_bidder != bidder:
37                self.notify_observer(previous_highest_bidder, 
38                    f"You have been outbid on '{self.item_name}'! The new highest bid is ${amount:.2f}.")
39
40    def end_auction(self):
41        with self._lock:
42            if self.state != AuctionState.ACTIVE:
43                return
44
45            self.state = AuctionState.CLOSED
46            self.winning_bid = self.get_highest_bid()
47
48            if self.winning_bid is not None:
49                end_message = f"Auction for '{self.item_name}' has ended. Winner is {self.winning_bid.get_bidder().get_name()} with a bid of ${self.winning_bid.get_amount():.2f}!"
50            else:
51                end_message = f"Auction for '{self.item_name}' has ended. There were no bids."
52
53            print(f"\n{end_message.upper()}")
54            self.notify_all_observers(end_message)
55
56    def get_highest_bid(self) -> Optional[Bid]:
57        if not self.bids:
58            return None
59        return max(self.bids)
60
61    def is_active(self) -> bool:
62        return self.state == AuctionState.ACTIVE
63
64    def add_observer(self, observer: AuctionObserver):
65        self.observers.add(observer)
66
67    def notify_all_observers(self, message: str):
68        for observer in self.observers:
69            observer.on_update(self, message)
70
71    def notify_observer(self, observer: AuctionObserver, message: str):
72        observer.on_update(self, message)
73
74    def get_id(self) -> str:
75        return self.id
76
77    def get_item_name(self) -> str:
78        return self.item_name
79
80    def get_bid_history(self) -> List[Bid]:
81        return self.bids.copy()
82
83    def get_state(self) -> AuctionState:
84        return self.state
85
86    def get_winning_bid(self) -> Optional[Bid]:
87        return self.winning_bid

1class AuctionService:
2    _instance = None
3    _lock = threading.Lock()
4
5    def __init__(self):
6        if AuctionService._instance is not None:
7            raise Exception("This class is a singleton!")
8        self.users: Dict[str, User] = {}
9        self.auctions: Dict[str, Auction] = {}
10        self.scheduler = ThreadPoolExecutor(max_workers=10)
11        self._shutdown = False
12
13    @staticmethod
14    def get_instance():
15        if AuctionService._instance is None:
16            with AuctionService._lock:
17                if AuctionService._instance is None:
18                    AuctionService._instance = AuctionService()
19        return AuctionService._instance
20
21    def create_user(self, name: str) -> User:
22        user = User(name)
23        self.users[user.get_id()] = user
24        return user
25
26    def get_user(self, user_id: str) -> User:
27        return self.users[user_id]
28
29    def create_auction(self, item_name: str, description: str, starting_price: Decimal, end_time: datetime) -> Auction:
30        auction = Auction(item_name, description, starting_price, end_time)
31        self.auctions[auction.get_id()] = auction
32
33        delay = (end_time - datetime.now()).total_seconds()
34        if delay > 0:
35            self.scheduler.submit(self._scheduled_end_auction, auction.get_id(), delay)
36
37        print(f"New auction created for '{item_name}' (ID: {auction.get_id()}), ending at {end_time}.")
38        return auction
39
40    def _scheduled_end_auction(self, auction_id: str, delay: float):
41        time.sleep(delay)
42        if not self._shutdown:
43            self.end_auction(auction_id)
44
45    def view_active_auctions(self) -> List[Auction]:
46        return [auction for auction in self.auctions.values() if auction.is_active()]
47
48    def place_bid(self, auction_id: str, bidder_id: str, amount: Decimal):
49        auction = self.get_auction(auction_id)
50        auction.place_bid(self.users[bidder_id], amount)
51
52    def end_auction(self, auction_id: str):
53        auction = self.get_auction(auction_id)
54        auction.end_auction()
55
56    def get_auction(self, auction_id: str) -> Auction:
57        auction = self.auctions.get(auction_id)
58        if auction is None:
59            raise KeyError(f"Auction with ID {auction_id} not found.")
60        return auction
61
62    def shutdown(self):
63        self._shutdown = True
64        self.scheduler.shutdown(wait=True)

1class AuctionSystemDemo:
2    @staticmethod
3    def main():
4        auction_service = AuctionService.get_instance()
5
6        alice = auction_service.create_user("Alice")
7        bob = auction_service.create_user("Bob")
8        carol = auction_service.create_user("Carol")
9
10        print("=============================================")
11        print("        Online Auction System Demo           ")
12        print("=============================================")
13
14        end_time = datetime.now() + timedelta(seconds=10)
15        laptop_auction = auction_service.create_auction(
16            "Vintage Laptop",
17            "A rare 1990s laptop, in working condition.",
18            Decimal("100.00"),
19            end_time
20        )
21        print()
22
23        try:
24            auction_service.place_bid(laptop_auction.get_id(), alice.get_id(), Decimal("110.00"))
25            time.sleep(0.5)
26
27            auction_service.place_bid(laptop_auction.get_id(), bob.get_id(), Decimal("120.00"))
28            time.sleep(0.5)
29
30            auction_service.place_bid(laptop_auction.get_id(), carol.get_id(), Decimal("125.00"))
31            time.sleep(0.5)
32
33            auction_service.place_bid(laptop_auction.get_id(), alice.get_id(), Decimal("150.00"))
34
35            print("\n--- Waiting for auction to end automatically... ---")
36            time.sleep(2)
37        except Exception as e:
38            print(f"An error occurred during bidding: {e}")
39
40        print("\n--- Post-Auction Information ---")
41        ended_auction = auction_service.get_auction(laptop_auction.get_id())
42
43        if ended_auction.get_winning_bid() is not None:
44            print(f"Final Winner: {ended_auction.get_winning_bid().get_bidder().get_name()}")
45            print(f"Winning Price: ${ended_auction.get_winning_bid().get_amount():.2f}")
46        else:
47            print("The auction ended with no winner.")
48
49        print("\nFull Bid History:")
50        for bid in ended_auction.get_bid_history():
51            print(bid)
52
53        print("\n--- Attempting to bid on an ended auction ---")
54        try:
55            auction_service.place_bid(laptop_auction.get_id(), bob.get_id(), Decimal("200.00"))
56        except Exception as e:
57            print(f"CAUGHT EXPECTED ERROR: {e}")
58
59        auction_service.shutdown()
60
61
62if __name__ == "__main__":
63    AuctionSystemDemo.main()