OOP Python: Object-Oriented Programming untuk IoT

"""
Singleton Pattern untuk MQTT Manager
BeebaneLabs - https://beebanelabs.pages.dev
"""


class MQTTManager:
    """Singleton — hanya satu instance yang boleh ada."""

    _instance = None
    _initialized = False

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self, broker="localhost", port=1883):
        if MQTTManager._initialized:
            return
        self.broker = broker
        self.port = port
        self._connected = False
        self._subscribers = {}
        MQTTManager._initialized = True
        print(f"[MQTT] Manager dibuat — broker: {broker}:{port}")

    def connect(self):
        self._connected = True
        print(f"[MQTT] Terhubung ke {self.broker}:{self.port}")

    def subscribe(self, topic, callback):
        self._subscribers[topic] = callback
        print(f"[MQTT] Subscribe: {topic}")


# Semua variabel ini menunjuk ke INSTANCE YANG SAMA
mqtt1 = MQTTManager("192.168.1.10", 1883)
mqtt2 = MQTTManager("broker-lain.com", 8883)  # Parameter diabaikan!

print(f"mqtt1 is mqtt2: {mqtt1 is mqtt2}")  # True
print(f"Broker: {mqtt2.broker}")  # 192.168.1.10 (tetap dari inisialisasi pertama)

"""
Observer Pattern untuk Event-Driven IoT
BeebaneLabs - https://beebanelabs.pages.dev
"""


class EventEmitter:
    """Base class untuk event system."""

    def __init__(self):
        self._listeners = {}

    def on(self, event_name, callback):
        """Mendaftarkan listener untuk event tertentu."""
        if event_name not in self._listeners:
            self._listeners[event_name] = []
        self._listeners[event_name].append(callback)

    def emit(self, event_name, data=None):
        """Memancarkan event ke semua listener."""
        if event_name in self._listeners:
            for callback in self._listeners[event_name]:
                callback(data)


class SensorMonitor(EventEmitter):
    """Sensor yang memancarkan event saat threshold terlampaui."""

    def __init__(self, nama, threshold_high=None, threshold_low=None):
        super().__init__()
        self.nama = nama
        self.threshold_high = threshold_high
        self.threshold_low = threshold_low
        self._nilai_terakhir = None

    def update(self, nilai):
        self._nilai_terakhir = nilai

        if self.threshold_high and nilai > self.threshold_high:
            self.emit("threshold_high", {
                "sensor": self.nama,
                "nilai": nilai,
                "threshold": self.threshold_high
            })

        if self.threshold_low and nilai < self.threshold_low:
            self.emit("threshold_low", {
                "sensor": self.nama,
                "nilai": nilai,
                "threshold": self.threshold_low
            })

        self.emit("data_update", {"sensor": self.nama, "nilai": nilai})


# --- Penggunaan ---
monitor_suhu = SensorMonitor("Suhu", threshold_high=35, threshold_low=15)
monitor_gas = SensorMonitor("Gas MQ-135", threshold_high=1000)

# Daftarkan listener
def alert_handler(data):
    print(f"🚨 ALERT: {data['sensor']} = {data['nilai']} (threshold: {data['threshold']})")

def log_handler(data):
    print(f"📝 LOG: {data['sensor']} → {data['nilai']}")

def dashboard_handler(data):
    print(f"📊 DASHBOARD: Update {data['sensor']}: {data['nilai']}")

monitor_suhu.on("threshold_high", alert_handler)
monitor_suhu.on("threshold_low", alert_handler)
monitor_suhu.on("data_update", log_handler)
monitor_suhu.on("data_update", dashboard_handler)
monitor_gas.on("threshold_high", alert_handler)

# Simulasi update
monitor_suhu.update(28)     # Normal
monitor_suhu.update(36.5)   # Threshold high triggered!
monitor_suhu.update(12)     # Threshold low triggered!
monitor_gas.update(1500)    # Gas bahaya!

"""
Factory Pattern untuk Membuat Sensor dari Config
BeebaneLabs - https://beebanelabs.pages.dev
"""

import json


class SensorFactory:
    """Factory untuk membuat object sensor dari konfigurasi."""

    _registry = {}

    @classmethod
    def register(cls, tipe, class_ref):
        """Mendaftarkan tipe sensor ke factory."""
        cls._registry[tipe] = class_ref

    @classmethod
    def buat(cls, config):
        """Membuat sensor dari dict konfigurasi."""
        tipe = config.get("tipe")
        if tipe not in cls._registry:
            raise ValueError(f"Tipe sensor tidak dikenal: {tipe}")

        sensor_class = cls._registry[tipe]
        return sensor_class(**{k: v for k, v in config.items() if k != "tipe"})

    @classmethod
    def buat_dari_file(cls, filepath):
        """Membuat semua sensor dari file JSON config."""
        with open(filepath, "r") as f:
            configs = json.load(f)

        sensors = []
        for cfg in configs:
            sensor = cls.buat(cfg)
            sensors.append(sensor)
        return sensors


# Register semua tipe sensor
# SensorFactory.register("dht22", SensorDHT)
# SensorFactory.register("ultrasonik", SensorUltrasonik)
# SensorFactory.register("ldr", SensorLDR)

# Contoh config JSON:
# [
#   {"tipe": "dht22", "nama": "Suhu Ruang", "pin": 4},
#   {"tipe": "ultrasonik", "nama": "Jarak Tangki", "pin_trigger": 17, "pin_echo": 27},
#   {"tipe": "ldr", "nama": "Cahaya Taman", "pin": 22}
# ]