"""
MeshBay Node — persistent (path, size, mtime) -> hash cache, one per node.

Without this, every node restart re-reads and re-hashes every file in every
root, even when nothing changed — measured at 23 minutes for a 114 GB library
on a USB hard drive. This cache lets a scan skip the read entirely for a file
whose size and mtime still match what was hashed last time.

It is a path-keyed accelerator only. The GroupIndex itself stays keyed by
content hash (see indexer.py's note on why two identical files are one
entry) — this cache never changes that, it only avoids recomputing a hash
that has not changed.

**Shared by every group's DirectoryIndexer, one instance, one open
connection** (2026-08-25) — an operator very often shares the same physical
folder (a music library, a Séries drive) into more than one group, and a
cache keyed purely by absolute path has no reason to care which group asked.
It used to be opened once per group (`data_dir/{group_id}/index_cache.db`),
which meant the second group to reference an already-fully-hashed multi-
terabyte folder paid the same full read the first one did — exactly the cost
this cache exists to avoid. The schema carries no group_id and never has;
only daemon.py's wiring changed.
"""

import logging
from dataclasses import dataclass
from pathlib import Path

import aiosqlite

log = logging.getLogger(__name__)

_SCHEMA = """
CREATE TABLE IF NOT EXISTS files (
    path         TEXT PRIMARY KEY,
    mtime        REAL NOT NULL,
    size         INTEGER NOT NULL,
    hash         TEXT NOT NULL,
    type         TEXT NOT NULL,
    added_at     INTEGER NOT NULL,
    hash_version INTEGER NOT NULL DEFAULT 1
);
"""

_MIGRATE_V2 = "ALTER TABLE files ADD COLUMN hash_version INTEGER NOT NULL DEFAULT 1"


@dataclass
class CachedEntry:
    hash: str
    type: str
    added_at: int
    hash_version: int = 1


class IndexCache:
    """Async SQLite (path, size, mtime) -> hash cache, shared node-wide."""

    def __init__(self, db_path: Path):
        self._db_path = db_path
        self._db: aiosqlite.Connection | None = None

    async def open(self) -> None:
        self._db_path.parent.mkdir(parents=True, exist_ok=True)
        self._db = await aiosqlite.connect(str(self._db_path))
        await self._db.executescript(_SCHEMA)
        try:
            await self._db.execute(_MIGRATE_V2)
        except Exception:
            pass  # column already exists
        await self._db.commit()

    async def close(self) -> None:
        if self._db:
            await self._db.close()
            self._db = None

    async def __aenter__(self):
        await self.open()
        return self

    async def __aexit__(self, *_):
        await self.close()

    async def lookup(self, path: str, size: int, mtime: float,
                     hash_version: int = 1) -> CachedEntry | None:
        """
        A cache hit requires an EXACT match on size, mtime AND hash_version.
        A v1 cached hash won't serve a v2 lookup for the same path — the file
        is re-hashed with the new algorithm instead.
        """
        async with self._db.execute(
                "SELECT hash, type, added_at, hash_version FROM files "
                "WHERE path = ? AND size = ? AND mtime = ? AND hash_version = ?",
                (path, size, mtime, hash_version)) as cur:
            row = await cur.fetchone()
        return CachedEntry(hash=row[0], type=row[1], added_at=row[2],
                           hash_version=row[3]) if row else None

    async def put(self, path: str, size: int, mtime: float, hash: str,
                  type: str, added_at: int, hash_version: int = 1) -> None:
        """
        Written only once a file has been hashed — never partway through — so
        a crash mid-hash leaves no stale/partial row behind: the next scan
        simply finds no cache entry and hashes the file again.
        """
        await self._db.execute(
            "INSERT INTO files (path, mtime, size, hash, type, added_at, hash_version) "
            "VALUES (?, ?, ?, ?, ?, ?, ?) "
            "ON CONFLICT(path) DO UPDATE SET "
            "mtime = excluded.mtime, size = excluded.size, hash = excluded.hash, "
            "type = excluded.type, added_at = excluded.added_at, "
            "hash_version = excluded.hash_version",
            (path, mtime, size, hash, type, added_at, hash_version))
        await self._db.commit()

    # ── Maintenance (node admin UI "prune index cache") ──────────────────────

    async def count(self) -> int:
        """Cheap — used for the dashboard stat, never for the prune decision
        itself (that needs the actual paths, see all_paths)."""
        async with self._db.execute("SELECT COUNT(*) FROM files") as cur:
            row = await cur.fetchone()
        return row[0] if row else 0

    async def all_paths(self) -> list[str]:
        """Every cached path, for a caller that decides staleness itself —
        this cache has no notion of which paths are still claimed by a
        group's roots, on purpose (see ops.prune_index_cache)."""
        async with self._db.execute("SELECT path FROM files") as cur:
            rows = await cur.fetchall()
        return [row[0] for row in rows]

    async def remove_many(self, paths: list[str]) -> None:
        """Drop rows outright — used only for paths a caller has already
        decided are gone for good. Losing one costs a rehash next time that
        path is scanned, never a wrong answer (lookup() always re-validates
        against a live stat())."""
        if not paths:
            return
        await self._db.executemany(
            "DELETE FROM files WHERE path = ?", [(p,) for p in paths])
        await self._db.commit()