"""
Tests for ``bal.core.checkalive`` (pure, GUI-free).

Covers the CheckAlive exceptions and the BASIC/ADVANCED date_to_check policy
(``resolve_date_to_check`` / ``resolve_relative_check_alive_date`` /
``is_check_alive_date_valid`` / ``ensure_check_alive_valid``), including the
sign rule: a NEGATIVE relative Check Alive counts back from the delivery, a
POSITIVE one counts forward from the inheritance creation date.

Run:
    source "$BAL_HOME/electrum/env/bin/activate"
    python3 tests/test_core_checkalive.py
"""

import sys
import time
from datetime import datetime, timezone

sys.path.insert(0, __file__.rsplit("/", 2)[0])

from bal.core.checkalive import (  # noqa: E402  (path insert above)
    CheckAliveAfterDeliveryError,
    CheckAliveError,
    ensure_check_alive_valid,
    is_check_alive_date_valid,
    resolve_date_to_check,
    resolve_delivery_date,
    resolve_guard_threshold,
    resolve_relative_check_alive_date,
)
from bal.core.plugin_base import BalTimestamp  # noqa: E402
from bal.core.will import Will  # noqa: E402


def _midnight(ts):
    return (
        datetime.fromtimestamp(ts, tz=timezone.utc)
        .replace(hour=0, minute=0, second=0, microsecond=0)
        .timestamp()
    )


# ------------------------------------------------------------------ #
# CheckAliveError / CheckAliveAfterDeliveryError
# ------------------------------------------------------------------ #


def test_check_alive_error_default():
    err = CheckAliveError(1000000)
    assert err.timestamp_to_check == 1000000
    assert err.reason is None


def test_check_alive_error_str():
    err = CheckAliveError(1000000)
    s = str(err)
    assert "Check alive expired" in s
    assert "1970" in s


def test_check_alive_error_str_with_reason():
    err = CheckAliveError(1000000, reason="too early")
    assert "too early" in str(err)


def test_check_alive_error_subclass():
    assert issubclass(CheckAliveError, Exception)


def test_check_alive_after_delivery_error_is_sibling():
    # NOT a subclass of CheckAliveError: the existing ``except CheckAliveError``
    # handlers must not invalidate the will for this configuration error.
    assert not issubclass(CheckAliveAfterDeliveryError, CheckAliveError)
    err = CheckAliveAfterDeliveryError(2000, 1000)
    assert err.timestamp_to_check == 2000
    assert err.delivery_timestamp == 1000
    assert "delivery" in str(err)


# ------------------------------------------------------------------ #
# resolve_delivery_date
# ------------------------------------------------------------------ #


def test_delivery_absolute_locktime():
    settings = {"locktime": 1_800_000_000}
    assert resolve_delivery_date(settings) == 1_800_000_000


def test_delivery_relative_locktime_resolved_from_now():
    fake_now = 1_800_000_000.0
    settings = {"locktime": "90d"}
    result = resolve_delivery_date(settings, now=fake_now)
    expected = _midnight(fake_now) + 90 * 86400
    assert abs(result - expected) < 1


def test_delivery_relative_locktime_anchored_to_built_tx():
    frozen = 1817424000
    settings = {"locktime": "2y"}
    result = resolve_delivery_date(
        settings, now=1_800_000_000.0, built_locktime=frozen
    )
    assert result == frozen


def test_delivery_missing_locktime_returns_none():
    assert resolve_delivery_date({}) is None


# ------------------------------------------------------------------ #
# resolve_relative_check_alive_date (the single calculation rule)
# ------------------------------------------------------------------ #


def test_relative_negative_anchors_to_delivery():
    fake_now = 1_800_000_000.0
    delivery = fake_now + 90 * 86400
    result = resolve_relative_check_alive_date(
        "-30d", delivery_date=delivery, creation_date=fake_now, now=fake_now
    )
    expected = _midnight(delivery) - 30 * 86400
    assert abs(result - expected) < 1
    assert result < delivery


def test_relative_positive_anchors_to_creation():
    fake_now = 1_800_000_000.0
    creation = fake_now + 5 * 86400
    delivery = fake_now + 365 * 86400
    result = resolve_relative_check_alive_date(
        "30d", delivery_date=delivery, creation_date=creation, now=fake_now
    )
    expected = _midnight(creation) + 30 * 86400
    assert abs(result - expected) < 1
    # The delivery anchor is irrelevant for a positive value.
    assert result < delivery


def test_relative_positive_without_creation_falls_back_to_now():
    fake_now = 1_800_000_000.0
    result = resolve_relative_check_alive_date(
        "30d", delivery_date=fake_now + 365 * 86400, creation_date=None, now=fake_now
    )
    expected = _midnight(fake_now) + 30 * 86400
    assert abs(result - expected) < 1


def test_relative_negative_without_delivery_falls_back_to_now():
    fake_now = 1_800_000_000.0
    result = resolve_relative_check_alive_date(
        "-30d", delivery_date=None, creation_date=fake_now, now=fake_now
    )
    expected = _midnight(fake_now) - 30 * 86400
    assert abs(result - expected) < 1


def test_relative_absolute_value_returned_unchanged():
    assert resolve_relative_check_alive_date(1_700_000_000, None, None) == 1_700_000_000


# ------------------------------------------------------------------ #
# resolve_date_to_check
# ------------------------------------------------------------------ #


def test_basic_mode_uses_now():
    fake_now = 1_800_000_000.0
    assert resolve_date_to_check(True, {}, now=fake_now) == fake_now


def test_advanced_mode_uses_threshold_absolute():
    threshold = time.time() + 5 * 86400
    settings = {"threshold": threshold}
    result = resolve_date_to_check(False, settings)
    assert abs(result - threshold) < 1


def test_advanced_mode_negative_relative_anchored_to_delivery():
    fake_now = 1_800_000_000.0
    locktime = fake_now + 90 * 86400
    settings = {"threshold": "-30d", "locktime": locktime}
    result = resolve_date_to_check(False, settings, now=fake_now)
    expected = _midnight(locktime) - 30 * 86400
    assert abs(result - expected) < 1
    assert result > fake_now


def test_advanced_mode_positive_relative_anchored_to_creation():
    fake_now = 1_800_000_000.0
    creation = fake_now + 10 * 86400
    locktime = fake_now + 365 * 86400
    settings = {"threshold": "30d", "locktime": locktime}
    result = resolve_date_to_check(
        False, settings, now=fake_now, creation_date=creation
    )
    expected = _midnight(creation) + 30 * 86400
    assert abs(result - expected) < 1


def test_advanced_mode_negative_relative_never_drifts():
    """A negative relative threshold anchored to a fixed absolute delivery does
    not drift with the clock."""
    fake_now = 1_800_000_000.0
    locktime = fake_now + 90 * 86400
    settings = {"threshold": "-30d", "locktime": locktime}
    first = resolve_date_to_check(False, settings, now=fake_now)
    second = resolve_date_to_check(False, settings, now=fake_now + 86400)
    assert first == second


def test_advanced_mode_positive_relative_creation_never_drifts():
    """A positive relative threshold anchored to the frozen creation date does
    not drift with the clock."""
    fake_now = 1_800_000_000.0
    creation = fake_now + 2 * 86400
    settings = {"threshold": "30d", "locktime": fake_now + 365 * 86400}
    first = resolve_date_to_check(
        False, settings, now=fake_now, creation_date=creation
    )
    second = resolve_date_to_check(
        False, settings, now=fake_now + 5 * 86400, creation_date=creation
    )
    assert first == second


def test_advanced_mode_relative_locktime_anchored_to_built_tx():
    """A RELATIVE stored locktime is anchored to the built will's frozen
    delivery date (built_locktime), not to "now": an unchanged will must not
    read as expired as the clock advances (the karen7 daily-invalidate bug)."""
    frozen = 1817424000  # frozen tx locktime, built 2026-08-05
    settings = {"threshold": "-30d", "locktime": "2y"}
    first = resolve_date_to_check(
        False, settings, now=1_800_000_000.0, built_locktime=frozen
    )
    assert abs(first - (frozen - 30 * 86400)) < 1
    later = resolve_date_to_check(
        False, settings, now=1_800_000_000.0 + 10 * 86400, built_locktime=frozen
    )
    assert first == later
    assert first < frozen


def test_advanced_mode_relative_locktime_without_built_tx_falls_back():
    fake_now = 1_800_000_000.0
    settings = {"threshold": "-30d", "locktime": "90d"}
    result = resolve_date_to_check(False, settings, now=fake_now)
    locktime_dt = BalTimestamp("90d").to_date(fake_now)
    expected = BalTimestamp("-30d").to_date(locktime_dt).timestamp()
    assert abs(result - expected) < 1


# ------------------------------------------------------------------ #
# resolve_guard_threshold
# ------------------------------------------------------------------ #


def test_guard_threshold_basic_mode_returns_none():
    fake_now = 1_800_000_000.0
    threshold = resolve_guard_threshold(True, {"threshold": "-30d"}, now=fake_now)
    assert threshold is None


def _guard_locktime(settings, fake_now):
    """Reproduce the call-site locktime expression of the guard."""
    return BalTimestamp(settings["locktime"]).to_timestamp(fake_now)


def test_guard_threshold_absolute():
    fake_now = 1_800_000_000.0
    locktime = fake_now + 90 * 86400
    threshold = locktime - 30 * 86400
    settings = {"locktime": locktime, "threshold": threshold}
    assert resolve_guard_threshold(False, settings, now=fake_now) == threshold


def test_guard_threshold_negative_relative_fresh_anchor():
    """A negative relative threshold is anchored to the FRESH locktime so the
    guard and the settings always share one reference frame."""
    fake_now = 1_800_000_000.0
    settings = {"locktime": "1y", "threshold": "-30d"}
    locktime = _guard_locktime(settings, fake_now)
    threshold = resolve_guard_threshold(False, settings, now=fake_now)
    assert threshold is not None
    assert locktime > threshold  # internally consistent: no fire
    assert threshold > fake_now


def test_guard_threshold_positive_relative_anchored_to_creation():
    fake_now = 1_800_000_000.0
    creation = fake_now + 4 * 86400
    settings = {"locktime": "1y", "threshold": "30d"}
    threshold = resolve_guard_threshold(
        False, settings, now=fake_now, creation_date=creation
    )
    expected = _midnight(creation) + 30 * 86400
    assert abs(threshold - expected) < 1


def test_guard_threshold_missing_returns_none():
    fake_now = 1_800_000_000.0
    assert resolve_guard_threshold(False, {"locktime": "1y"}, now=fake_now) is None


# ------------------------------------------------------------------ #
# is_check_alive_date_valid / ensure_check_alive_valid
# ------------------------------------------------------------------ #


def test_is_valid_inside_window():
    now = 1_800_000_000.0
    assert is_check_alive_date_valid(now + 100, now + 1000, now=now) is True


def test_is_valid_rejects_past():
    now = 1_800_000_000.0
    assert is_check_alive_date_valid(now - 100, now + 1000, now=now) is False


def test_is_valid_rejects_on_or_after_delivery():
    now = 1_800_000_000.0
    delivery = now + 1000
    assert is_check_alive_date_valid(delivery, delivery, now=now) is False
    assert is_check_alive_date_valid(delivery + 1, delivery, now=now) is False


def test_is_valid_without_delivery_skips_upper_bound():
    now = 1_800_000_000.0
    assert is_check_alive_date_valid(now + 100, None, now=now) is True


def test_is_valid_none_is_false():
    assert is_check_alive_date_valid(None, 1000) is False


def test_basic_mode_never_expired():
    assert ensure_check_alive_valid(True, time.time() - 10_000) is None
    assert ensure_check_alive_valid(True, 1_000_000_000.0) is None


def test_advanced_raises_when_past():
    try:
        ensure_check_alive_valid(False, time.time() - 10_000)
    except CheckAliveError:
        pass
    else:
        raise AssertionError("expected CheckAliveError")


def test_advanced_raises_when_after_delivery():
    now = time.time()
    try:
        ensure_check_alive_valid(False, now + 100, delivery_date=now + 50)
    except CheckAliveAfterDeliveryError:
        pass
    else:
        raise AssertionError("expected CheckAliveAfterDeliveryError")


def test_advanced_valid_does_not_raise():
    now = time.time()
    assert ensure_check_alive_valid(False, now + 100, delivery_date=now + 1000) is None


# ------------------------------------------------------------------ #
# Will.get_creation_time
# ------------------------------------------------------------------ #


class _FakeWillItem:
    def __init__(self, time_value, valid=True):
        self.time = time_value
        self._valid = valid

    def get_status(self, status):
        return self._valid if status == "VALID" else False


def test_get_creation_time_min_of_valid_items():
    will = {
        "a": _FakeWillItem(2000),
        "b": _FakeWillItem(1000),
        "c": _FakeWillItem(3000),
    }
    assert Will.get_creation_time(will) == 1000


def test_get_creation_time_ignores_invalid_and_none():
    will = {
        "a": _FakeWillItem(500, valid=False),
        "b": _FakeWillItem(None),
        "c": _FakeWillItem(2000),
    }
    assert Will.get_creation_time(will) == 2000


def test_get_creation_time_empty_returns_none():
    assert Will.get_creation_time({}) is None


# ------------------------------------------------------------------ #
# Main
# ------------------------------------------------------------------ #

if __name__ == "__main__":
    for name in sorted(dir()):
        if name.startswith("test_"):
            globals()[name]()
            print(f"  [OK] {name}")
    print("[OK] All core checkalive tests passed")