#!/usr/bin/env python3
"""Local SQLite chunk-replacement fixture; no model or vector service.
Python 3.9+, standard library only. Run with --test for regression tests.
"""
import json
import sqlite3
import sys
import unittest

UPSERT = """INSERT INTO chunks VALUES (?, ?, ?, ?)
ON CONFLICT(tenant, document, ordinal) DO UPDATE SET body=excluded.body"""
OLD = ['Current policy introduction', 'Manager approval required',
       'Retired exception: verbal approval is enough']
NEW = ['Current policy introduction', 'Written approval required']


def database():
    db = sqlite3.connect(':memory:', isolation_level=None)
    db.execute('''CREATE TABLE chunks (
        tenant TEXT NOT NULL, document TEXT NOT NULL,
        ordinal INTEGER NOT NULL, body TEXT NOT NULL,
        PRIMARY KEY (tenant, document, ordinal))''')
    return db


def rows(db, tenant='alpha', document='policy'):
    return db.execute('''SELECT ordinal, body FROM chunks
        WHERE tenant=? AND document=? ORDER BY ordinal''',
        (tenant, document)).fetchall()


def upsert_only(db, tenant, document, bodies):
    db.executemany(UPSERT, [(tenant, document, i, body)
                           for i, body in enumerate(bodies)])


def replace_document(db, tenant, document, bodies, *, complete, fail_after_delete=False):
    # Application-owned precondition. The caller must establish completeness.
    if complete is not True:
        raise ValueError('incomplete source snapshot')
    if not isinstance(tenant, str) or not tenant or not isinstance(document, str) or not document:
        raise ValueError('scope must contain nonempty strings')
    if not isinstance(bodies, list) or len(bodies) > 1000:
        raise ValueError('expected bounded chunk list')
    if any(not isinstance(body, str) or not body or len(body) > 10000 for body in bodies):
        raise ValueError('invalid chunk body')
    if db.in_transaction:
        raise ValueError('function requires an idle dedicated connection')
    db.execute('BEGIN IMMEDIATE')
    try:
        db.execute('DELETE FROM chunks WHERE tenant=? AND document=?', (tenant, document))
        if fail_after_delete:
            raise RuntimeError('injected failure after deletion')
        db.executemany('INSERT INTO chunks VALUES (?, ?, ?, ?)',
                       [(tenant, document, i, body) for i, body in enumerate(bodies)])
        expected = list(enumerate(bodies))
        if rows(db, tenant, document) != expected:
            raise RuntimeError('replacement mismatch')
        db.execute('COMMIT')
    except BaseException:
        if db.in_transaction:
            db.execute('ROLLBACK')
        raise


def demo():
    db = database()
    try:
        upsert_only(db, 'alpha', 'policy', OLD)
        upsert_only(db, 'alpha', 'policy', NEW)
        weak = rows(db)
        replace_document(db, 'alpha', 'policy', NEW, complete=True)
        return {'upsert_only': weak, 'transactional_replacement': rows(db)}
    finally:
        db.close()


class ReplacementTests(unittest.TestCase):
    def setUp(self):
        self.db = database()
        upsert_only(self.db, 'alpha', 'policy', OLD)

    def tearDown(self):
        self.db.close()

    def test_upsert_leaves_removed_tail(self):
        upsert_only(self.db, 'alpha', 'policy', NEW)
        self.assertEqual(rows(self.db), list(enumerate(NEW + OLD[2:])))

    def test_replacement_removes_tail(self):
        replace_document(self.db, 'alpha', 'policy', NEW, complete=True)
        self.assertEqual(rows(self.db), list(enumerate(NEW)))

    def test_failure_restores_original(self):
        with self.assertRaises(RuntimeError):
            replace_document(self.db, 'alpha', 'policy', NEW,
                             complete=True, fail_after_delete=True)
        self.assertEqual(rows(self.db), list(enumerate(OLD)))
        self.assertFalse(self.db.in_transaction)

    def test_scope_isolated(self):
        upsert_only(self.db, 'beta', 'policy', ['Other tenant'])
        upsert_only(self.db, 'alpha', 'other', ['Other document'])
        replace_document(self.db, 'alpha', 'policy', NEW, complete=True)
        self.assertEqual(rows(self.db, 'beta', 'policy'), [(0, 'Other tenant')])
        self.assertEqual(rows(self.db, 'alpha', 'other'), [(0, 'Other document')])

    def test_empty_complete_snapshot_removes_all(self):
        replace_document(self.db, 'alpha', 'policy', [], complete=True)
        self.assertEqual(rows(self.db), [])

    def test_partial_and_ambiguous_completeness_rejected(self):
        for complete in [False, None, 1, 'true']:
            with self.subTest(complete=complete), self.assertRaises(ValueError):
                replace_document(self.db, 'alpha', 'policy', [], complete=complete)
            self.assertEqual(rows(self.db), list(enumerate(OLD)))

    def test_invalid_body_rejected_before_deletion(self):
        for bodies in [[''], [None], ['x' * 10001], ['x'] * 1001, ('x',)]:
            with self.subTest(bodies_type=type(bodies).__name__), self.assertRaises(ValueError):
                replace_document(self.db, 'alpha', 'policy', bodies, complete=True)
            self.assertEqual(rows(self.db), list(enumerate(OLD)))

    def test_repeat_has_same_contents(self):
        for _ in range(2):
            replace_document(self.db, 'alpha', 'policy', NEW, complete=True)
        self.assertEqual(rows(self.db), list(enumerate(NEW)))

    def test_nested_transaction_rejected(self):
        self.db.execute('BEGIN')
        with self.assertRaises(ValueError):
            replace_document(self.db, 'alpha', 'policy', NEW, complete=True)
        self.assertTrue(self.db.in_transaction)
        self.db.execute('ROLLBACK')
        self.assertEqual(rows(self.db), list(enumerate(OLD)))


if __name__ == '__main__':
    if sys.argv[1:] == ['--test']:
        unittest.main(argv=[sys.argv[0]], verbosity=2)
    elif not sys.argv[1:]:
        print(json.dumps(demo(), indent=2))
    else:
        raise SystemExit('usage: rag-stale-chunks.py [--test]')
