ক্লাসিক সিনক্রোনাইজেশন: প্রডিউসার-কনজিউমার

class Semaphore:  # L18-এর ক্লাস, অপরিবর্তিত
    def __init__(self, initial_value):
        self.value = initial_value
        self.waiting = []

    def wait(self, name):
        self.value -= 1
        if self.value < 0:
            self.waiting.append(name)
            print(f"    {name}: wait() -> value={self.value} (BLOCKED, waiting={self.waiting})")
            return False
        print(f"    {name}: wait() -> value={self.value} (proceed)")
        return True

    def signal(self, name):
        self.value += 1
        woken = None
        if self.value <= 0 and self.waiting:
            woken = self.waiting.pop(0)
            print(f"    {name}: signal() -> value={self.value} (wakes {woken})")
        else:
            print(f"    {name}: signal() -> value={self.value}")
        return woken


BUFFER_SIZE = 2
buffer = []

empty = Semaphore(BUFFER_SIZE)  # ফাঁকা স্লট
full = Semaphore(0)             # ভরা স্লট
mutex = Semaphore(1)            # বাফার প্রোটেকশন

pending_item = [None]  # ব্লকড হওয়া producer-এর আইটেম মনে রাখার জন্য

def produce(item):
    print(f"\nProducer -> '{item}' produce করার চেষ্টা")
    ok = empty.wait("Producer")
    if not ok:
        pending_item[0] = item
        print(f"  Producer blocked -- বাফার পূর্ণ, '{item}' পেন্ডিং")
        return
    mutex.wait("Producer")
    buffer.append(item)
    print(f"  বাফারে যোগ হলো: {buffer}")
    mutex.signal("Producer")
    woken = full.signal("Producer")
    if woken:
        resume_consumer_after_wakeup()

def resume_consumer_after_wakeup():
    print("  [জাগ্রত হওয়া Consumer তার বাকি কাজ সম্পন্ন করছে]")
    mutex.wait("Consumer(resume)")
    item = buffer.pop(0)
    print(f"    বাফার থেকে সরানো হলো: {item}, বাফার এখন: {buffer}")
    mutex.signal("Consumer(resume)")
    empty.signal("Consumer(resume)")

def consume():
    print("\nConsumer -> আইটেম consume করার চেষ্টা")
    ok = full.wait("Consumer")
    if not ok:
        print("  Consumer blocked -- বাফার খালি")
        return
    mutex.wait("Consumer")
    item = buffer.pop(0)
    print(f"  বাফার থেকে সরানো হলো: {item}, বাফার এখন: {buffer}")
    mutex.signal("Consumer")
    woken = empty.signal("Consumer")
    if woken:
        resume_producer_after_wakeup()

def resume_producer_after_wakeup():
    print("  [জাগ্রত হওয়া Producer তার বাকি কাজ সম্পন্ন করছে]")
    item = pending_item[0]
    mutex.wait("Producer(resume)")
    buffer.append(item)
    print(f"    বাফারে যোগ হলো: {buffer}")
    mutex.signal("Producer(resume)")
    full.signal("Producer(resume)")


produce("A")               # খালি বাফার -> সরাসরি সফল
produce("B")                # বাফার এখন পূর্ণ (সাইজ ২)
produce("C")                 # বাফার পূর্ণ -> BLOCKED
consume()                    # A সরায়, এবং ব্লকড Producer("C") কে জাগায়
consume()                    # B সরায়
consume()                    # C সরায় (এখন বাফার আবার খালি)
consume()                    # বাফার খালি -> BLOCKED
produce("D")                  # ব্লকড Consumer কে জাগায়

print("\nফাইনাল বাফার:", buffer)
print("empty.value:", empty.value, " full.value:", full.value, " mutex.value:", mutex.value)