JARVIS/display.py

#!/usr/bin/env python3
"""
JARVIS Display
──────────────
Renders the JARVIS UI overlay via X11.

  Development:   python display.py
  Kiosk:         DISPLAY=:0 python display.py --fullscreen

Weather via Open-Meteo (free, no API key).
Cycles through _LOCATIONS every 5 seconds.
"""

import os
import json
import math
import threading
import time as _time
import argparse
import urllib.request
import urllib.parse
from datetime import datetime

_parser = argparse.ArgumentParser(description='JARVIS display', add_help=True)
_parser.add_argument('--fullscreen', '-fs', action='store_true',
                     help='Run fullscreen under X11/Wayland')
_parser.add_argument('--width',  type=int, default=1280,
                     help='Screen width  (default 1280)')
_parser.add_argument('--height', type=int, default=800,
                     help='Screen height (default 800)')
_args, _ = _parser.parse_known_args()

import pygame

# ── Locations to cycle through ────────────────────────────────────────────────
_LOCATIONS = ['Poole', 'Portsmouth', 'Besancon', 'Paris', 'Gorinchem']

# ── Colour palette ───────────────────────────────────────────────────────────
BLACK    = (  0,   0,   0)
WHITE    = (255, 255, 255)
GRAY     = (160, 160, 160)
DIM_GRAY = ( 80,  80,  80)
WIRE_COL = ( 58,  58,  58)
WIRE_EYE = ( 95,  95,  95)

# ── WMO weather codes (Open-Meteo) ────────────────────────────────────────────
_WMO = {
    0: 'Clear sky', 1: 'Mainly clear', 2: 'Partly cloudy', 3: 'Overcast',
    45: 'Fog', 48: 'Freezing fog',
    51: 'Light drizzle', 53: 'Drizzle', 55: 'Heavy drizzle',
    61: 'Light rain', 63: 'Rain', 65: 'Heavy rain',
    71: 'Light snow', 73: 'Snow', 75: 'Heavy snow', 77: 'Snow grains',
    80: 'Light showers', 81: 'Showers', 82: 'Heavy showers',
    85: 'Snow showers', 86: 'Heavy snow showers',
    95: 'Thunderstorm', 96: 'Thunderstorm + hail', 99: 'Thunderstorm + hail',
}

# ── Weather state — one dict per location, updated by background thread ───────
_weather_all: list[dict] = []
_weather_lock = threading.Lock()


def _geocode(city: str) -> tuple[float, float, str]:
    url = ('https://geocoding-api.open-meteo.com/v1/search'
           f'?name={urllib.parse.quote(city)}&count=1&language=en&format=json')
    with urllib.request.urlopen(url, timeout=10) as r:
        data = json.loads(r.read())
    r = data['results'][0]
    return r['latitude'], r['longitude'], r['name']


def _fetch_one(lat: float, lon: float) -> dict:
    url = (
        'https://api.open-meteo.com/v1/forecast'
        f'?latitude={lat:.4f}&longitude={lon:.4f}'
        '&daily=weather_code,temperature_2m_max,temperature_2m_min'
        '&hourly=temperature_2m,weather_code'
        '&timezone=auto'
        '&forecast_days=7'
    )
    with urllib.request.urlopen(url, timeout=10) as r:
        data = json.loads(r.read())

    daily  = data['daily']
    hourly = data['hourly']

    week = []
    for i, date_str in enumerate(daily['time']):
        d = datetime.strptime(date_str, '%Y-%m-%d')
        week.append({
            'day':  'Today' if i == 0 else d.strftime('%A'),
            'high': round(daily['temperature_2m_max'][i]),
            'low':  round(daily['temperature_2m_min'][i]),
            'desc': _WMO.get(daily['weather_code'][i], ''),
        })

    now   = datetime.now()
    hours = []
    for i, ts in enumerate(hourly['time']):
        if len(hours) >= 5:
            break
        t = datetime.strptime(ts, '%Y-%m-%dT%H:%M')
        if t <= now:
            continue
        hours.append({
            'label': t.strftime('%-I%p').lower(),
            'temp':  round(hourly['temperature_2m'][i]),
            'desc':  _WMO.get(hourly['weather_code'][i], ''),
        })

    return {'week': week, 'hours': hours}


def _weather_worker(locations: list[tuple[float, float, str]]) -> None:
    while True:
        fresh = []
        for lat, lon, name in locations:
            try:
                entry = _fetch_one(lat, lon)
            except Exception:
                entry = {'week': [], 'hours': []}
            entry['town'] = name
            fresh.append(entry)
        with _weather_lock:
            _weather_all.clear()
            _weather_all.extend(fresh)
        _time.sleep(1800)


# ── Wireframe face ────────────────────────────────────────────────────────────

def _hw(t: float, rx: float) -> float:
    if t <= 0.0:
        return rx * math.sqrt(max(0.0, 1.0 - t * t))
    return rx * math.sqrt(max(0.0, 1.0 - t * t)) * (1.0 - 0.30 * t)


def draw_wireframe_face(surface: pygame.Surface,
                        cx: int, cy: int, rx: float, ry: float) -> None:
    N_H, N_V, PTS = 13, 11, 40

    def sc(xf, t):
        w   = _hw(t, rx)
        bow = int(0.06 * w * (1.0 - t*t) * (1.0 - xf*xf))
        return (int(cx + xf*w), int(cy + t*ry) - bow)

    def draw(pts, col=WIRE_COL):
        if len(pts) >= 2:
            pygame.draw.lines(surface, col, False, pts, 1)

    t_vals = [-1.0 + 2.0*i/(PTS-1) for i in range(PTS)]
    draw([sc(-1.0, t) for t in t_vals])
    draw([sc( 1.0, t) for t in t_vals])
    pygame.draw.lines(surface, WIRE_COL, False, [sc(-1.0,-1.0), sc(1.0,-1.0)], 1)
    pygame.draw.lines(surface, WIRE_COL, False, [sc(-0.6,1.0), sc(0.0,1.02), sc(0.6,1.0)], 1)

    for i in range(1, N_H):
        t = -1.0 + 2.0*i/N_H
        draw([sc(-1.0 + 2.0*j/(PTS-1), t) for j in range(PTS)])
    for i in range(1, N_V):
        xf = -1.0 + 2.0*i/N_V
        draw([sc(xf, t) for t in t_vals])

    eye_t, eye_xf = -0.38, 0.35
    eye_w = _hw(eye_t, rx)
    e_rx  = int(eye_w * 0.24)
    e_ry  = int(ry * 0.09)
    for sign in (-1, +1):
        ecx = int(cx + sign * eye_xf * eye_w)
        ecy = int(cy + eye_t * ry)
        pts = [(int(ecx + e_rx*math.cos(2*math.pi*k/28)),
                int(ecy + e_ry*math.sin(2*math.pi*k/28))) for k in range(29)]
        pygame.draw.lines(surface, WIRE_EYE, True, pts, 1)

    inner  = int(eye_w * 0.12)
    e_btm  = int(cy + eye_t*ry) + e_ry
    nose_y = int(cy + 0.08*ry)
    nose_w = int(eye_w * 0.07)
    draw([(cx-inner, e_btm), (cx-nose_w, nose_y)])
    draw([(cx+inner, e_btm), (cx+nose_w, nose_y)])


# ── Clock ─────────────────────────────────────────────────────────────────────

def draw_clock(surface: pygame.Surface, fonts: dict, x: int, y: int) -> None:
    now    = datetime.now()
    t_surf = fonts['large'].render(now.strftime('%-H:%M'), True, WHITE)
    s_surf = fonts['small'].render(now.strftime('%S'), True, DIM_GRAY)
    surface.blit(fonts['small'].render(now.strftime('%A, %-d %B %Y'), True, GRAY), (x, y))
    ty = y + fonts['small'].get_height() + 4
    surface.blit(t_surf, (x, ty))
    surface.blit(s_surf, (x + t_surf.get_width() + 2,
                           ty + t_surf.get_height() - s_surf.get_height() - 8))


# ── Weather panel ─────────────────────────────────────────────────────────────

_WEATHER_COLS  = 5
_WEATHER_COL_W = 84


def draw_weather(surface: pygame.Surface, fonts: dict, x: int, y: int) -> None:
    with _weather_lock:
        all_data = list(_weather_all)

    th     = fonts['tiny'].get_height()
    row    = th + 2
    town_h = fonts['medium'].get_height()

    def _trunc(s, n=13):
        return s if len(s) <= n else s[:n-1] + '…'

    def _col(items, start_y, label_fn, row2_fn, row3_fn):
        for i, item in enumerate(items[:_WEATHER_COLS]):
            cx = x + i * _WEATHER_COL_W
            surface.blit(fonts['tiny'].render(label_fn(item), True, GRAY),     (cx, start_y))
            surface.blit(fonts['tiny'].render(row2_fn(item),  True, WHITE),    (cx, start_y + row))
            surface.blit(fonts['tiny'].render(row3_fn(item),  True, DIM_GRAY), (cx, start_y + 2*row))

    if not all_data:
        surface.blit(fonts['medium'].render('Weather loading…', True, DIM_GRAY), (x, y))
        return

    idx  = int(_time.time() / 5) % len(all_data)
    data = all_data[idx]
    week  = data.get('week',  [])
    hours = data.get('hours', [])
    town  = data.get('town',  '')

    # Town name
    surface.blit(fonts['medium'].render(town, True, GRAY), (x, y))

    # 5-day section
    _col(week,
         y + town_h + 4,
         lambda d: 'Today' if d['day'] == 'Today' else d['day'][:3],
         lambda d: f"{d['high']}°/{d['low']}°",
         lambda d: _trunc(d['desc']))

    # 5-hour section
    if hours:
        _col(hours,
             y + town_h + 4 + 3*row + 8,
             lambda h: h['label'],
             lambda h: f"{h['temp']}°",
             lambda h: _trunc(h['desc']))


# ── Font helper ───────────────────────────────────────────────────────────────

def _load_font(size: int, bold: bool = False) -> pygame.font.Font:
    for name in ('DejaVuSans', 'FreeSans', 'LiberationSans', 'Helvetica', 'Arial', None):
        try:
            f = pygame.font.SysFont(name, size, bold=bold)
            if f:
                return f
        except Exception:
            pass
    return pygame.font.Font(None, size)


# ── Main loop ─────────────────────────────────────────────────────────────────

def main() -> None:
    pygame.init()

    W, H = _args.width, _args.height

    if _args.fullscreen:
        screen = pygame.display.set_mode((W, H), pygame.FULLSCREEN | pygame.NOFRAME)
    else:
        screen = pygame.display.set_mode((W, H))
        pygame.display.set_caption('JARVIS')

    pygame.mouse.set_visible(False)

    fonts = {
        'large':  _load_font(38),
        'medium': _load_font(18),
        'small':  _load_font(13),
        'tiny':   _load_font(11),
    }

    face_rx = int(min(W, H) * 0.085)
    face_ry = int(min(W, H) * 0.100)
    face_cx = W // 2
    face_cy = int(face_ry * 1.2) + 8

    clock_block_h = fonts['small'].get_height() + 4 + fonts['large'].get_height()
    clock_y       = face_cy - clock_block_h // 2
    weather_x     = W - _WEATHER_COLS * _WEATHER_COL_W - 15
    weather_y     = clock_y - fonts['medium'].get_height() - 4

    # Geocode all locations and start background weather thread
    try:
        resolved = [_geocode(city) for city in _LOCATIONS]
        threading.Thread(target=_weather_worker, args=(resolved,), daemon=True).start()
    except Exception:
        pass

    _here    = os.path.dirname(os.path.abspath(__file__))
    png_path = os.path.join(_here, 'assets', 'face_wire.png')
    face_img = None
    if os.path.exists(png_path):
        raw      = pygame.image.load(png_path).convert()
        iw, ih   = raw.get_size()
        scale    = min((face_rx * 2.2) / iw, (face_ry * 2.4) / ih)
        face_img = pygame.transform.smoothscale(
            raw, (max(1, int(iw*scale)), max(1, int(ih*scale))))

    pg_clock = pygame.time.Clock()

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit(); return
            if event.type == pygame.KEYDOWN and event.key in (pygame.K_ESCAPE, pygame.K_q):
                pygame.quit(); return

        screen.fill(BLACK)

        if face_img:
            screen.blit(face_img, face_img.get_rect(center=(face_cx, face_cy)),
                        special_flags=pygame.BLEND_ADD)
        else:
            draw_wireframe_face(screen, face_cx, face_cy, face_rx, face_ry)

        draw_clock(screen, fonts, 20, clock_y)
        draw_weather(screen, fonts, weather_x, weather_y)

        pygame.display.flip()
        pg_clock.tick(10)


if __name__ == '__main__':
    main()