# -*- coding: utf-8 -*-
from __future__ import annotations

__title__   = "analog_sensors"
__author__  = 'Mehmet Karatay & "Saraswati" (ChatGPT)'
__purpose__ = "MCP3008 üzerinden okunan analog sensörler için basit hub"
__version__ = "0.1.0"
__date__    = "2025-11-23"

"""
ebuild/core/analog_sensors.py

Amaç
-----
- MCP3008 ADC üzerinden okunan analog kanalları tek noktada toplamak.
- Basınç, gaz, yağmur ve LDR için basit arayüz sağlamak.

Notlar
------
- Şimdilik çok sade tutuldu; istersen ileride eşik, durum (state) ve alarm
  mantığını genişletebilirsin.
"""

from typing import Dict, Any, Optional


class _SimpleChannelState:
    """
    Tek bir analog kanal için durum tutucu.
    """
    def __init__(self, name: str) -> None:
        self.name = name
        self.state: Optional[str] = None
        self.last_raw: Optional[int] = None
        # Gaz için latched alarm gibi ek alanlar:
        self.latched_alarm: bool = False

    def update(self, raw: Optional[int]) -> None:
        self.last_raw = raw
        # Şimdilik state hesaplamıyoruz; ileride eşiğe göre doldurulabilir.
        self.state = None


class AnalogSensorsHub:
    """
    MCP3008 ADC üzerinden basınç, gaz, yağmur, LDR gibi sensörleri yöneten hub.

    Beklenti:
    ---------
    adc nesnesinin en azından şu fonksiyonu sağlaması:
        - read_channel(ch: int) -> int  (0..1023 arası değer)
    """

    def __init__(self, adc) -> None:
        self.adc = adc

        # Her kanal için basit state objeleri
        self.pressure = _SimpleChannelState("pressure")
        self.gas      = _SimpleChannelState("gas")
        self.rain     = _SimpleChannelState("rain")
        self.ldr      = _SimpleChannelState("ldr")

        # Kanalları sabitliyoruz; istersen config'ten de alabilirsin.
        self.pressure_ch = 0
        self.gas_ch      = 1
        self.rain_ch     = 2
        self.ldr_ch      = 3

    def _safe_read(self, ch: int) -> Optional[int]:
        """
        ADC'den güvenli okuma. Hata olursa None döndürür.
        """
        if self.adc is None:
            return None

        try:
            val = self.adc.read_channel(ch)
            return int(val)
        except Exception:
            return None

    def update_all(self) -> Dict[str, Any]:
        """
        Tüm kanalları okuyup state nesnelerini günceller.

        Dönüş:
            {
              "pressure": <raw or None>,
              "gas": <raw or None>,
              "rain": <raw or None>,
              "ldr": <raw or None>,
            }
        """
        vals: Dict[str, Any] = {}

        p_raw = self._safe_read(self.pressure_ch)
        g_raw = self._safe_read(self.gas_ch)
        r_raw = self._safe_read(self.rain_ch)
        l_raw = self._safe_read(self.ldr_ch)

        self.pressure.update(p_raw)
        self.gas.update(g_raw)
        self.rain.update(r_raw)
        self.ldr.update(l_raw)

        vals["pressure"] = p_raw
        vals["gas"]      = g_raw
        vals["rain"]     = r_raw
        vals["ldr"]      = l_raw

        return vals


if __name__ == "__main__":
    # Basit demo: sahte ADC ile
    class DummyADC:
        def read_channel(self, ch: int) -> int:
            return 512 + ch  # uydurma değerler

    hub = AnalogSensorsHub(DummyADC())
    values = hub.update_all()
    print("AnalogSensorsHub demo:", values)
    print("Gas latched_alarm:", hub.gas.latched_alarm)