"""Falling photos backdrop for the idle/title screen.

Saved photos from the photos/ folder drift down from the top of the
screen with a small white border, looping forever. They are drawn behind
the title text. Thumbnails are loaded once and cached by file path; the
cache is pruned when photos are deleted (after a print cycle).
"""

import math
import random

import pygame

THUMB_H = 140
BORDER = 6
NUM_PHOTOS = 10
MIN_SPEED, MAX_SPEED = 30, 90       # px/sec downward
DRIFT_AMP = 40
ROT_MIN, ROT_MAX = -12.5, 12.5      # degrees (halved)
SPIN_MIN, SPIN_MAX = -10, 10        # deg/sec (halved)


def _color_with_border(src):
    """Scale src to THUMB_H tall, add a white BORDER, return (surf, w, h)."""
    w0, h0 = src.get_size()
    new_w = max(1, int(w0 * THUMB_H / h0))
    scaled = pygame.transform.smoothscale(src, (new_w, THUMB_H))
    bw, bh = new_w + 2 * BORDER, THUMB_H + 2 * BORDER
    surf = pygame.Surface((bw, bh), pygame.SRCALPHA)
    surf.fill((255, 255, 255, 255))
    surf.blit(scaled, (BORDER, BORDER))
    return surf, bw, bh


class _Sprite:
    def __init__(self, screen_size, picker):
        self.screen_w, self.screen_h = screen_size
        self.picker = picker
        self._respawn(top=True)

    def _respawn(self, top=False):
        self.image, self.w, self.h = self.picker()
        self.angle = random.uniform(ROT_MIN, ROT_MAX)
        self.spin = random.uniform(SPIN_MIN, SPIN_MAX)
        self.speed = random.uniform(MIN_SPEED, MAX_SPEED)
        self.drift_amp = random.uniform(0, DRIFT_AMP)
        self.drift_phase = random.uniform(0, math.tau)
        self.drift_speed = random.uniform(0.4, 1.2)
        if top:
            self.x = random.uniform(-self.w, self.screen_w)
            self.y = random.uniform(-self.h * 3, -self.h)
        else:
            self.x = random.uniform(0, self.screen_w - self.w)
            self.y = -self.h

    def update(self, dt):
        self.y += self.speed * dt
        self.drift_phase += self.drift_speed * dt
        self.angle += self.spin * dt
        if self.y > self.screen_h + self.h:
            self._respawn()

    def draw(self, screen):
        ox = math.sin(self.drift_phase) * self.drift_amp
        rotated = pygame.transform.rotate(self.image, self.angle)
        rect = rotated.get_rect(
            center=(self.x + self.w / 2 + ox, self.y + self.h / 2))
        screen.blit(rotated, rect)


class FallingPhotos:
    def __init__(self, screen_size, photos_dir):
        self.screen_size = screen_size
        self.photos_dir = photos_dir
        self._cache = {}      # path -> (bordered_surf, bw, bh)
        self._paths = []
        self._scan()
        self.sprites = [_Sprite(screen_size, self._pick) for _ in range(NUM_PHOTOS)]

    def _scan(self):
        self._paths = (sorted(self.photos_dir.glob("*.jpg"))
                       if self.photos_dir.exists() else [])
        self._cache = {p: v for p, v in self._cache.items() if p in self._paths}

    def reload(self):
        """Re-scan the photos folder (call after photos are deleted)."""
        self._scan()

    def _pick(self):
        if not self._paths:
            surf = pygame.Surface((THUMB_H, THUMB_H), pygame.SRCALPHA)
            surf.fill((0, 0, 0, 0))
            return surf, THUMB_H, THUMB_H
        path = random.choice(self._paths)
        if path not in self._cache:
            try:
                src = pygame.image.load(str(path)).convert_alpha()
            except (pygame.error, OSError):
                self._paths = [p for p in self._paths if p != path]
                return self._pick()
            self._cache[path] = _color_with_border(src)
        return self._cache[path]

    def update(self, dt):
        if not self._paths:
            self._scan()
        for s in self.sprites:
            s.update(dt)

    def draw(self, screen):
        for s in self.sprites:
            s.draw(screen)