"""TDD: quota queries use musehub_object_refs, not musehub_objects.repo_id.

Coverage matrix:
    1. wire_push quota: exceeded quota is rejected (push/stream).
    2. get_repo_stats: total_objects and total_size_bytes use refs join.
    3. get_repo_stats: shared object counted once per repo.
"""
from __future__ import annotations

import secrets
from unittest.mock import patch

import msgpack
import pytest
import sqlalchemy as sa
from sqlalchemy.ext.asyncio import AsyncSession

from muse.core.types import blob_id, fake_id
from musehub.db import musehub_models as db
from musehub.types.json_types import JSONValue, StrDict
from tests.factories import create_repo


def _oid(raw: bytes) -> str:
    return blob_id(raw)


def _mp(data: JSONValue) -> bytes:
    return msgpack.packb(data, use_bin_type=True)


# ---------------------------------------------------------------------------
# Test 1: push rejected when quota exceeded
# ---------------------------------------------------------------------------

@pytest.mark.asyncio
async def test_push_rejected_when_quota_exceeded(
    db_session: AsyncSession,
) -> None:
    """wire_push_stream must reject pushes that would exceed per_repo_quota_bytes."""
    import msgpack
    from muse.core.mpack import MuseWireFrameWriter
    from musehub.services.musehub_wire import wire_push_stream
    from musehub.models.wire import SFRAME_HEADER, SFRAME_OBJECT, SFRAME_COMMIT_PACK, SFRAME_END

    raw = b"x" * 100
    oid = _oid(raw)
    repo = await create_repo(db_session, slug=f"quota-reject-{secrets.token_hex(4)}", owner="test-user-wire")

    fw = MuseWireFrameWriter()

    def _wrap(ft: str, data: JSONValue) -> bytes:
        return fw.wrap(frame_type=ft, payload=msgpack.packb(data, use_bin_type=True))

    body = (
        _wrap(SFRAME_HEADER, {"t": SFRAME_HEADER, "branch": "main", "force": False,
                               "have": [], "head": fake_id("push-head"), "n_objects": 1, "n_commits": 0})
        + _wrap(SFRAME_OBJECT, {"t": SFRAME_OBJECT, "id": oid, "content": raw, "path": "big.md", "enc": "raw"})
        + _wrap(SFRAME_COMMIT_PACK, {"t": SFRAME_COMMIT_PACK, "commits": [], "snapshots": []})
        + _wrap(SFRAME_END, {"t": SFRAME_END, "n_objects": 1, "n_commits": 0})
    )

    async def body_iter() -> None:
        yield body

    frames: list[dict] = []
    with patch("musehub.services.musehub_wire.settings") as mock_settings:
        mock_settings.per_repo_quota_bytes = 1  # 1 byte — always exceeded
        mock_settings.require_signed_commits = False
        mock_settings.trusted_agent_ids = []
        async for chunk in wire_push_stream(db_session, repo.repo_id, body_iter(), pusher_id="test-user-wire"):
            unpacker = msgpack.Unpacker(raw=False)
            unpacker.feed(chunk)
            frames.extend(list(unpacker))

    result = frames[-1] if frames else {}
    assert result.get("ok") is not True  # X frame (error) has no "ok"; R frame has ok=False
    msg = (result.get("msg") or result.get("message") or "").lower()
    assert "quota" in msg, f"rejection message must mention quota; got: {msg}"


# ---------------------------------------------------------------------------
# Test 2: get_repo_stats counts and sizes via refs join
# ---------------------------------------------------------------------------

@pytest.mark.asyncio
async def test_repo_stats_uses_refs_join(
    db_session: AsyncSession,
) -> None:
    """get_repo_stats total_objects and total_size_bytes must count via refs."""
    from musehub.services.musehub_repository import get_repo_home_stats

    repo = await create_repo(db_session, slug=f"stats-refs-{secrets.token_hex(4)}", owner="test-user-wire")

    # Insert an object + ref directly
    oid = _oid(b"stats test object content")
    obj = db.MusehubObject(
        object_id=oid,
        path="stats.md",
        size_bytes=42,
        disk_path="",
    )
    db_session.add(obj)
    db_session.add(db.MusehubObjectRef(repo_id=repo.repo_id, object_id=oid))
    await db_session.commit()

    stats = await get_repo_home_stats(db_session, repo.repo_id, ref="main")

    assert stats["total_objects"] == 1
    assert stats["total_size_bytes"] == 42


# ---------------------------------------------------------------------------
# Test 3: get_repo_stats shared object counted once per repo
# ---------------------------------------------------------------------------

@pytest.mark.asyncio
async def test_repo_stats_shared_object_per_repo(
    db_session: AsyncSession,
) -> None:
    """A shared object must appear in each repo's stats independently."""
    from musehub.services.musehub_repository import get_repo_home_stats

    repo_a = await create_repo(db_session, slug=f"stats-shared-a-{secrets.token_hex(4)}", owner="test-user-wire")
    repo_b = await create_repo(db_session, slug=f"stats-shared-b-{secrets.token_hex(4)}", owner="test-user-wire")

    oid = _oid(b"shared stats object")
    obj = db.MusehubObject(
        object_id=oid,
        path="shared.md",
        size_bytes=100,
        disk_path="",
    )
    db_session.add(obj)
    db_session.add(db.MusehubObjectRef(repo_id=repo_a.repo_id, object_id=oid))
    db_session.add(db.MusehubObjectRef(repo_id=repo_b.repo_id, object_id=oid))
    await db_session.commit()

    stats_a = await get_repo_home_stats(db_session, repo_a.repo_id, ref="main")
    stats_b = await get_repo_home_stats(db_session, repo_b.repo_id, ref="main")

    assert stats_a["total_objects"] == 1
    assert stats_a["total_size_bytes"] == 100
    assert stats_b["total_objects"] == 1
    assert stats_b["total_size_bytes"] == 100