"""Publication barrier and provenance shared by SQLite and Neo4j.

Builders work in a staging directory. Readers hold a shared process lock while
using a snapshot; publishers hold its exclusive counterpart. A durable pending
marker makes a process crash fail closed until the next successful sync.
"""
from __future__ import annotations

import fcntl
import json
import os
import sqlite3
from contextlib import closing, contextmanager
from functools import wraps
from pathlib import Path

from tools.rag.common import DATA_DIR

VERSION_FILE = 'index_version.json'
PENDING_FILE = '.sync-pending.json'
LOCK_FILE = '.index-publication.lock'


class IndexUnavailableError(RuntimeError):
    pass


def fsync_directory(path: Path) -> None:
    descriptor = os.open(path, os.O_RDONLY | os.O_DIRECTORY)
    try:
        os.fsync(descriptor)
    finally:
        os.close(descriptor)


def durable_json(path: Path, value: dict) -> None:
    temporary = path.with_suffix(path.suffix + '.tmp')
    with temporary.open('w', encoding='utf-8') as handle:
        json.dump(value, handle, ensure_ascii=False, indent=2)
        handle.write('\n'); handle.flush(); os.fsync(handle.fileno())
    os.replace(temporary, path)
    fsync_directory(path.parent)


@contextmanager
def publication_lock(data_dir: Path, *, exclusive: bool = False):
    data_dir.mkdir(parents=True, exist_ok=True)
    with (data_dir / LOCK_FILE).open('a+') as handle:
        try:
            flags = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH | fcntl.LOCK_NB
            fcntl.flock(handle.fileno(), flags)
        except BlockingIOError as error:
            raise IndexUnavailableError('Prebieha aktivácia novej verzie indexov.') from error
        try:
            yield
        finally:
            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)


def read_version(data_dir: Path = DATA_DIR) -> dict | None:
    path = data_dir / VERSION_FILE
    if not path.exists():
        return None  # Pre-migration index; first coordinated sync adds metadata.
    try:
        value = json.loads(path.read_text())
        if not isinstance(value, dict) or not value.get('version'):
            raise ValueError('Missing version')
        return value
    except (ValueError, OSError) as error:
        raise IndexUnavailableError('Neplatná verzia vyhľadávacieho indexu.') from error


def sqlite_version(db_file: Path) -> dict | None:
    with closing(sqlite3.connect(db_file.resolve().as_uri() + '?mode=ro', uri=True)) as conn:
        if not conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='index_state'").fetchone():
            return None
        row = conn.execute('SELECT metadata_json FROM index_state WHERE id=1').fetchone()
        try:
            return json.loads(row[0]) if row else None
        except ValueError as error:
            raise IndexUnavailableError('Neplatná verzia SQLite indexu.') from error


@contextmanager
def index_snapshot(data_dir: Path = DATA_DIR, *, db_file: Path | None = None):
    with publication_lock(data_dir):
        if (data_dir / PENDING_FILE).exists():
            raise IndexUnavailableError('Synchronizácia indexov nebola dokončená; zopakujte synchronizáciu.')
        version = read_version(data_dir)
        if db_file is not None and version is not None and sqlite_version(db_file) != version:
            raise IndexUnavailableError('SQLite index nezodpovedá aktívnej verzii dát.')
        yield version


def rag_snapshot(function):
    @wraps(function)
    def wrapped(*args, **kwargs):
        db_file = Path(args[0] if args else kwargs.get('db_path', kwargs.get('db_file')))
        with index_snapshot(db_file.parent, db_file=db_file) as version:
            result = function(*args, **kwargs)
            if version is not None:
                result['index_version'] = version
            return result
    return wrapped