Videre

local/file_watcher.py

@@ -191,40 +191,42 @@ class LibraryWatcher:
     def _full_scan_library(self, library_id: int, library_path: str):
         """
         Sammenligner filer på disk med SQLite og synkroniserer forskelle.
-        
-        Tre operationer:
-          1. Nye filer     → indsæt i SQLite
-          2. Ændrede filer → opdater SQLite (baseret på fil-timestamp)
-          3. Forsvundne    → marker som missing i SQLite
+        Håndterer utilgængelige mapper og symlinks sikkert.
         """
         logger.info(f"Fuld scan starter: {library_path}")
         base = Path(library_path)
 
-        # Hvad SQLite kender til
-        known = get_all_song_paths_for_library(library_id)
+        # Tjek at mappen faktisk er tilgængelig — med timeout
+        if not self._path_accessible(base):
+            logger.warning(f"Bibliotek ikke tilgængeligt (timeout eller ingen adgang): {library_path}")
+            return
 
-        # Hvad der faktisk er på disk
+        known = get_all_song_paths_for_library(library_id)
         found_paths = set()
         processed = 0
         errors = 0
 
-        for file_path in base.rglob("*"):
-            if not file_path.is_file() or not is_supported(file_path):
-                continue
-
-            path_str = str(file_path)
-            found_paths.add(path_str)
-            disk_modified = get_file_modified_at(file_path)
-
-            # Ny fil eller ændret siden sidst
-            if path_str not in known or known[path_str] != disk_modified:
+        import os
+        for dirpath, dirnames, filenames in os.walk(
+            str(base), followlinks=False,
+            onerror=lambda e: logger.warning(f"Adgang nægtet: {e}")
+        ):
+            for filename in filenames:
+                file_path = Path(dirpath) / filename
                 try:
-                    tags = read_tags(file_path)
-                    tags["library_id"] = library_id
-                    upsert_song(tags)
-                    processed += 1
-                    if self.on_change:
-                        self.on_change("upserted", path_str, None)
+                    if not is_supported(file_path):
+                        continue
+                    path_str = str(file_path)
+                    found_paths.add(path_str)
+                    disk_modified = get_file_modified_at(file_path)
+
+                    if path_str not in known or known[path_str] != disk_modified:
+                        tags = read_tags(file_path)
+                        tags["library_id"] = library_id
+                        upsert_song(tags)
+                        processed += 1
+                        if self.on_change:
+                            self.on_change("upserted", path_str, None)
                 except Exception as e:
                     logger.error(f"Scan-fejl for {file_path}: {e}")
                     errors += 1
@@ -244,6 +246,20 @@ class LibraryWatcher:
             f"{processed} opdateret, {missing_count} mangler, {errors} fejl"
         )
 
+    def _path_accessible(self, path: Path, timeout_sec: float = 5.0) -> bool:
+        """Tjek om en sti er tilgængelig inden for timeout."""
+        import threading
+        result = [False]
+        def check():
+            try:
+                result[0] = path.exists() and path.is_dir()
+            except Exception:
+                result[0] = False
+        t = threading.Thread(target=check, daemon=True)
+        t.start()
+        t.join(timeout=timeout_sec)
+        return result[0]
+
 
 # ── Singleton til brug i appen ────────────────────────────────────────────────
 

local/local_db.py

@@ -81,6 +81,16 @@ def init_db():
                 dance_order INTEGER NOT NULL DEFAULT 1
             );
 
+            -- Alternativ-danse relationer (kun online hvis logget ind, men caches lokalt)
+            CREATE TABLE IF NOT EXISTS dance_alternatives (
+                id                TEXT PRIMARY KEY,
+                song_dance_id     INTEGER NOT NULL REFERENCES song_dances(id) ON DELETE CASCADE,
+                alt_song_dance_id INTEGER NOT NULL REFERENCES song_dances(id) ON DELETE CASCADE,
+                note              TEXT NOT NULL DEFAULT '',
+                created_at        TEXT NOT NULL DEFAULT (datetime('now')),
+                UNIQUE(song_dance_id, alt_song_dance_id)
+            );
+
             -- Lokale afspilningslister (offline-projekter)
             CREATE TABLE IF NOT EXISTS playlists (
                 id          INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -119,6 +129,76 @@ def init_db():
             CREATE INDEX IF NOT EXISTS idx_song_dances    ON song_dances(song_id);
         """)
 
+        # Migration: tilføj tabeller der måske mangler i ældre databaser
+        _run_migrations(conn)
+
+
+def _run_migrations(conn):
+    """Kør migrations sikkert — CREATE IF NOT EXISTS er idempotent."""
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS dance_alternatives (
+            id                TEXT PRIMARY KEY,
+            song_dance_id     INTEGER NOT NULL REFERENCES song_dances(id) ON DELETE CASCADE,
+            alt_dance_name    TEXT NOT NULL,
+            level_id          INTEGER REFERENCES dance_levels(id),
+            note              TEXT NOT NULL DEFAULT '',
+            source            TEXT NOT NULL DEFAULT 'local',
+            created_by        TEXT NOT NULL DEFAULT '',
+            created_at        TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS event_state (
+            key   TEXT PRIMARY KEY,
+            value TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS dance_names (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            name        TEXT NOT NULL UNIQUE COLLATE NOCASE,
+            source      TEXT NOT NULL DEFAULT 'local',
+            use_count   INTEGER NOT NULL DEFAULT 1,
+            synced_at   TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS dance_levels (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            sort_order  INTEGER NOT NULL,
+            name        TEXT NOT NULL UNIQUE,
+            description TEXT NOT NULL DEFAULT '',
+            synced_at   TEXT
+        );
+    """)
+
+    # Tilføj kolonner der måske mangler i ældre databaser
+    migrations = [
+        "ALTER TABLE songs ADD COLUMN extra_tags TEXT NOT NULL DEFAULT '{}'",
+        "ALTER TABLE song_dances ADD COLUMN level_id INTEGER REFERENCES dance_levels(id)",
+        "ALTER TABLE dance_alternatives ADD COLUMN alt_dance_name TEXT NOT NULL DEFAULT ''",
+        "ALTER TABLE dance_alternatives ADD COLUMN level_id INTEGER REFERENCES dance_levels(id)",
+        "ALTER TABLE dance_alternatives ADD COLUMN source TEXT NOT NULL DEFAULT 'local'",
+        "ALTER TABLE dance_alternatives ADD COLUMN created_by TEXT NOT NULL DEFAULT ''",
+    ]
+    for sql in migrations:
+        try:
+            conn.execute(sql)
+        except Exception:
+            pass  # kolonnen eksisterer allerede
+
+    # Indlæs standard-niveauer hvis tabellen er tom
+    count = conn.execute("SELECT COUNT(*) FROM dance_levels").fetchone()[0]
+    if count == 0:
+        defaults = [
+            (1, "Begynder",   "Passer til alle"),
+            (2, "Let øvet",   "Lidt erfaring kræves"),
+            (3, "Øvet",       "Kræver regelmæssig træning"),
+            (4, "Erfaren",    "For dedikerede dansere"),
+            (5, "Ekspert",    "Konkurrenceniveau"),
+        ]
+        conn.executemany(
+            "INSERT OR IGNORE INTO dance_levels (sort_order, name, description) VALUES (?,?,?)",
+            defaults
+        )
+
 
 # ── Biblioteker ───────────────────────────────────────────────────────────────
 
@@ -144,7 +224,12 @@ def get_libraries(active_only: bool = True) -> list[sqlite3.Row]:
 
 def remove_library(library_id: int):
     with get_db() as conn:
-        conn.execute("UPDATE libraries SET is_active=0 WHERE id=?", (library_id,))
+        # Marker sange som manglende
+        conn.execute(
+            "UPDATE songs SET file_missing=1 WHERE library_id=?", (library_id,)
+        )
+        # Slet biblioteket helt
+        conn.execute("DELETE FROM libraries WHERE id=?", (library_id,))
 
 
 def update_library_scan_time(library_id: int):
@@ -162,20 +247,23 @@ def upsert_song(song_data: dict) -> str:
     Indsæt eller opdater en sang baseret på local_path.
     Returnerer song_id.
     """
-    import uuid
+    import uuid, json
     with get_db() as conn:
         existing = conn.execute(
             "SELECT id FROM songs WHERE local_path=?", (song_data["local_path"],)
         ).fetchone()
 
+        extra_tags_json = json.dumps(song_data.get("extra_tags", {}), ensure_ascii=False)
+
         if existing:
             song_id = existing["id"]
             conn.execute("""
                 UPDATE songs SET
-                    title=?, artist=?, album=?, bpm=?, duration_sec=?,
-                    file_format=?, file_modified_at=?, file_missing=0
+                    library_id=?, title=?, artist=?, album=?, bpm=?, duration_sec=?,
+                    file_format=?, file_modified_at=?, file_missing=0, extra_tags=?
                 WHERE id=?
             """, (
+                song_data.get("library_id"),
                 song_data.get("title", ""),
                 song_data.get("artist", ""),
                 song_data.get("album", ""),
@@ -183,6 +271,7 @@ def upsert_song(song_data: dict) -> str:
                 song_data.get("duration_sec", 0),
                 song_data.get("file_format", ""),
                 song_data.get("file_modified_at", ""),
+                extra_tags_json,
                 song_id,
             ))
         else:
@@ -190,8 +279,8 @@ def upsert_song(song_data: dict) -> str:
             conn.execute("""
                 INSERT INTO songs
                     (id, library_id, local_path, title, artist, album,
-                     bpm, duration_sec, file_format, file_modified_at)
-                VALUES (?,?,?,?,?,?,?,?,?,?)
+                     bpm, duration_sec, file_format, file_modified_at, extra_tags)
+                VALUES (?,?,?,?,?,?,?,?,?,?,?)
             """, (
                 song_id,
                 song_data.get("library_id"),
@@ -203,16 +292,33 @@ def upsert_song(song_data: dict) -> str:
                 song_data.get("duration_sec", 0),
                 song_data.get("file_format", ""),
                 song_data.get("file_modified_at", ""),
+                extra_tags_json,
             ))
 
         # Opdater danse hvis de er med i data
         if "dances" in song_data:
             conn.execute("DELETE FROM song_dances WHERE song_id=?", (song_id,))
-            for i, dance_name in enumerate(song_data["dances"], start=1):
+            for i, dance in enumerate(song_data["dances"], start=1):
+                # dance kan være str eller dict med {name, level_id}
+                if isinstance(dance, dict):
+                    name     = dance.get("name", "")
+                    level_id = dance.get("level_id")
+                else:
+                    name     = dance
+                    level_id = None
                 conn.execute(
-                    "INSERT INTO song_dances (song_id, dance_name, dance_order) VALUES (?,?,?)",
-                    (song_id, dance_name, i),
+                    "INSERT INTO song_dances (song_id, dance_name, dance_order, level_id) VALUES (?,?,?,?)",
+                    (song_id, name, i, level_id),
                 )
+            # Registrer navne i ordbogen
+            try:
+                from local.local_db import register_dance_name as _reg
+                for dance in song_data["dances"]:
+                    nm = dance.get("name", dance) if isinstance(dance, dict) else dance
+                    if nm:
+                        _reg(nm)
+            except Exception:
+                pass
 
     return song_id
 
@@ -232,17 +338,23 @@ def get_song_by_path(local_path: str) -> sqlite3.Row | None:
 
 
 def search_songs(query: str, limit: int = 50) -> list[sqlite3.Row]:
-    """Søg i titel, artist og dansenavne."""
+    """Søg i alle tags — titel, artist, album, danse og alle øvrige tags."""
     pattern = f"%{query}%"
     with get_db() as conn:
         return conn.execute("""
             SELECT DISTINCT s.* FROM songs s
             LEFT JOIN song_dances sd ON sd.song_id = s.id
             WHERE s.file_missing = 0
-              AND (s.title LIKE ? OR s.artist LIKE ? OR s.album LIKE ? OR sd.dance_name LIKE ?)
+              AND (
+                s.title      LIKE ? OR
+                s.artist     LIKE ? OR
+                s.album      LIKE ? OR
+                sd.dance_name LIKE ? OR
+                s.extra_tags  LIKE ?
+              )
             ORDER BY s.artist, s.title
             LIMIT ?
-        """, (pattern, pattern, pattern, pattern, limit)).fetchall()
+        """, (pattern, pattern, pattern, pattern, pattern, limit)).fetchall()
 
 
 def get_songs_for_library(library_id: int) -> list[sqlite3.Row]:
@@ -328,3 +440,148 @@ def get_playlist_with_songs(playlist_id: int) -> dict:
         """, (playlist_id,)).fetchall()
 
         return {"playlist": dict(playlist), "songs": [dict(s) for s in songs]}
+
+
+# ── Event-state (gemmes løbende så man kan genstarte efter strømsvigt) ────────
+
+def save_event_state(current_idx: int, statuses: list[str]):
+    """Gem event-fremgang — overskrives ved hver ændring."""
+    import json
+    with get_db() as conn:
+        conn.execute("INSERT OR REPLACE INTO event_state (key,value) VALUES ('current_idx',?)",
+                     (str(current_idx),))
+        conn.execute("INSERT OR REPLACE INTO event_state (key,value) VALUES ('statuses',?)",
+                     (json.dumps(statuses),))
+
+
+def load_event_state() -> tuple[int, list[str]] | None:
+    """Indlæs gemt event-fremgang. Returnerer None hvis ingen gemt tilstand."""
+    import json
+    with get_db() as conn:
+        idx_row = conn.execute(
+            "SELECT value FROM event_state WHERE key='current_idx'"
+        ).fetchone()
+        sta_row = conn.execute(
+            "SELECT value FROM event_state WHERE key='statuses'"
+        ).fetchone()
+    if not idx_row or not sta_row:
+        return None
+    return int(idx_row["value"]), json.loads(sta_row["value"])
+
+
+def clear_event_state():
+    """Nulstil gemt event-tilstand (bruges ved 'Start event')."""
+    with get_db() as conn:
+        conn.execute("DELETE FROM event_state")
+
+
+# ── Dans-navne ordbog ─────────────────────────────────────────────────────────
+
+def get_dance_name_suggestions(prefix: str, limit: int = 20) -> list[str]:
+    """Returnerer danse-navne der starter med prefix, sorteret efter popularitet."""
+    with get_db() as conn:
+        rows = conn.execute("""
+            SELECT name FROM dance_names
+            WHERE name LIKE ? COLLATE NOCASE
+            ORDER BY use_count DESC, name
+            LIMIT ?
+        """, (f"{prefix}%", limit)).fetchall()
+        return [r["name"] for r in rows]
+
+
+def register_dance_name(name: str, source: str = "local"):
+    """Tilføj eller opdater et dans-navn i ordbogen."""
+    name = name.strip()
+    if not name:
+        return
+    with get_db() as conn:
+        existing = conn.execute(
+            "SELECT id, use_count FROM dance_names WHERE name=? COLLATE NOCASE",
+            (name,)
+        ).fetchone()
+        if existing:
+            conn.execute(
+                "UPDATE dance_names SET use_count=use_count+1 WHERE id=?",
+                (existing["id"],)
+            )
+        else:
+            conn.execute(
+                "INSERT INTO dance_names (name, source, use_count) VALUES (?,?,1)",
+                (name, source)
+            )
+
+
+def sync_dance_names_from_api(names: list[dict]):
+    """Synkroniser dans-navne fra API — {name, use_count}."""
+    from datetime import datetime, timezone
+    now = datetime.now(timezone.utc).isoformat()
+    with get_db() as conn:
+        for item in names:
+            conn.execute("""
+                INSERT INTO dance_names (name, source, use_count, synced_at)
+                VALUES (?, 'community', ?, ?)
+                ON CONFLICT(name) DO UPDATE SET
+                    use_count = MAX(use_count, excluded.use_count),
+                    synced_at = excluded.synced_at
+            """, (item["name"], item.get("use_count", 1), now))
+
+
+# ── Dans-niveauer ─────────────────────────────────────────────────────────────
+
+def get_dance_levels() -> list[sqlite3.Row]:
+    """Hent alle niveauer sorteret efter sort_order."""
+    with get_db() as conn:
+        return conn.execute(
+            "SELECT * FROM dance_levels ORDER BY sort_order"
+        ).fetchall()
+
+
+def sync_dance_levels_from_api(levels: list[dict]):
+    """Synkroniser niveauer fra API — {sort_order, name, description}."""
+    from datetime import datetime, timezone
+    now = datetime.now(timezone.utc).isoformat()
+    with get_db() as conn:
+        for lvl in levels:
+            conn.execute("""
+                INSERT INTO dance_levels (sort_order, name, description, synced_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(name) DO UPDATE SET
+                    sort_order  = excluded.sort_order,
+                    description = excluded.description,
+                    synced_at   = excluded.synced_at
+            """, (lvl["sort_order"], lvl["name"], lvl.get("description", ""), now))
+
+
+# ── Dans-alternativer ─────────────────────────────────────────────────────────
+
+def get_alternatives_for_dance(song_dance_id: int) -> list[sqlite3.Row]:
+    with get_db() as conn:
+        return conn.execute("""
+            SELECT da.*, dl.name as level_name, dl.sort_order as level_sort
+            FROM dance_alternatives da
+            LEFT JOIN dance_levels dl ON dl.id = da.level_id
+            WHERE da.song_dance_id = ?
+            ORDER BY da.source, dl.sort_order
+        """, (song_dance_id,)).fetchall()
+
+
+def add_alternative(song_dance_id: int, alt_dance_name: str,
+                    level_id: int | None = None, note: str = "",
+                    source: str = "local", created_by: str = "") -> str:
+    import uuid as _uuid
+    alt_id = str(_uuid.uuid4())
+    with get_db() as conn:
+        conn.execute("""
+            INSERT INTO dance_alternatives
+                (id, song_dance_id, alt_dance_name, level_id, note, source, created_by)
+            VALUES (?,?,?,?,?,?,?)
+        """, (alt_id, song_dance_id, alt_dance_name.strip(),
+              level_id, note, source, created_by))
+    # Registrer alt-dans-navne i ordbogen
+    register_dance_name(alt_dance_name, source=source)
+    return alt_id
+
+
+def remove_alternative(alt_id: str):
+    with get_db() as conn:
+        conn.execute("DELETE FROM dance_alternatives WHERE id=?", (alt_id,))

local/tag_reader.py

@@ -65,7 +65,8 @@ def read_tags(path: str | Path) -> dict:
     """
     Læser metadata og danse fra en lydfil.
     Returnerer dict med: title, artist, album, bpm, duration_sec,
-                         file_format, file_modified_at, dances, can_write_dances.
+                         file_format, file_modified_at, dances, can_write_dances,
+                         extra_tags (dict med alle øvrige tags som {navn: værdi}).
     """
     path = Path(path)
     result = {
@@ -79,6 +80,7 @@ def read_tags(path: str | Path) -> dict:
         "file_modified_at": get_file_modified_at(path),
         "dances":           [],
         "can_write_dances": can_write_dances(path),
+        "extra_tags":       {},
     }
 
     if not MUTAGEN_AVAILABLE:
@@ -127,6 +129,17 @@ def _read_mp3(audio, result: dict):
         except (ValueError, TypeError):
             pass
     dances = {}
+    extra = {}
+    # Kendte ID3-felt-navne til menneskelige navne
+    ID3_NAMES = {
+        "TIT2": "titel", "TPE1": "artist", "TALB": "album", "TBPM": "bpm",
+        "TYER": "år", "TDRC": "dato", "TCON": "genre", "TPE2": "albumartist",
+        "TPOS": "disknummer", "TRCK": "spornummer", "TCOM": "komponist",
+        "TLYR": "sangtekst", "TCOP": "copyright", "TPUB": "udgiver",
+        "TENC": "kodet_af", "TLAN": "sprog", "TMOO": "stemning",
+        "TPE3": "dirigent", "TPE4": "fortolket_af", "TOAL": "original_album",
+        "TOPE": "original_artist", "TORY": "original_år",
+    }
     for key, frame in tags.items():
         if key.startswith("TXXX:") and TXXX_DANCE_PREFIX in key:
             try:
@@ -134,7 +147,31 @@ def _read_mp3(audio, result: dict):
                 dances[num] = str(frame.text[0])
             except (ValueError, IndexError):
                 pass
+        elif key.startswith("TXXX:"):
+            # Custom TXXX-felt — gem under dets beskrivelse
+            desc = key[5:]  # fjern "TXXX:"
+            try:
+                extra[desc] = str(frame.text[0])
+            except Exception:
+                pass
+        elif key in ID3_NAMES and key not in ("TIT2","TPE1","TALB","TBPM"):
+            # Standardfelt vi ikke allerede har gemt
+            try:
+                val = str(frame.text[0]) if hasattr(frame, "text") else str(frame)
+                if val:
+                    extra[ID3_NAMES[key]] = val
+            except Exception:
+                pass
+        elif hasattr(frame, "text") and key not in ("TIT2","TPE1","TALB","TBPM"):
+            # Alle andre tekstfelter
+            try:
+                val = str(frame.text[0])
+                if val and not key.startswith("APIC"):  # spring albumcover over
+                    extra[key] = val
+            except Exception:
+                pass
     result["dances"] = [dances[k] for k in sorted(dances.keys())]
+    result["extra_tags"] = extra
 
 
 def _read_vorbis(audio, result: dict):
@@ -149,7 +186,7 @@ def _read_vorbis(audio, result: dict):
         result["bpm"] = int(tags.get("bpm", [0])[0])
     except (ValueError, TypeError):
         pass
-    # Danse gemmes som linedance_dance.1, linedance_dance.2 ...
+    # Danse
     dances = {}
     for key, values in tags.items():
         if key.lower().startswith(f"{VORBIS_DANCE_KEY}."):
@@ -158,11 +195,21 @@ def _read_vorbis(audio, result: dict):
                 dances[num] = values[0]
             except (ValueError, IndexError):
                 pass
-    # Fallback: enkelt felt linedance_dance med komma-separeret liste
     if not dances and VORBIS_DANCE_KEY in tags:
         result["dances"] = [d.strip() for d in tags[VORBIS_DANCE_KEY][0].split(",") if d.strip()]
-        return
-    result["dances"] = [dances[k] for k in sorted(dances.keys())]
+    else:
+        result["dances"] = [dances[k] for k in sorted(dances.keys())]
+    # Alle øvrige tags som extra_tags
+    skip = {"title", "artist", "album", "bpm", VORBIS_DANCE_KEY}
+    extra = {}
+    for key, values in tags.items():
+        k = key.lower()
+        if k not in skip and not k.startswith(VORBIS_DANCE_KEY):
+            try:
+                extra[k] = str(values[0])
+            except Exception:
+                pass
+    result["extra_tags"] = extra
 
 
 def _read_m4a(audio, result: dict):
@@ -180,12 +227,33 @@ def _read_m4a(audio, result: dict):
             result["bpm"] = int(tags["tmpo"][0])
         except (ValueError, TypeError):
             pass
-    # Danse gemmes som ----:LINEDANCE:DANCE — én værdi per dans
     if M4A_DANCE_FREEFORM in tags:
         result["dances"] = [
             v.decode("utf-8") if isinstance(v, (bytes, MP4FreeForm)) else str(v)
             for v in tags[M4A_DANCE_FREEFORM]
         ]
+    # Menneskelige navne til M4A-nøgler
+    M4A_NAMES = {
+        "\xa9nam": "titel", "\xa9ART": "artist", "\xa9alb": "album",
+        "\xa9day": "år", "\xa9gen": "genre", "\xa9wrt": "komponist",
+        "\xa9cmt": "kommentar", "aART": "albumartist", "trkn": "spornummer",
+        "disk": "disknummer", "cprt": "copyright", "\xa9lyr": "sangtekst",
+        "tmpo": "bpm",
+    }
+    skip_keys = {"\xa9nam", "\xa9ART", "\xa9alb", "tmpo", M4A_DANCE_FREEFORM, "covr"}
+    extra = {}
+    for key, values in tags.items():
+        if key in skip_keys:
+            continue
+        label = M4A_NAMES.get(key, key)
+        try:
+            val = values[0]
+            if isinstance(val, (bytes, MP4FreeForm)):
+                val = val.decode("utf-8", errors="replace")
+            extra[label] = str(val)
+        except Exception:
+            pass
+    result["extra_tags"] = extra
 
 
 def _read_generic(audio, result: dict):
@@ -278,3 +346,46 @@ def read_dances_from_file(path: str | Path) -> list[str]:
     """Læser kun danse fra en fil — hurtigere end fuld read_tags()."""
     tags = read_tags(path)
     return tags.get("dances", [])
+
+
+# ── BPM-analyse ───────────────────────────────────────────────────────────────
+
+def analyze_bpm(path: str | Path) -> float | None:
+    """
+    Analysér BPM fra lydfilen ved hjælp af librosa.
+    Returnerer BPM som float eller None ved fejl.
+    Tager 2-5 sekunder per sang — kør i baggrundstråd.
+    """
+    try:
+        import librosa
+        # Indlæs kun de første 60 sekunder for hastighed
+        y, sr = librosa.load(str(path), duration=60.0, mono=True)
+        tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
+        # librosa returnerer array i nyere versioner
+        if hasattr(tempo, "__len__"):
+            bpm = float(tempo[0]) if len(tempo) > 0 else 0.0
+        else:
+            bpm = float(tempo)
+        return round(bpm, 1) if bpm > 0 else None
+    except ImportError:
+        print("librosa ikke installeret — installer med: pip install librosa")
+        return None
+    except Exception as e:
+        print(f"BPM-analyse fejl for {path}: {e}")
+        return None
+
+
+def analyze_and_save_bpm(path: str | Path, song_id: str) -> float | None:
+    """Analysér BPM og gem i SQLite. Returnerer målt BPM."""
+    bpm = analyze_bpm(path)
+    if bpm and bpm > 0:
+        try:
+            from local.local_db import get_db
+            with get_db() as conn:
+                conn.execute(
+                    "UPDATE songs SET bpm=? WHERE id=? AND (bpm IS NULL OR bpm=0)",
+                    (int(round(bpm)), song_id)
+                )
+        except Exception as e:
+            print(f"BPM gem fejl: {e}")
+    return bpm