স্ট্রাকচারাল প্যাটার্ন — Adapter, Decorator, Facade

# Adapter pattern -- ধারণা: LegacyPrinter-এর ইন্টারফেস client কোড যা আশা করে তার
# সাথে মেলে না -- PrinterAdapter মাঝখানে দাঁড়িয়ে ইন্টারফেস "অনুবাদ" করে দেয়,
# LegacyPrinter-এর একটি লাইন কোডও না বদলিয়ে।

class LegacyPrinter:
    """একটি পুরনো/থার্ড-পার্টি ক্লাস -- ইন্টারফেস client-এর প্রত্যাশার সাথে মেলে না।"""
    def print_text(self, s):
        return f"[LegacyPrinter] {s}"

class Printer:
    """Client কোড এই ইন্টারফেস আশা করে -- শুধু একটি .print(document) মেথড।"""
    def print(self, document):
        raise NotImplementedError

class PrinterAdapter(Printer):
    """LegacyPrinter-কে client-এর প্রত্যাশিত .print() ইন্টারফেসে অনুবাদ করে।"""
    def __init__(self, legacy_printer):
        self.legacy_printer = legacy_printer

    def print(self, document):
        return self.legacy_printer.print_text(document)

def client_code(printer: Printer, document: str):
    # client_code শুধু Printer ইন্টারফেস চেনে -- LegacyPrinter সম্পর্কে কিছুই জানে না।
    return printer.print(document)

legacy = LegacyPrinter()
adapter = PrinterAdapter(legacy)
print(client_code(adapter, "রিপোর্ট.pdf"))

# Decorator pattern -- প্রতিটি ডেকোরেটর একটি coffee-সদৃশ অবজেক্ট wrap করে,
# একই ইন্টারফেস রাখে (.cost(), .description()), এবং wrapped অবজেক্টের ফলাফলের
# উপর নিজের অংশ যোগ করে -- একাধিক ডেকোরেটর একে অপরের উপর স্ট্যাক করা যায়।

class Coffee:
    def cost(self):
        return 50

    def description(self):
        return "কফি"

class CoffeeDecorator(Coffee):
    def __init__(self, wrapped):
        self.wrapped = wrapped

    def cost(self):
        return self.wrapped.cost()

    def description(self):
        return self.wrapped.description()

class MilkDecorator(CoffeeDecorator):
    def cost(self):
        return self.wrapped.cost() + 15

    def description(self):
        return self.wrapped.description() + " + দুধ"

class SugarDecorator(CoffeeDecorator):
    def cost(self):
        return self.wrapped.cost() + 5

    def description(self):
        return self.wrapped.description() + " + চিনি"

base = Coffee()
with_milk = MilkDecorator(base)
with_milk_sugar = SugarDecorator(with_milk)

print(f"{base.description()}: {base.cost()} টাকা")
print(f"{with_milk.description()}: {with_milk.cost()} টাকা")
print(f"{with_milk_sugar.description()}: {with_milk_sugar.cost()} টাকা")

# Facade pattern -- ComputerFacade জটিল সাবসিস্টেমের (CPU, Memory, Disk) মেথডগুলো
# সঠিক ক্রমে নিজে কল করে -- client শুধু .start() কল করে, ভেতরের জটিলতা জানতেও হয় না।

class CPU:
    def freeze(self):
        return "CPU: ফ্রিজ করা হলো"

    def jump(self, position):
        return f"CPU: অবস্থান {position}-এ জাম্প করা হলো"

    def execute(self):
        return "CPU: এক্সিকিউশন শুরু হলো"

class Memory:
    def load(self, position, data):
        return f"Memory: অবস্থান {position}-এ '{data}' লোড করা হলো"

class Disk:
    def read(self, sector, size):
        return f"Disk: সেক্টর {sector} থেকে {size} বাইট পড়া হলো"

class ComputerFacade:
    """একটি সরল .start() ইন্টারফেসের পেছনে CPU, Memory, Disk-কে সমন্বয় করে।"""
    def __init__(self):
        self.cpu = CPU()
        self.memory = Memory()
        self.disk = Disk()

    def start(self):
        steps = [self.cpu.freeze()]
        boot_data = self.disk.read(sector=0, size=512)
        steps.append(boot_data)
        steps.append(self.memory.load(position=0, data="বুট-লোডার"))
        steps.append(self.cpu.jump(position=0))
        steps.append(self.cpu.execute())
        return steps

computer = ComputerFacade()
for step in computer.start():
    print(step)