"""核心链路回归：心跳超时、任务校验、产出公式、提现余额。"""

from __future__ import annotations

import os
import tempfile
import unittest
import uuid
from datetime import datetime, timedelta, timezone
from decimal import Decimal
from pathlib import Path

_db_path = Path(tempfile.gettempdir()) / "depin_core_flow.db"
os.environ["DATABASE_URL"] = "sqlite:///" + _db_path.as_posix()
os.environ["DISABLE_SCHEDULER"] = "1"
os.environ["JWT_SECRET"] = "test-secret-test-secret-test-secret"
os.environ["ADMIN_USERNAME"] = "admin"
os.environ["ADMIN_PASSWORD"] = "test-admin-pass"
os.environ["ADMIN_WALLET"] = "admin-root"

from fastapi.testclient import TestClient
from sqlalchemy import select

from app.clock import utcnow
from app.database import Base, SessionLocal, engine
from app.main import app
from app.jobs.daily_yield import run_daily_yield_cron
from app.money import money
from app.models import (
    ComputeNode,
    ComputeTask,
    IPWhitelist,
    NodeStatus,
    NodeYield,
    PushStatus,
    TaskStatus,
    UptimeInterval,
    YieldStatus,
)
from app.services.heartbeat import mark_stale_nodes
from app.services.datacenter import FINGERPRINT_CLASH
from app.services.ip_guard import DATACENTER_BATCH_MESSAGE
from app.services.tasks import dispatch_random_tasks


class CoreFlowTest(unittest.TestCase):
    def setUp(self) -> None:
        Base.metadata.drop_all(bind=engine)
        Base.metadata.create_all(bind=engine)
        self.client_cm = TestClient(app)
        self.client = self.client_cm.__enter__()
        with SessionLocal() as session:
            session.add(IPWhitelist(ip_address="testclient", note="unit test", created_at=utcnow()))
            session.commit()

    def tearDown(self) -> None:
        self.client_cm.__exit__(None, None, None)

    def test_heartbeat_goes_offline_after_timeout(self) -> None:
        self._register("0xabc", "NODE-A", "100")
        beat = self.client.post("/api/v1/node/heartbeat", json={"sn": "NODE-A"})
        self.assertEqual(beat.status_code, 200, beat.text)
        self.assertEqual(beat.json()["status"], "online")

        recent = utcnow() - timedelta(minutes=1)
        self._shift_presence("NODE-A", recent)
        with SessionLocal() as session:
            mark_stale_nodes(session, utcnow())
            session.commit()
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-A"))
            self.assertEqual(node.status, NodeStatus.ONLINE)

        stale_at = utcnow() - timedelta(minutes=30)
        self._shift_presence("NODE-A", stale_at)
        with SessionLocal() as session:
            changed = mark_stale_nodes(session, utcnow())
            session.commit()
            self.assertEqual(changed, ["NODE-A"])
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-A"))
            interval = session.scalar(select(UptimeInterval).where(UptimeInterval.node_id == node.id))
            self.assertEqual(node.status, NodeStatus.OFFLINE)
            self.assertEqual(interval.ended_at, node.last_heartbeat_at)
            self.assertAlmostEqual((utcnow() - interval.ended_at).total_seconds(), 1800, delta=5)
            self.assertEqual(interval.close_reason, "heartbeat_timeout")

        expired = self.client.post("/api/v1/node/heartbeat", json={"sn": "NODE-A"})
        self.assertEqual(expired.status_code, 200, expired.text)

        with SessionLocal() as session:
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-A"))
            node.license_expires_at = utcnow() - timedelta(minutes=1)
            session.commit()
        denied = self.client.post("/api/v1/node/heartbeat", json={"sn": "NODE-A"})
        self.assertEqual(denied.status_code, 403, denied.text)

    def test_task_report_requires_nonce(self) -> None:
        self._register("0xdef", "NODE-T", "50")
        self.client.post("/api/v1/node/heartbeat", json={"sn": "NODE-T"})
        with SessionLocal() as session:
            tasks = dispatch_random_tasks(session)
            session.commit()
            task_id = tasks[0].id
            nonce = tasks[0].payload["nonce"]

        pending = self.client.get("/api/v1/node/NODE-T/tasks")
        self.assertEqual(pending.status_code, 200, pending.text)
        self.assertEqual(pending.json()[0]["task_id"], task_id)

        rejected = self.client.post(
            "/api/v1/node/task/report",
            json={"sn": "NODE-T", "task_id": task_id, "success": True, "nonce": "0" * 32},
        )
        self.assertEqual(rejected.status_code, 400, rejected.text)

        accepted = self.client.post(
            "/api/v1/node/task/report",
            json={"sn": "NODE-T", "task_id": task_id, "success": True, "nonce": nonce},
        )
        self.assertEqual(accepted.status_code, 200, accepted.text)
        self.assertEqual(accepted.json()["status"], "completed")

        duplicated = self.client.post(
            "/api/v1/node/task/report",
            json={"sn": "NODE-T", "task_id": task_id, "success": True, "nonce": nonce},
        )
        self.assertEqual(duplicated.status_code, 409, duplicated.text)

    def test_daily_yield_uses_uptime_and_task_response(self) -> None:
        yesterday = (utcnow() - timedelta(days=1)).date()
        day_start = utcnow().replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=1)
        day_end = day_start + timedelta(days=1)
        for wallet, sn in (("0xaaa", "NODE-FULL"), ("0xbbb", "NODE-NOTASK"), ("0xccc", "NODE-MISS")):
            self._register(wallet, sn, "365")
            self._cover_full_day(sn, day_start, day_end)

        with SessionLocal() as session:
            full = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-FULL"))
            miss = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-MISS"))
            session.add(self._task(full.id, TaskStatus.COMPLETED, day_start))
            session.add(self._task(miss.id, TaskStatus.FAILED, day_start))
            session.commit()

        settled = self.client.post(
            "/api/v1/yield/settle",
            headers=self._admin_headers(),
            params={"yield_date": yesterday.isoformat()},
        )
        self.assertEqual(settled.status_code, 200, settled.text)
        self.assertEqual(settled.json()["created"], 3)

        full_row = self._yield_row("NODE-FULL")
        idle_row = self._yield_row("NODE-NOTASK")
        miss_row = self._yield_row("NODE-MISS")
        self.assertEqual(full_row.online_rate, Decimal("1.00000000"))
        self.assertEqual(full_row.task_response_rate, Decimal("1.00000000"))
        self.assertEqual(full_row.performance, Decimal("1.00000000"))
        self.assertEqual(full_row.points_delta, money(Decimal(365) / Decimal(30)))
        self.assertEqual(full_row.compute_output, Decimal("365.00000000"))
        self.assertEqual(full_row.online_weight, Decimal("0.70000000"))

        self.assertEqual(idle_row.tasks_dispatched, 0)
        self.assertEqual(idle_row.performance, Decimal("1.00000000"))
        self.assertEqual(idle_row.points_delta, money(Decimal(365) / Decimal(30)))
        self.assertEqual(idle_row.online_weight, Decimal("1.00000000"))

        self.assertEqual(miss_row.task_response_rate, Decimal("0.00000000"))
        self.assertEqual(miss_row.performance, Decimal("0.70000000"))
        self.assertEqual(miss_row.points_delta, money(Decimal(365) / Decimal(30) * Decimal("0.7")))
        self.assertEqual(miss_row.compute_output, Decimal("255.50000000"))

        again = self.client.post(
            "/api/v1/yield/settle",
            headers=self._admin_headers(),
            params={"yield_date": yesterday.isoformat()},
        )
        self.assertEqual(again.json()["created"], 0)
        self.assertEqual(again.json()["skipped"], 3)

        future = self.client.post(
            "/api/v1/yield/settle",
            headers=self._admin_headers(),
            params={"yield_date": "2999-01-01"},
        )
        self.assertEqual(future.status_code, 400, future.text)

    def test_open_interval_stops_at_last_heartbeat(self) -> None:
        yesterday = (utcnow() - timedelta(days=1)).date()
        day_start = utcnow().replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=1)
        self._register("0xhalf", "NODE-HALF", "365")
        noon = day_start + timedelta(hours=12)
        with SessionLocal() as session:
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-HALF"))
            node.licensed_at = day_start
            node.license_expires_at = day_start + timedelta(days=365)
            node.last_heartbeat_at = noon
            session.add(UptimeInterval(node_id=node.id, started_at=day_start, ended_at=None))
            session.commit()

        settled = self.client.post(
            "/api/v1/yield/settle",
            headers=self._admin_headers(),
            params={"yield_date": yesterday.isoformat()},
        )
        self.assertEqual(settled.status_code, 200, settled.text)
        row = self._yield_row("NODE-HALF")
        self.assertEqual(row.online_seconds, 12 * 60 * 60)
        self.assertEqual(row.online_rate, Decimal("0.50000000"))
        self.assertEqual(row.points_delta, money(Decimal(365) / Decimal(30) * Decimal("0.5")))

    def test_daily_cron_writes_previous_closed_day(self) -> None:
        # 北京时间 2026-10-12 00:05，对应上一个已结束的 UTC 账本日 2026-10-10。
        moment = datetime(2026, 10, 11, 16, 5, tzinfo=timezone.utc)
        day_start = datetime(2026, 10, 10, tzinfo=timezone.utc)
        self._register("0xcron", "NODE-CRON", "365")
        self._cover_full_day("NODE-CRON", day_start, day_start + timedelta(days=1))

        summary = run_daily_yield_cron(now=moment)
        self.assertEqual(summary.yield_date.isoformat(), "2026-10-10")
        self.assertEqual(summary.created, 1)
        self.assertFalse(summary.is_partial)
        row = self._yield_row("NODE-CRON")
        self.assertEqual(row.status, YieldStatus.SETTLED)
        self.assertEqual(row.points_delta, money(Decimal(365) / Decimal(30)))
        self.assertEqual(row.compute_output, Decimal("365.00000000"))

        again = run_daily_yield_cron(now=moment)
        self.assertEqual(again.created, 0)
        self.assertEqual(again.skipped, 1)

    def test_withdrawal_reserves_balance_until_rejected_or_confirmed(self) -> None:
        yesterday = (utcnow() - timedelta(days=1)).date()
        day_start = utcnow().replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=1)
        self._register("0xpay", "NODE-PAY", "365")
        self._cover_full_day("NODE-PAY", day_start, day_start + timedelta(days=1))
        payer = self._auth("0xpay")
        settled = self.client.post(
            "/api/v1/yield/settle",
            headers=self._admin_headers(),
            params={"yield_date": yesterday.isoformat()},
        )
        self.assertEqual(settled.status_code, 200, settled.text)

        too_much = self.client.post(
            "/api/v1/withdrawals",
            headers=payer,
            json={"wallet_address": "0xpay", "amount": "100"},
        )
        self.assertEqual(too_much.status_code, 400, too_much.text)

        created = self.client.post(
            "/api/v1/withdrawals",
            headers=payer,
            json={"wallet_address": "0xpay", "amount": "0.4", "asset_symbol": "POINT"},
        )
        self.assertEqual(created.status_code, 200, created.text)
        withdrawal_id = created.json()["id"]
        released = money(Decimal(365) / Decimal(30))
        self.assertEqual(created.json()["available_after"], format(money(released - Decimal("0.4")), "f"))

        blocked = self.client.post(
            "/api/v1/withdrawals",
            headers=payer,
            json={"wallet_address": "0xpay", "amount": "12"},
        )
        self.assertEqual(blocked.status_code, 400, blocked.text)

        confirmed = self.client.post(
            f"/api/v1/withdrawals/{withdrawal_id}/confirm",
            headers=self._admin_headers(),
            json={"tx_hash": "0xabc123"},
        )
        self.assertEqual(confirmed.status_code, 200, confirmed.text)
        self.assertEqual(confirmed.json()["status"], "completed")
        self.assertEqual(confirmed.json()["tx_hash"], "0xabc123")

        balance = self.client.get("/api/v1/users/0xpay/balance", headers=self._auth("0xpay"))
        self.assertEqual(balance.json()["available_points"], format(money(released - Decimal("0.4")), "f"))

    def test_roles_split_user_and_admin(self) -> None:
        registered = self.client.post(
            "/api/v1/auth/register",
            json={"wallet_address": "0xuser01", "username": "miner", "password": "secret1"},
        )
        self.assertEqual(registered.status_code, 200, registered.text)
        self.assertEqual(registered.json()["role"], "user")
        token = registered.json()["access_token"]
        user_headers = {"Authorization": f"Bearer {token}"}

        by_wallet = self.client.post("/api/v1/auth/login", json={"wallet_address": "0xuser01"})
        self.assertEqual(by_wallet.status_code, 200, by_wallet.text)
        by_password = self.client.post(
            "/api/v1/auth/login",
            json={"username": "miner", "password": "secret1"},
        )
        self.assertEqual(by_password.status_code, 200, by_password.text)

        denied = self.client.get("/api/v1/admin/users", headers=user_headers)
        self.assertEqual(denied.status_code, 403, denied.text)
        opened = self.client.get("/api/v1/admin/summary", headers=self._admin_headers())
        self.assertEqual(opened.status_code, 200, opened.text)
        self.assertGreaterEqual(opened.json()["users"], 1)

        wallet_admin = self.client.post("/api/v1/auth/login", json={"wallet_address": "admin-root"})
        self.assertEqual(wallet_admin.status_code, 403, wallet_admin.text)

    def test_order_stays_locked_until_admin_approves(self) -> None:
        registered = self.client.post(
            "/api/v1/auth/register",
            json={"wallet_address": "0xbuyer01", "username": "buyer", "password": "secret1"},
        )
        self.assertEqual(registered.status_code, 200, registered.text)
        headers = {"Authorization": f"Bearer {registered.json()['access_token']}"}

        created = self.client.post("/api/v1/me/orders", headers=headers, json={"tx_id": "paytx1500usdt01"})
        self.assertEqual(created.status_code, 200, created.text)
        self.assertEqual(created.json()["status"], "pending")
        self.assertEqual(created.json()["amount"], "1500.00000000")
        order_id = created.json()["id"]

        denied = self.client.post(f"/api/v1/admin/orders/{order_id}/approve", headers=headers)
        self.assertEqual(denied.status_code, 403, denied.text)
        board = self.client.get("/api/v1/me/dashboard", headers=headers)
        self.assertEqual(board.status_code, 200, board.text)
        self.assertEqual(board.json()["orders"][0]["status"], "pending")
        self.assertEqual(board.json()["nodes"], [])

        approved = self.client.post(f"/api/v1/admin/orders/{order_id}/approve", headers=self._admin_headers())
        self.assertEqual(approved.status_code, 200, approved.text)
        self.assertEqual(approved.json()["status"], "approved")
        sn = approved.json()["sn"]
        self.assertTrue(sn)

        board = self.client.get("/api/v1/me/dashboard", headers=headers)
        node = board.json()["nodes"][0]
        self.assertEqual(node["sn"], sn)
        self.assertEqual(node["display_node_id"], 1001)
        self.assertTrue(node["genesis"])
        self.assertEqual(node["recovery_days"], 30)
        self.assertEqual(board.json()["network_nodes"], 1001)
        self.assertTrue(node["activated"])
        self.assertTrue(node["node_token"])
        self.assertEqual(node["license_months"], 12)

        missing = self.client.post("/api/v1/node/heartbeat", json={"sn": sn})
        self.assertEqual(missing.status_code, 403, missing.text)
        beat = self.client.post("/api/v1/node/heartbeat", json={"sn": sn, "token": node["node_token"]})
        self.assertEqual(beat.status_code, 200, beat.text)
        self.assertEqual(beat.json()["status"], "online")

        client = self.client.get(f"/api/v1/me/nodes/{sn}/client", headers=headers)
        self.assertEqual(client.status_code, 200, client.text)
        self.assertIn(node["node_token"], client.text)
        self.assertIn("nvidia-smi", client.text)
        self.assertIn("pynvml", client.text)

        duplicated = self.client.post("/api/v1/me/orders", headers=headers, json={"tx_id": "paytx1500usdt01"})
        self.assertEqual(duplicated.status_code, 409, duplicated.text)
        rejected_order = self.client.post("/api/v1/me/orders", headers=headers, json={"tx_id": "paytxrejected01"})
        self.assertEqual(rejected_order.status_code, 200, rejected_order.text)
        rejected = self.client.post(
            f"/api/v1/admin/orders/{rejected_order.json()['id']}/reject",
            headers=self._admin_headers(),
            json={"note": "凭证无效"},
        )
        self.assertEqual(rejected.status_code, 200, rejected.text)
        self.assertEqual(rejected.json()["status"], "rejected")
        self.assertIsNone(rejected.json()["sn"])

    def test_gpu_generation_locks_recovery_and_releases_stake(self) -> None:
        from app.services.hardware import classify_generation, score_hardware

        self.assertEqual(classify_generation("NVIDIA GeForce RTX 4090"), ("40", 210))
        self.assertEqual(classify_generation("NVIDIA GeForce RTX 4070"), ("40", 210))
        self.assertEqual(classify_generation("NVIDIA GeForce RTX 3060 Ti"), ("30", 365))
        self.assertEqual(classify_generation("NVIDIA GeForce RTX 3060"), ("30", 365))
        self.assertEqual(classify_generation("NVIDIA GeForce GTX 1080"), ("10", 540))
        self.assertEqual(classify_generation("NVIDIA GeForce GTX 1050"), ("10", 540))
        self.assertEqual(classify_generation("Intel UHD Graphics 630"), ("10", 540))
        self.assertEqual(score_hardware("NVIDIA GeForce RTX 3060 Ti", 8), Decimal("1"))

        yesterday = (utcnow() - timedelta(days=1)).date()
        day_start = utcnow().replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=1)
        day_end = day_start + timedelta(days=1)
        self._register("0xgen", "NODE-GEN", "1500")
        for index in range(19):
            self._register(f"0xpad{index:02d}", f"PAD-{index:02d}", "1500")
        self._register("0x40", "NODE-40", "1500")
        self._register("0x10", "NODE-10", "1500")
        self._cover_full_day("NODE-GEN", day_start, day_end)
        self._cover_full_day("NODE-40", day_start, day_end)
        self._cover_full_day("NODE-10", day_start, day_end)

        genesis = self.client.post(
            "/api/v1/node/heartbeat",
            json={"sn": "NODE-GEN", "gpu_model": "NVIDIA GeForce RTX 4090", "vram_gb": 24},
        )
        self.assertEqual(genesis.status_code, 200, genesis.text)
        self.assertEqual(genesis.json()["display_node_id"], 1001)
        self.assertEqual(genesis.json()["gpu_generation"], "40")
        self.assertEqual(genesis.json()["recovery_days"], 30)
        still = self.client.post(
            "/api/v1/node/heartbeat",
            json={"sn": "NODE-GEN", "gpu_model": "NVIDIA GeForce GTX 1050", "vram_gb": 2},
        )
        self.assertEqual(still.json()["recovery_days"], 30)

        high = self.client.post(
            "/api/v1/node/heartbeat",
            json={"sn": "NODE-40", "gpu_model": "NVIDIA GeForce RTX 4090", "vram_gb": 24, "cpu_count": 16, "memory_gb": 64},
        )
        self.assertEqual(high.status_code, 200, high.text)
        self.assertEqual(high.json()["display_node_id"], 1021)
        self.assertEqual(high.json()["gpu_generation"], "40")
        self.assertEqual(high.json()["recovery_days"], 210)
        self.assertEqual(high.json()["recoverable_stake_amount"], "1500.00000000")
        locked = self.client.post(
            "/api/v1/node/heartbeat",
            json={"sn": "NODE-40", "gpu_model": "NVIDIA GeForce GTX 1050", "vram_gb": 2},
        )
        self.assertEqual(locked.json()["gpu_generation"], "40")
        self.assertEqual(locked.json()["recovery_days"], 210)

        low = self.client.post(
            "/api/v1/node/heartbeat",
            json={"sn": "NODE-10", "gpu_model": "NVIDIA GeForce GTX 1050", "vram_gb": 2},
        )
        self.assertEqual(low.status_code, 200, low.text)
        self.assertEqual(low.json()["display_node_id"], 1022)
        self.assertEqual(low.json()["gpu_generation"], "10")
        self.assertEqual(low.json()["recovery_days"], 540)

        settled = self.client.post(
            "/api/v1/yield/settle",
            headers=self._admin_headers(),
            params={"yield_date": yesterday.isoformat()},
        )
        self.assertEqual(settled.status_code, 200, settled.text)
        genesis_points = money(Decimal(1500) / Decimal(30))
        high_points = money(Decimal(1500) / Decimal(210))
        low_points = money(Decimal(1500) / Decimal(540))
        self.assertEqual(genesis_points, Decimal("50.00000000"))
        self.assertEqual(self._yield_row("NODE-GEN").points_delta, genesis_points)
        self.assertEqual(self._yield_row("NODE-40").points_delta, high_points)
        self.assertEqual(self._yield_row("NODE-10").points_delta, low_points)
        with SessionLocal() as session:
            first = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-GEN"))
            fast = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-40"))
            slow = session.scalar(select(ComputeNode).where(ComputeNode.sn == "NODE-10"))
            self.assertEqual(first.recoverable_stake_amount, money(Decimal(1500) - genesis_points))
            self.assertEqual(fast.recoverable_stake_amount, money(Decimal(1500) - high_points))
            self.assertEqual(slow.recoverable_stake_amount, money(Decimal(1500) - low_points))
            self.assertGreater(slow.license_expires_at, fast.license_expires_at)
        population = self.client.get("/api/v1/network")
        self.assertEqual(population.status_code, 200, population.text)
        self.assertEqual(population.json()["nodes"], 1022)

    def test_whitelist_skips_single_ip_limit(self) -> None:
        shared = {"X-Real-IP": "203.0.113.10"}
        self._register("0xip1", "NODE-IP1", "1500", headers=shared)
        blocked = self.client.post(
            "/api/v1/users",
            json={"wallet_address": "0xip2"},
        )
        self.assertEqual(blocked.status_code, 200, blocked.text)
        denied = self.client.post(
            "/api/v1/nodes",
            headers={**self._auth("0xip2"), **shared},
            json={"wallet_address": "0xip2", "sn": "NODE-IP2", "purchase_amount": "1500"},
        )
        self.assertEqual(denied.status_code, 409, denied.text)
        self.assertEqual(denied.json()["detail"], DATACENTER_BATCH_MESSAGE)

        added = self.client.post(
            "/api/v1/admin/ip-whitelist",
            headers=self._admin_headers(),
            json={"ip_address": "203.0.113.10", "note": "机房出口"},
        )
        self.assertEqual(added.status_code, 200, added.text)
        allowed = self.client.post(
            "/api/v1/nodes",
            headers={**self._auth("0xip2"), **shared},
            json={"wallet_address": "0xip2", "sn": "NODE-IP2", "purchase_amount": "1500"},
        )
        self.assertEqual(allowed.status_code, 200, allowed.text)

        self._register("0xip3", "NODE-IP3", "1500", headers={"X-Real-IP": "203.0.113.21"})
        crowded = self.client.post(
            "/api/v1/node/heartbeat",
            headers={"X-Real-IP": "203.0.113.21"},
            json={"sn": "NODE-IP1"},
        )
        self.assertEqual(crowded.status_code, 409, crowded.text)
        marked = self.client.post(
            "/api/v1/admin/nodes/NODE-IP1/whitelist",
            headers=self._admin_headers(),
            json={"is_whitelist": True},
        )
        self.assertEqual(marked.status_code, 200, marked.text)
        self.assertTrue(marked.json()["is_whitelist"])
        mounted = self.client.post(
            "/api/v1/node/heartbeat",
            headers={"X-Real-IP": "203.0.113.21"},
            json={"sn": "NODE-IP1"},
        )
        self.assertEqual(mounted.status_code, 200, mounted.text)

        removed = self.client.delete(
            f"/api/v1/admin/ip-whitelist/{added.json()['id']}",
            headers=self._admin_headers(),
        )
        self.assertEqual(removed.status_code, 200, removed.text)
        listing = self.client.get("/api/v1/admin/ip-whitelist", headers=self._admin_headers())
        self.assertNotIn("203.0.113.10", [row["ip_address"] for row in listing.json()])

    def test_datacenter_subnet_and_hardware_fingerprint(self) -> None:
        fingerprint = "a" * 64
        other = "b" * 64
        registered = self.client.post(
            "/api/v1/auth/register",
            json={"wallet_address": "0xdc01", "username": "room", "password": "secret1"},
        )
        self.assertEqual(registered.status_code, 200, registered.text)
        headers = {"Authorization": f"Bearer {registered.json()['access_token']}"}
        short = self.client.post(
            "/api/v1/me/datacenter-applications",
            headers=headers,
            json={
                "contact": "room@example.com",
                "node_count": 4,
                "subnet_ip": "198.51.100.0/24",
                "hardware_proof": "RTX 4090 x 4",
                "gpu_generation": "40",
            },
        )
        self.assertEqual(short.status_code, 400, short.text)
        self.assertEqual(short.json()["detail"], DATACENTER_BATCH_MESSAGE)
        low = self.client.post(
            "/api/v1/me/datacenter-applications",
            headers=headers,
            json={
                "contact": "room@example.com",
                "node_count": 8,
                "subnet_ip": "198.51.100.0/24",
                "hardware_proof": "GTX 1080 x 8",
                "gpu_generation": "40",
            },
        )
        self.assertEqual(low.status_code, 400, low.text)
        created = self.client.post(
            "/api/v1/me/datacenter-applications",
            headers=headers,
            json={
                "contact": "room@example.com",
                "node_count": 8,
                "subnet_ip": "198.51.100.10/24",
                "hardware_proof": "8 台 RTX 4090",
                "gpu_generation": "40",
            },
        )
        self.assertEqual(created.status_code, 200, created.text)
        self.assertEqual(created.json()["subnet_ip"], "198.51.100.0/24")
        self.assertEqual(created.json()["status"], "pending")
        approved = self.client.post(
            f"/api/v1/admin/datacenter-applications/{created.json()['id']}/approve",
            headers=self._admin_headers(),
        )
        self.assertEqual(approved.status_code, 200, approved.text)
        listed = self.client.get("/api/v1/admin/ip-whitelist", headers=self._admin_headers())
        self.assertIn("198.51.100.0/24", [row["ip_address"] for row in listed.json()])

        self._register("0xdc02", "NODE-DC1", "1500", headers={"X-Real-IP": "198.51.100.8"})
        self._register("0xdc03", "NODE-DC2", "1500", headers={"X-Real-IP": "198.51.100.9"})
        first = self.client.post(
            "/api/v1/node/heartbeat",
            headers={"X-Real-IP": "198.51.100.8"},
            json={"sn": "NODE-DC1", "gpu_model": "NVIDIA GeForce RTX 4090", "hardware_fingerprint": fingerprint},
        )
        self.assertEqual(first.status_code, 200, first.text)
        cloned = self.client.post(
            "/api/v1/node/heartbeat",
            headers={"X-Real-IP": "198.51.100.9"},
            json={"sn": "NODE-DC2", "gpu_model": "NVIDIA GeForce RTX 4090", "hardware_fingerprint": fingerprint},
        )
        self.assertEqual(cloned.status_code, 409, cloned.text)
        self.assertEqual(cloned.json()["detail"], FINGERPRINT_CLASH)
        second = self.client.post(
            "/api/v1/node/heartbeat",
            headers={"X-Real-IP": "198.51.100.9"},
            json={"sn": "NODE-DC2", "gpu_model": "NVIDIA GeForce RTX 3060", "hardware_fingerprint": other},
        )
        self.assertEqual(second.status_code, 200, second.text)
        cheap = self.client.post(
            "/api/v1/node/heartbeat",
            headers={"X-Real-IP": "198.51.100.9"},
            json={"sn": "NODE-DC2", "gpu_model": "NVIDIA GeForce GTX 1080", "hardware_fingerprint": other},
        )
        self.assertEqual(cheap.status_code, 409, cheap.text)
        self.assertEqual(cheap.json()["detail"], DATACENTER_BATCH_MESSAGE)

    def _auth(self, wallet: str) -> dict[str, str]:
        logged = self.client.post("/api/v1/auth/login", json={"wallet_address": wallet})
        self.assertEqual(logged.status_code, 200, logged.text)
        return {"Authorization": f"Bearer {logged.json()['access_token']}"}

    def _admin_headers(self) -> dict[str, str]:
        logged = self.client.post(
            "/api/v1/auth/login",
            json={"username": "admin", "password": "test-admin-pass"},
        )
        self.assertEqual(logged.status_code, 200, logged.text)
        self.assertEqual(logged.json()["role"], "admin")
        return {"Authorization": f"Bearer {logged.json()['access_token']}"}

    def _register(self, wallet: str, sn: str, amount: str, headers: dict[str, str] | None = None) -> None:
        user = self.client.post("/api/v1/users", json={"wallet_address": wallet})
        self.assertEqual(user.status_code, 200, user.text)
        node = self.client.post(
            "/api/v1/nodes",
            headers={**self._auth(wallet), **(headers or {})},
            json={"wallet_address": wallet, "sn": sn, "purchase_amount": amount},
        )
        self.assertEqual(node.status_code, 200, node.text)
        self.assertEqual(node.json()["status"], "offline")
        self.assertEqual(node.json()["license_months"], 12)

    def _shift_presence(self, sn: str, moment) -> None:
        with SessionLocal() as session:
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == sn))
            node.last_heartbeat_at = moment
            interval = session.scalar(
                select(UptimeInterval).where(
                    UptimeInterval.node_id == node.id,
                    UptimeInterval.ended_at.is_(None),
                )
            )
            interval.started_at = moment
            session.commit()

    def _cover_full_day(self, sn: str, day_start, day_end) -> None:
        with SessionLocal() as session:
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == sn))
            node.licensed_at = day_start
            node.license_expires_at = day_start + timedelta(days=365)
            session.add(UptimeInterval(node_id=node.id, started_at=day_start, ended_at=day_end))
            session.commit()

    def _task(self, node_id: int, status: TaskStatus, day_start) -> ComputeTask:
        return ComputeTask(
            id=str(uuid.uuid4()),
            node_id=node_id,
            task_type="simulated_compute",
            payload={"op": "simulated_compute", "nonce": "abc123abc123abcd", "seed": "seedseed"},
            status=status,
            push_status=PushStatus.QUEUED,
            dispatched_at=day_start + timedelta(hours=3),
            deadline_at=day_start + timedelta(hours=4),
            success=status == TaskStatus.COMPLETED,
        )

    def _yield_row(self, sn: str) -> NodeYield:
        with SessionLocal() as session:
            node = session.scalar(select(ComputeNode).where(ComputeNode.sn == sn))
            return session.scalar(select(NodeYield).where(NodeYield.node_id == node.id))


if __name__ == "__main__":
    unittest.main()