Lobster Tamagotchi Companion Bot

#!/usr/bin/env python3
"""
ClawdBot Table Buddy — entry point
Raspberry Pi Zero 2W

Module layout
─────────────
  main.py        ← this file: boot, threads, glue
  src/state.py   ← BotState dataclass + mood logic
  src/sensors.py ← Wi-Fi RSSI + INA219 battery
  src/display.py ← SSD1306 Yellow/Blue OLED (luma.oled SPI)
  src/power.py   ← GPIO, buttons, LED blink
  src/bot.py     ← Telegram handlers, GPT-4o, reminders

Hardware
────────
  SSD1306 Yellow/Blue 0.96" 128×64 SPI (7-pin)
      D0 (CLK)  → BCM11   D1 (MOSI) → BCM10
      CS        → BCM8    DC        → BCM25   RES → BCM27
  INA219 (I2C)  SDA → BCM2   SCL → BCM3
  Buttons (active-low, pull-up)
      FEED → BCM17   PLAY → BCM22   SLEEP → BCM5
  Status LED → BCM6 → 330 Ω → GND
  Power chain: USB-C → TP4056 Type-C → 18650 (holder)
               TP4056 OUT → MT3608 boost (3.7→5V)
               MT3608 VOUT → INA219 VIN+ → Pi 5V (GPIO pin 2)
"""

import os
import sys
import time
import asyncio
import logging
import threading

from dotenv import load_dotenv
load_dotenv()

# ── Logging ───────────────────────────────────────────────────────────────────
logging.basicConfig(
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    level=logging.INFO,
)
log = logging.getLogger("clawdbot.main")

# ── Environment ───────────────────────────────────────────────────────────────
TELEGRAM_TOKEN  = os.environ.get("TELEGRAM_TOKEN",  "")
OPENAI_API_KEY  = os.environ.get("OPENAI_API_KEY",  "")
ALLOWED_CHAT_ID = int(os.environ.get("ALLOWED_CHAT_ID", "0"))

if not TELEGRAM_TOKEN:
    log.error("TELEGRAM_TOKEN not set in .env — aborting.")
    sys.exit(1)

# ── Module imports (after env check) ─────────────────────────────────────────
from src.state   import state, STANDBY_TIMEOUT_S
from src.sensors import (init_ina219, get_wifi_rssi, rssi_to_bars,
                          get_battery_info)
from src.display import (oled, refresh, draw_active, draw_standby,
                          draw_hatch_step, _lock as _oled_lock)
from src.power   import gpio_setup, led_blink, gpio_cleanup
from src.bot     import init_bot

from PIL import Image

# ── Shared sensor cache (updated by sensor loop; read by bot.py) ──────────────
_last_wifi_bars: int  = 0
_last_bat:       dict = {"percent": -1, "charging": False, "available": False}


# ─────────────────────────────────────────────────────────────────────────────
# Hatch animation
# ─────────────────────────────────────────────────────────────────────────────
def hatch_animation():
    global _last_wifi_bars, _last_bat
    log.info("Hatch animation starting…")

    # Seed sensor readings for the status bar
    _last_wifi_bars = rssi_to_bars(get_wifi_rssi())
    _last_bat       = get_battery_info()

    steps = [
        (-1, "...zzzz..."),        # no egg yet
        (0,  "Something stirs!"),  # egg appears
        (1,  "*CRACK*"),           # first crack
        (2,  "I LIVE! SNAP!"),     # big crack → transitions to face
    ]

    for crack, label in steps:
        if crack == 2:
            # Final step: show the happy active face
            img = draw_active("happy", "I LIVE! SNAP!",
                              _last_wifi_bars, _last_bat)
            with _oled_lock:
                oled.display(img)
            led_blink(3, on_ms=200)
            time.sleep(2)
        else:
            img = draw_hatch_step(crack, label, _last_wifi_bars, _last_bat)
            with _oled_lock:
                oled.display(img)
            led_blink(1)
            time.sleep(1.5)

    state.hatched = True
    log.info("Hatch complete.")


# ─────────────────────────────────────────────────────────────────────────────
# Background threads
# ─────────────────────────────────────────────────────────────────────────────

# ── Sensor poll (Wi-Fi + battery, every 15 s) ─────────────────────────────────
def _sensor_loop():
    global _last_wifi_bars, _last_bat
    while True:
        time.sleep(15)
        rssi            = get_wifi_rssi()
        _last_wifi_bars = rssi_to_bars(rssi)
        _last_bat       = get_battery_info()
        refresh(state.mood, "", _last_wifi_bars, _last_bat)
        log.debug("Sensor poll → bars=%d bat_pct=%s",
                  _last_wifi_bars, _last_bat.get("percent"))


# ── Standby loop (inactivity check + blink animation) ─────────────────────────
def _standby_loop():
    BLINK_OPEN  = 2.7
    BLINK_CLOSE = 0.3
    blink_phase = True
    blink_timer = time.time()

    while True:
        time.sleep(0.1)
        idle = time.time() - state.last_activity

        if not state.standby:
            if idle >= STANDBY_TIMEOUT_S and state.hatched:
                state.standby = True
                blink_phase   = True
                blink_timer   = time.time()
                log.info("Standby: ENTER (idle=%.0fs)", idle)
                with _oled_lock:
                    try:
                        img = draw_standby(state.mood,
                                           _last_wifi_bars, _last_bat,
                                           blink_phase=True)
                        oled.display(img)
                    except Exception as exc:
                        log.warning("Standby enter error: %s", exc)
        else:
            elapsed   = time.time() - blink_timer
            threshold = BLINK_OPEN if blink_phase else BLINK_CLOSE
            if elapsed >= threshold:
                blink_phase = not blink_phase
                blink_timer = time.time()
                with _oled_lock:
                    try:
                        img = draw_standby(state.mood,
                                           _last_wifi_bars, _last_bat,
                                           blink_phase=blink_phase)
                        oled.display(img)
                    except Exception as exc:
                        log.warning("Standby blink error: %s", exc)


# ── Care loop (mood decay + Telegram nags, every 60 s) ────────────────────────
def _care_loop():
    from src.bot import send_cranky_nag, send_low_battery_alert
    global _last_bat
    nag_cooldown = 0
    lbo_alerted  = False

    while True:
        time.sleep(60)
        state.tick()
        _last_bat = get_battery_info()
        refresh(state.mood, "", _last_wifi_bars, _last_bat)
        led_blink(1)

        # Low-battery alert
        if _last_bat.get("low") and not lbo_alerted:
            lbo_alerted = True
            led_blink(5, on_ms=80, off_ms=80)
            send_low_battery_alert(_last_bat["voltage"])
        elif not _last_bat.get("low"):
            lbo_alerted = False

        # Charging log
        if _last_bat.get("charging"):
            log.info("TP4056: USB-C charging — %.2fV @ %.0fmA",
                     _last_bat["voltage"], _last_bat["current"])

        # Cranky nag
        if state.mood == "cranky" and nag_cooldown <= 0:
            send_cranky_nag()
            nag_cooldown = 10
        else:
            nag_cooldown = max(0, nag_cooldown - 1)


# ── Button poll (50 ms debounce) ───────────────────────────────────────────────
def _button_loop():
    import RPi.GPIO as GPIO
    from src.power import PIN_BTN_FEED, PIN_BTN_PLAY, PIN_BTN_SLEEP
    last = {PIN_BTN_FEED: 1, PIN_BTN_PLAY: 1, PIN_BTN_SLEEP: 1}
    actions = {
        PIN_BTN_FEED:  state.feed,
        PIN_BTN_PLAY:  state.play,
        PIN_BTN_SLEEP: state.sleep,
    }
    while True:
        time.sleep(0.05)
        for pin, action in actions.items():
            v = GPIO.input(pin)
            if v == 0 and last[pin] == 1:   # falling edge = press
                action()
                refresh(state.mood, "", _last_wifi_bars, _last_bat)
                led_blink(1)
                log.info("Button BCM%d → mood=%s", pin, state.mood)
            last[pin] = v


# ─────────────────────────────────────────────────────────────────────────────
# Main
# ─────────────────────────────────────────────────────────────────────────────
async def main():
    loop = asyncio.get_running_loop()

    # Hardware init
    gpio_setup()
    init_ina219()
    hatch_animation()

    # Start background threads
    for target in (_sensor_loop, _standby_loop, _care_loop, _button_loop):
        threading.Thread(target=target, daemon=True).start()

    # Build and run the Telegram bot (blocks here via run_polling)
    app = init_bot(
        telegram_token  = TELEGRAM_TOKEN,
        openai_key      = OPENAI_API_KEY,
        allowed_chat_id = ALLOWED_CHAT_ID,
        loop            = loop,
    )

    log.info("ClawdBot online — polling Telegram…")
    refresh(state.mood, "Waiting for Telegram",
            _last_wifi_bars, _last_bat, force_active=True)

    await app.run_polling(allowed_updates=["message"])


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        log.info("Shutting down.")
    finally:
        try:
            oled.cleanup()
        except Exception:
            pass
        gpio_cleanup()