"""Unified /manager-clones CRUD + actions."""

from __future__ import annotations

import base64

import pytest
from fastapi.testclient import TestClient

from app.config import get_settings
from app.main import app

client = TestClient(app)
HEADERS = {"X-Internal-Token": get_settings().internal_api_token}


def _audio_b64(tag: bytes = b"\x00") -> str:
    return base64.b64encode(b"RIFF" + tag * 200).decode()


def _mock_openai_voice(monkeypatch: pytest.MonkeyPatch) -> None:
    async def fake_consent(**_k):
        return "cons_setup_1"

    async def fake_create(**_k):
        return {"id": "voice_openai_setup", "name": "Setup Voice", "object": "audio.voice"}

    monkeypatch.setattr(
        "app.services.enterprise.enterprise.create_voice_consent", fake_consent
    )
    monkeypatch.setattr(
        "app.services.enterprise.enterprise.create_custom_voice", fake_create
    )


@pytest.fixture(autouse=True)
def _force_local_llm(monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr("app.llm._provider_available", lambda _name: False)


def _create_clone() -> str:
    res = client.post(
        "/api/v1/manager-clones",
        headers=HEADERS,
        json={
            "company_id": "co-mc-1",
            "sample_questions": ["Tell me about ownership."],
        },
    )
    assert res.status_code == 200, res.text
    return res.json()["clone_id"]


def test_crud_get_patch_delete() -> None:
    clone_id = _create_clone()
    got = client.get(f"/api/v1/manager-clones/{clone_id}", headers=HEADERS)
    assert got.status_code == 200
    assert got.json()["company_id"] == "co-mc-1"

    patched = client.patch(
        f"/api/v1/manager-clones/{clone_id}",
        headers=HEADERS,
        json={"style_summary": "Updated style"},
    )
    assert patched.status_code == 200
    assert patched.json()["style_summary"] == "Updated style"

    deleted = client.delete(f"/api/v1/manager-clones/{clone_id}", headers=HEADERS)
    assert deleted.status_code == 200
    assert client.get(f"/api/v1/manager-clones/{clone_id}", headers=HEADERS).status_code == 404


def test_create_setup_with_knowledge_and_voice(monkeypatch: pytest.MonkeyPatch) -> None:
    """Knowledge + uploaded voice sample can be set on create (manager setup)."""
    _mock_openai_voice(monkeypatch)
    res = client.post(
        "/api/v1/manager-clones",
        headers=HEADERS,
        json={
            "company_id": "co-setup-1",
            "sample_questions": ["Walk me through a hard decision."],
            "knowledge": {
                "filename": "setup-guide.txt",
                "text": "Probe for ownership and tradeoffs.",
            },
            "voice": {
                "voice_name": "Setup Voice",
                "sample_audio_base64": _audio_b64(b"\x10"),
                "consent_audio_base64": _audio_b64(b"\x11"),
            },
        },
    )
    assert res.status_code == 200, res.text
    body = res.json()
    assert body["clone_id"]
    assert "setup-guide.txt" in body["knowledge_files"]
    assert body["setup"]["knowledge"]["filename"] == "setup-guide.txt"
    assert body["voice_id"]
    assert body["setup"]["voice"]["voice_id"] == body["voice_id"]
    assert body["setup"]["voice"]["mode"] == "custom"

    # Knowledge can be updated again via PATCH setup
    patched = client.patch(
        f"/api/v1/manager-clones/{body['clone_id']}",
        headers=HEADERS,
        json={
            "knowledge": {
                "filename": "setup-guide-v2.txt",
                "text": "Updated knowledge for this clone.",
            }
        },
    )
    assert patched.status_code == 200, patched.text
    assert "setup-guide-v2.txt" in patched.json()["knowledge_files"]
    assert patched.json()["setup"]["knowledge"]["filename"] == "setup-guide-v2.txt"


def test_knowledge_and_version_lifecycle_via_actions() -> None:
    clone_id = _create_clone()

    know = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "knowledge",
            "action": "upload_knowledge",
            "input": {"filename": "guide.txt", "text": "Focus on ownership."},
        },
    )
    assert know.status_code == 200, know.text
    assert know.json()["result"]["filename"] == "guide.txt"

    # GET …/actions/{action_id} is commented out
    action_id = know.json()["action_id"]
    fetched = client.get(
        f"/api/v1/manager-clones/{clone_id}/actions/{action_id}",
        headers=HEADERS,
    )
    assert fetched.status_code == 404

    draft = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "version",
            "action": "create_draft",
            "input": {
                "created_by": "recruiter@acme.example",
                "snapshot": {"style_summary": "v1"},
            },
        },
    )
    assert draft.status_code == 200, draft.text
    version_id = draft.json()["result"]["version_id"]

    published = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "version",
            "action": "publish",
            "input": {"version_id": version_id},
        },
    )
    assert published.status_code == 200, published.text
    assert published.json()["result"]["version_status"] == "published"

    versions = client.get(f"/api/v1/manager-clones/{clone_id}/versions", headers=HEADERS)
    assert versions.status_code == 200
    assert len(versions.json()["versions"]) >= 1

    rollback = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "version",
            "action": "rollback",
            "input": {
                "target_version_id": version_id,
                "created_by": "recruiter@acme.example",
            },
        },
    )
    assert rollback.status_code == 200, rollback.text
    new_id = rollback.json()["result"]["version_id"]
    assert new_id != version_id
    assert rollback.json()["result"]["version_status"] == "draft"

    # History preserved: original published version still listed
    after = client.get(f"/api/v1/manager-clones/{clone_id}/versions", headers=HEADERS)
    ids = {v["version_id"] for v in after.json()["versions"]}
    assert version_id in ids and new_id in ids

    archived = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "version",
            "action": "archive",
            "input": {"version_id": version_id},
        },
    )
    assert archived.status_code == 200, archived.text
    assert archived.json()["result"]["version_status"] == "archived"


def test_market_research_and_voice_actions(monkeypatch: pytest.MonkeyPatch) -> None:
    _mock_openai_voice(monkeypatch)
    clone_id = _create_clone()
    market = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "market_research",
            "action": "generate_questions",
            "input": {"role_title": "Backend Engineer", "industry": "SaaS", "count": 3},
        },
    )
    assert market.status_code == 200, market.text
    assert len(market.json()["result"]["questions"]) >= 1

    voice = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "voice",
            "action": "generate_voice",
            "input": {
                "voice_name": "Brand",
                "sample_audio_base64": _audio_b64(b"\x20"),
                "consent_audio_base64": _audio_b64(b"\x21"),
            },
        },
    )
    assert voice.status_code == 200, voice.text
    assert voice.json()["result"]["voice_id"]
    assert voice.json()["result"]["mode"] == "custom"


def test_invalid_module_action_pair() -> None:
    clone_id = _create_clone()
    res = client.post(
        f"/api/v1/manager-clones/{clone_id}/actions",
        headers=HEADERS,
        json={
            "module": "knowledge",
            "action": "publish",
            "input": {},
        },
    )
    assert res.status_code == 422
