"""Owner-scoping + the owner-only rename pencil on the public build page.

This is the security contract Mike asked to confirm: a logged-in user can
rename/delete ONLY their own builds; having someone else's session, or no
session, can't touch another user's build. And the rename pencil on
/b/<code> renders for the owner only.

Hits the dev mirror; users + their builds are torn down via make_user.
"""
import pytest

from conftest import add_part, login

pytestmark = [pytest.mark.integration, pytest.mark.db]


def _save_owned(client, sample_parts, title="Owned Build"):
    """Save a build as the currently-logged-in user; return (code, build_id)."""
    add_part(client, sample_parts[0]["id"])
    add_part(client, sample_parts[1]["id"])
    resp = client.post("/build/save", data={"title": title})
    assert resp.status_code == 302, resp.headers.get("Location")
    loc = resp.headers["Location"]
    assert loc.startswith("/b/"), f"not logged in? got {loc}"
    return loc.rsplit("/", 1)[-1].split("?")[0]


def _build_id_for_code(db_conn, code):
    with db_conn.cursor() as cur:
        cur.execute("SELECT id FROM build WHERE code=%s", (code,))
        return cur.fetchone()["id"]


def _title_for_code(db_conn, code):
    with db_conn.cursor() as cur:
        cur.execute("SELECT title FROM build WHERE code=%s", (code,))
        return cur.fetchone()["title"]


# --------------------------------------------------------------------------- #
# Rename pencil visibility on /b/<code>
# --------------------------------------------------------------------------- #
def test_owner_sees_rename_pencil(app, db_conn, sample_parts, make_user):
    owner = make_user()
    c = app.test_client()
    login(c, owner)
    code = _save_owned(c, sample_parts)

    page = c.get(f"/b/{code}", follow_redirects=True).get_data(as_text=True)
    assert 'id="pv-rename-display"' in page
    assert 'id="pv-rename-toggle"' in page          # the ✎ button


def test_non_owner_does_not_see_rename_pencil(app, db_conn, sample_parts,
                                              make_user):
    owner = make_user()
    oc = app.test_client()
    login(oc, owner)
    code = _save_owned(oc, sample_parts)

    # Anonymous viewer
    anon = app.test_client()
    page = anon.get(f"/b/{code}", follow_redirects=True).get_data(as_text=True)
    assert page                                     # renders fine
    assert 'id="pv-rename-display"' not in page
    assert 'id="pv-rename-toggle"' not in page

    # A DIFFERENT logged-in user also must not see it.
    other = make_user()
    occ = app.test_client()
    login(occ, other)
    page2 = occ.get(f"/b/{code}", follow_redirects=True).get_data(as_text=True)
    assert 'id="pv-rename-display"' not in page2


# --------------------------------------------------------------------------- #
# Rename is owner-scoped in the SQL (the takeover guard)
# --------------------------------------------------------------------------- #
def test_owner_can_rename(app, db_conn, sample_parts, make_user):
    owner = make_user()
    c = app.test_client()
    login(c, owner)
    code = _save_owned(c, sample_parts, title="Before")
    bid = _build_id_for_code(db_conn, code)

    c.post(f"/build/{bid}/rename", data={"title": "After"})
    assert _title_for_code(db_conn, code) == "After"


def test_other_user_cannot_rename(app, db_conn, sample_parts, make_user):
    owner = make_user()
    oc = app.test_client()
    login(oc, owner)
    code = _save_owned(oc, sample_parts, title="Original")
    bid = _build_id_for_code(db_conn, code)

    # A different logged-in user POSTs the rename for someone else's build id.
    attacker = make_user()
    ac = app.test_client()
    login(ac, attacker)
    ac.post(f"/build/{bid}/rename", data={"title": "Hijacked"})

    # owner_user_id-scoped UPDATE matched 0 rows -> title unchanged.
    assert _title_for_code(db_conn, code) == "Original"


def test_anonymous_cannot_rename(app, db_conn, sample_parts, make_user):
    owner = make_user()
    oc = app.test_client()
    login(oc, owner)
    code = _save_owned(oc, sample_parts, title="Original")
    bid = _build_id_for_code(db_conn, code)

    anon = app.test_client()
    resp = anon.post(f"/build/{bid}/rename", data={"title": "Hijacked"})
    assert resp.status_code == 302
    assert "/login" in resp.headers.get("Location", "")
    assert _title_for_code(db_conn, code) == "Original"


# --------------------------------------------------------------------------- #
# Delete is owner-scoped too
# --------------------------------------------------------------------------- #
def test_other_user_cannot_delete(app, db_conn, sample_parts, make_user):
    owner = make_user()
    oc = app.test_client()
    login(oc, owner)
    code = _save_owned(oc, sample_parts)
    bid = _build_id_for_code(db_conn, code)

    attacker = make_user()
    ac = app.test_client()
    login(ac, attacker)
    ac.post(f"/build/{bid}/delete")

    # Build still present — delete_lineage is WHERE owner_user_id.
    with db_conn.cursor() as cur:
        cur.execute("SELECT COUNT(*) AS n FROM build WHERE code=%s", (code,))
        assert cur.fetchone()["n"] == 1


def test_owner_can_delete(app, db_conn, sample_parts, make_user):
    owner = make_user()
    c = app.test_client()
    login(c, owner)
    code = _save_owned(c, sample_parts)

    c.post(f"/build/{_build_id_for_code(db_conn, code)}/delete")
    with db_conn.cursor() as cur:
        cur.execute("SELECT COUNT(*) AS n FROM build WHERE code=%s", (code,))
        assert cur.fetchone()["n"] == 0
