"""Integration tests for /api/stations endpoints."""
import pytest
from httpx import AsyncClient

from src.backend.tests.conftest import auth_headers, create_test_recipe


async def test_list_stations_requires_auth(client: AsyncClient):
    resp = await client.get("/api/stations")
    assert resp.status_code == 401


async def test_create_station_as_admin(client: AsyncClient, admin_user):
    resp = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-API", "name": "Via API"},
    )
    assert resp.status_code == 201, resp.text
    body = resp.json()
    assert body["code"] == "ST-API"
    assert body["active"] is True
    assert body["id"] > 0


async def test_create_station_non_admin_is_403(client: AsyncClient, maker_user):
    resp = await client.post(
        "/api/stations",
        headers=auth_headers(maker_user),
        json={"code": "ST-NO", "name": "No"},
    )
    assert resp.status_code == 403


async def test_update_station(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-UP", "name": "Old"},
    )
    station_id = created.json()["id"]
    resp = await client.put(
        f"/api/stations/{station_id}",
        headers=auth_headers(admin_user),
        json={"name": "New", "active": False},
    )
    assert resp.status_code == 200
    body = resp.json()
    assert body["name"] == "New"
    assert body["active"] is False


async def test_delete_station(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-D", "name": "D"},
    )
    sid = created.json()["id"]
    resp = await client.delete(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
    )
    assert resp.status_code == 204
    again = await client.get(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
    )
    assert again.status_code == 404


async def test_assign_and_unassign_recipe(
    client: AsyncClient, admin_user, db_session,
):
    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-AS")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-ASSIGN", "name": "A"},
    )
    sid = created.json()["id"]
    a = await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )
    assert a.status_code == 201
    r = await client.get(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
    )
    assert r.status_code == 200
    assert [rec["code"] for rec in r.json()] == ["REC-AS"]
    u = await client.delete(
        f"/api/stations/{sid}/recipes/{recipe.id}",
        headers=auth_headers(admin_user),
    )
    assert u.status_code == 204
    r2 = await client.get(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
    )
    assert r2.json() == []


async def test_list_recipes_by_station_code(
    client: AsyncClient, admin_user, measurement_tec_user, db_session,
):
    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-BC")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-BC", "name": "BC"},
    )
    sid = created.json()["id"]
    await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )
    resp = await client.get(
        "/api/stations/by-code/ST-BC/recipes",
        headers=auth_headers(measurement_tec_user),
    )
    assert resp.status_code == 200
    assert [r["code"] for r in resp.json()] == ["REC-BC"]


async def test_list_recipes_by_unknown_code_404(
    client: AsyncClient, measurement_tec_user,
):
    resp = await client.get(
        "/api/stations/by-code/ST-DOES-NOT-EXIST/recipes",
        headers=auth_headers(measurement_tec_user),
    )
    assert resp.status_code == 404


async def test_admin_can_list_stations(client: AsyncClient, admin_user):
    await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-L1", "name": "A"},
    )
    await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-L2", "name": "B", "active": False},
    )
    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
    assert resp.status_code == 200
    codes = {s["code"] for s in resp.json()}
    assert {"ST-L1", "ST-L2"}.issubset(codes)

    resp_active = await client.get(
        "/api/stations?active_only=true", headers=auth_headers(admin_user),
    )
    assert resp_active.status_code == 200
    active_codes = {s["code"] for s in resp_active.json()}
    assert "ST-L1" in active_codes
    assert "ST-L2" not in active_codes


async def test_assign_recipe_not_found_returns_404(
    client: AsyncClient, admin_user,
):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-NR", "name": "NR"},
    )
    sid = created.json()["id"]
    resp = await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": 99999},
    )
    assert resp.status_code == 404


async def test_duplicate_assignment_returns_409(
    client: AsyncClient, admin_user, db_session,
):
    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-DUP")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-DUP-A", "name": "Dup"},
    )
    sid = created.json()["id"]
    first = await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )
    assert first.status_code == 201
    second = await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )
    assert second.status_code == 409


# ---------------------------------------------------------------------------
# Station list carries assigned recipes (point 7)
# ---------------------------------------------------------------------------


async def test_list_stations_includes_assigned_recipes(
    client: AsyncClient, admin_user, db_session,
):
    """The admin list shows which recipes a station handles, without a call per row."""
    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-LIST")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-WITHREC", "name": "Con ricette"},
    )
    sid = created.json()["id"]
    await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )

    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
    assert resp.status_code == 200
    station = next(s for s in resp.json() if s["id"] == sid)
    assert [r["code"] for r in station["recipes"]] == ["REC-LIST"]


async def test_list_stations_empty_recipes_when_unassigned(
    client: AsyncClient, admin_user,
):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-NOREC", "name": "Senza ricette"},
    )
    sid = created.json()["id"]
    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
    station = next(s for s in resp.json() if s["id"] == sid)
    assert station["recipes"] == []


async def test_list_stations_hides_inactive_recipes(
    client: AsyncClient, admin_user, db_session,
):
    """An assigned but deactivated recipe must not show: the operator won't see it."""
    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-OFF")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-INACT", "name": "Con ricetta spenta"},
    )
    sid = created.json()["id"]
    await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )

    recipe.active = False
    await db_session.commit()

    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
    station = next(s for s in resp.json() if s["id"] == sid)
    assert station["recipes"] == []


# ---------------------------------------------------------------------------
# Per-row station reset (point 7)
# ---------------------------------------------------------------------------


async def test_reset_station_removes_all_assignments(
    client: AsyncClient, admin_user, db_session,
):
    first = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-R1")
    second = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-R2")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-RESET", "name": "Da azzerare"},
    )
    sid = created.json()["id"]
    for recipe in (first, second):
        await client.post(
            f"/api/stations/{sid}/recipes",
            headers=auth_headers(admin_user),
            json={"recipe_id": recipe.id},
        )

    resp = await client.delete(
        f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user),
    )
    assert resp.status_code == 200, resp.text
    assert resp.json() == {"station_id": sid, "removed": 2}

    left = await client.get(
        f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user),
    )
    assert left.json() == []


async def test_reset_station_keeps_the_station(
    client: AsyncClient, admin_user, db_session,
):
    """Reset clears assignments only - the station stays and can be reassigned."""
    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-KEEP")
    await db_session.commit()
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-KEEP", "name": "Resta"},
    )
    sid = created.json()["id"]
    await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )
    await client.delete(f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user))

    still_there = await client.get(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
    )
    assert still_there.status_code == 200

    reassigned = await client.post(
        f"/api/stations/{sid}/recipes",
        headers=auth_headers(admin_user),
        json={"recipe_id": recipe.id},
    )
    assert reassigned.status_code == 201


async def test_reset_empty_station_is_idempotent(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-IDEM", "name": "Gia vuota"},
    )
    sid = created.json()["id"]
    resp = await client.delete(
        f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user),
    )
    assert resp.status_code == 200
    assert resp.json()["removed"] == 0


async def test_reset_station_non_admin_is_403(
    client: AsyncClient, admin_user, maker_user,
):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-RBAC", "name": "Protetta"},
    )
    sid = created.json()["id"]
    resp = await client.delete(
        f"/api/stations/{sid}/recipes", headers=auth_headers(maker_user),
    )
    assert resp.status_code == 403


async def test_reset_unknown_station_is_404(client: AsyncClient, admin_user):
    resp = await client.delete(
        "/api/stations/999999/recipes", headers=auth_headers(admin_user),
    )
    assert resp.status_code == 404


# --- vision_worker_url (#45) ---

async def test_station_vision_worker_url_roundtrip(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations",
        headers=auth_headers(admin_user),
        json={"code": "ST-VW", "name": "VW", "vision_worker_url": " http://10.0.0.7:8100/ "},
    )
    assert created.status_code == 201, created.text
    # spazi tolti e "/" finale tolto
    assert created.json()["vision_worker_url"] == "http://10.0.0.7:8100"

    sid = created.json()["id"]
    updated = await client.put(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
        json={"vision_worker_url": "https://w.example:9000"},
    )
    assert updated.status_code == 200
    assert updated.json()["vision_worker_url"] == "https://w.example:9000"

    # stringa vuota = torna al worker centrale
    cleared = await client.put(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
        json={"vision_worker_url": ""},
    )
    assert cleared.status_code == 200
    assert cleared.json()["vision_worker_url"] is None


async def test_station_vision_worker_url_defaults_to_null(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-VN", "name": "VN"},
    )
    assert created.status_code == 201
    assert created.json()["vision_worker_url"] is None


async def test_station_vision_worker_url_must_be_http(client: AsyncClient, admin_user):
    resp = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-VF", "name": "VF", "vision_worker_url": "ftp://x"},
    )
    assert resp.status_code == 422

    created = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-VG", "name": "VG"},
    )
    resp = await client.put(
        f"/api/stations/{created.json()['id']}", headers=auth_headers(admin_user),
        json={"vision_worker_url": "ftp://x"},
    )
    assert resp.status_code == 422


# --- camera_url / camera_source (#72) ---

async def test_station_camera_fields_roundtrip(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={
            "code": "ST-CAM", "name": "CAM",
            "camera_url": " http://127.0.0.1:8765/ ",
            "camera_source": "  camera:folder  ",
        },
    )
    assert created.status_code == 201, created.text
    assert created.json()["camera_url"] == "http://127.0.0.1:8765"
    assert created.json()["camera_source"] == "camera:folder"

    sid = created.json()["id"]
    read = await client.get(f"/api/stations/{sid}", headers=auth_headers(admin_user))
    assert read.status_code == 200
    assert read.json()["camera_url"] == "http://127.0.0.1:8765"
    assert read.json()["camera_source"] == "camera:folder"

    updated = await client.put(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
        json={"camera_url": "https://cam.example:9000", "camera_source": "camera:ABC123"},
    )
    assert updated.status_code == 200
    assert updated.json()["camera_url"] == "https://cam.example:9000"
    assert updated.json()["camera_source"] == "camera:ABC123"

    cleared = await client.put(
        f"/api/stations/{sid}", headers=auth_headers(admin_user),
        json={"camera_url": "", "camera_source": "   "},
    )
    assert cleared.status_code == 200
    assert cleared.json()["camera_url"] is None
    assert cleared.json()["camera_source"] is None


async def test_station_camera_fields_default_to_null(client: AsyncClient, admin_user):
    created = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-CN", "name": "CN"},
    )
    assert created.status_code == 201
    assert created.json()["camera_url"] is None
    assert created.json()["camera_source"] is None


async def test_station_camera_url_must_be_http(client: AsyncClient, admin_user):
    resp = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-CF", "name": "CF", "camera_url": "ftp://x"},
    )
    assert resp.status_code == 422

    created = await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-CG", "name": "CG"},
    )
    resp = await client.put(
        f"/api/stations/{created.json()['id']}", headers=auth_headers(admin_user),
        json={"camera_url": "ftp://x"},
    )
    assert resp.status_code == 422


async def test_station_by_code_returns_station(client: AsyncClient, admin_user):
    await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-BC", "name": "BC", "camera_url": "http://h:1", "camera_source": "camera:folder"},
    )
    resp = await client.get("/api/stations/by-code/ST-BC", headers=auth_headers(admin_user))
    assert resp.status_code == 200, resp.text
    assert resp.json()["code"] == "ST-BC"
    assert resp.json()["camera_url"] == "http://h:1"
    assert resp.json()["camera_source"] == "camera:folder"


async def test_station_by_code_unknown_is_404(client: AsyncClient, admin_user):
    resp = await client.get("/api/stations/by-code/NOPE", headers=auth_headers(admin_user))
    assert resp.status_code == 404


async def test_station_by_code_any_authenticated_user(
    client: AsyncClient, measurement_tec_user, admin_user,
):
    await client.post(
        "/api/stations", headers=auth_headers(admin_user),
        json={"code": "ST-BA", "name": "BA"},
    )
    resp = await client.get("/api/stations/by-code/ST-BA", headers=auth_headers(measurement_tec_user))
    assert resp.status_code == 200, resp.text
    assert resp.json()["code"] == "ST-BA"


async def test_station_by_code_requires_auth(client: AsyncClient):
    resp = await client.get("/api/stations/by-code/ST-BA")
    assert resp.status_code == 401