"""Bolt Assistant without a mic, speaker or server: synthetic audio frames,
a fake transcriber, fake converse/tts/playback. Covers wake matching, the
voice-activity detector, the listen -> ask -> speak flow, and the command
rules."""

import array
import json
import sys
from pathlib import Path
from unittest.mock import MagicMock, patch

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

import pytest

from bolt_assistant import config, server
from bolt_assistant.assistant import Assistant, annotate
from bolt_assistant.listener import Segmenter
from bolt_assistant.stt import Transcription, parse_result
from bolt_assistant.tools import Tools
from bolt_assistant.wake import find_wake

LOUD, QUIET = 3000, 20


def frame(level, samples=1280):
    return array.array("h", [level, -level] * (samples // 2)).tobytes()


# ── wake phrases ────────────────────────────────────────────────────────────

W = config.WAKE_WORDS


@pytest.mark.parametrize("said, expected", [
    ("Hey Bolt, what's the weather?", (True, "what's the weather?")),
    ("Bolt.", (True, "")),
    ("Thunderbolt turn on the lights", (True, "turn on the lights")),
    ("hey thunderbolt!", (True, "")),
    ("um, hey Bolt what time is it", (True, "what time is it")),
    ("Hey assistant. Set a timer", (True, "Set a timer")),
    ("Hey volt, play music", (True, "play music")),   # a common mishearing, after "hey"
    ("okay so bolt, hi", (True, "hi")),
    ("tighten that bolt", (False, "")),
    ("the bolt on the door", (False, "")),
    ("I was bold", (False, "")),                       # the mishearing alone isn't a wake word
    ("assistant set a timer", (False, "")),            # "assistant" needs the "hey"
    ("boltage is high", (False, "")),
    ("", (False, "")),
])
def test_find_wake(said, expected):
    assert find_wake(said, W) == expected


# ── voice-activity detection ────────────────────────────────────────────────

def seg(**kw):
    args = dict(threshold=500, start_frames=3, silence_end_sec=0.4, min_sec=0.3, max_sec=2.0)
    args.update(kw)
    return Segmenter(**args)


def feed(s, frames):
    events = []
    for f in frames:
        events += s.feed(f)
    return events


def test_silence_never_starts_an_utterance():
    assert feed(seg(), [frame(QUIET)] * 50) == []


def test_speech_starts_with_pre_roll_and_ends_after_silence():
    s = seg()
    events = feed(s, [frame(QUIET)] * 6 + [frame(LOUD)] * 6 + [frame(QUIET)] * 5)
    kinds = [e.kind for e in events]
    assert kinds[0] == "start" and kinds[-1] == "end"
    start = events[0]
    assert len(start.frames) == 4 + 3  # pre-roll kept the first syllable, plus the trigger
    end = events[-1]
    assert len(end.audio) == (4 + 6 + 5) * 2560  # pre-roll + speech + trailing silence


def test_a_click_is_not_speech_and_a_short_burst_is_dropped():
    s = seg(min_sec=0.5)  # needs 6+ loud frames
    assert feed(s, [frame(LOUD), frame(QUIET)] * 5) == []  # isolated clicks
    events = feed(s, [frame(LOUD)] * 3 + [frame(QUIET)] * 5)
    assert [e.kind for e in events if e.kind != "frame"] == ["start", "dropped"]


def test_long_speech_is_cut_off_at_the_cap():
    events = feed(seg(max_sec=1.0), [frame(LOUD)] * 30)
    ends = [e for e in events if e.kind == "end"]
    assert ends and ends[0].seconds <= 1.0 + 1e-6


# ── the flow ────────────────────────────────────────────────────────────────

class FakeTranscription:
    """Each utterance returns the next scripted transcript."""

    script = []

    def __init__(self):
        self.frames = 0
        self.cancelled = False

    def add(self, frames):
        self.frames += len(frames)

    def finish(self, audio):
        return FakeTranscription.script.pop(0)

    def cancel(self):
        self.cancelled = True


class Clock:
    def __init__(self):
        self.t = 1000.0

    def __call__(self):
        return self.t


def utterance():
    return [frame(LOUD)] * 8 + [frame(QUIET)] * 12


def make(replies, commands="read", streaming=False, **kw):
    asked, played, logs = [], [], []

    def converse(message, on_command, on_say=None):
        asked.append(message)
        reply = replies.pop(0)
        if callable(reply):
            return reply(on_command)
        return server.Reply(reply)

    clock = Clock()
    a = Assistant(transcription=FakeTranscription, converse=converse,
                  converse_stream=None if not streaming else kw.pop("stream"),
                  tts=lambda text, voice: [text.encode()], play=lambda chunks: played.extend(chunks),
                  tools=Tools(mode=commands, log=logs.append), log=logs.append, clock=clock, **kw)
    return a, asked, played, logs, clock


def say(a, transcript):
    FakeTranscription.script.append(transcript)
    for f in utterance():
        a.process(f)


def spoken(played):
    return [p.decode() for p in played if not p.startswith(b"\x00") and len(p) < 2000]


@pytest.fixture(autouse=True)
def _config(monkeypatch):
    monkeypatch.setattr(config, "STREAMING_REPLIES", False)
    monkeypatch.setattr(config, "VAD_RMS_THRESHOLD", 500)
    FakeTranscription.script = []


def test_ignores_speech_without_the_wake_phrase():
    a, asked, played, logs, _ = make([])
    say(a, "so anyway I was telling him about the bolt")
    assert asked == [] and played == []


def test_wake_phrase_and_request_in_one_breath():
    a, asked, played, logs, _ = make(["It's three o'clock."])
    say(a, "Hey Bolt, what time is it?")
    assert asked[0].startswith("what time is it?\n\n[Bolt Assistant: a voice-only assistant")
    assert "It's three o'clock." in spoken(played)
    assert a.state == "idle"


def test_bare_wake_phrase_chimes_then_takes_the_next_utterance():
    a, asked, played, logs, clock = make(["Sure."])
    say(a, "Hey Bolt")
    assert a.state == "command" and asked == []
    assert played  # the chime
    clock.t += 1
    say(a, "turn it up")  # no wake phrase needed now
    assert asked[0].startswith("turn it up")


def test_the_command_window_closes():
    a, asked, played, logs, clock = make([])
    say(a, "Thunderbolt")
    clock.t += config.COMMAND_WAIT_SEC + 5
    say(a, "so then we left")
    assert asked == [] and a.state == "idle"


def test_a_question_keeps_listening_for_the_answer():
    a, asked, played, logs, clock = make(["Which room, the kitchen or the bedroom?", "Done."])
    say(a, "Hey Bolt, turn on the lights")
    assert a.state == "follow_up"
    clock.t += 2
    say(a, "the kitchen")
    assert asked[1].startswith("the kitchen") and a.state == "idle"


def test_mic_audio_during_speech_is_discarded():
    a, asked, played, logs, clock = make(["Hello there."])
    a.on_mic_frame(frame(LOUD))  # queued while... (simulating backlog)
    say(a, "hey bolt hello")
    assert a.frames.empty()  # what the mic heard while Bolt talked is gone
    assert not a.segmenter.in_speech


def test_streamed_sentences_are_spoken_as_they_arrive():
    def stream(message, on_say, on_command):
        on_say("First.")
        on_say("Second.")
        return server.Reply("First. Second.", streamed=True)

    a, asked, played, logs, _ = make([], streaming=True, stream=stream)
    a._stream = stream
    say(a, "hey bolt tell me two things")
    assert spoken(played)[-2:] == ["First.", "Second."]


def test_server_failure_chimes_and_goes_back_to_listening():
    def boom(on_command):
        raise server.ServerError("down")

    a, asked, played, logs, _ = make([boom])
    say(a, "hey bolt anything")
    assert any("down" in line for line in logs) and a.state == "idle"


def test_markdown_is_not_read_aloud():
    a, asked, played, logs, _ = make(["**Sure** — see https://example.com for `details`."])
    say(a, "hey bolt help")
    text = spoken(played)[-1]
    assert "**" not in text and "https" not in text and "`" not in text


def test_the_note_describes_what_bolt_may_do():
    assert "can't run shell commands" in annotate("x", "read")
    assert "`command: <shell command>`" in annotate("x", "all")
    assert "can't act on this computer" in annotate("x", "off")


# ── commands relayed by the server ──────────────────────────────────────────

def filectl(**payload):
    return "filectl " + json.dumps(payload)


def test_read_mode_lists_files_but_refuses_shell_and_writes(tmp_path):
    (tmp_path / "a.txt").write_text("hi")
    ran = []
    tools = Tools(mode="read", log=lambda _m: None, shell=lambda c: ran.append(c) or "[exit 0]\n")
    assert "a.txt" in tools(filectl(op="list", path=str(tmp_path)))
    assert "hi" in tools(filectl(op="read", path=str(tmp_path / "a.txt")))
    assert "Not run" in tools("rm -rf /")
    assert "Not run" in tools(filectl(op="write", path=str(tmp_path / "b.txt"), content="x"))
    assert ran == [] and not (tmp_path / "b.txt").exists()


def test_all_mode_runs_commands_and_off_runs_nothing(tmp_path):
    ran = []
    shell = lambda c: ran.append(c) or "[exit 0]\n"  # noqa: E731
    assert Tools(mode="all", log=lambda _m: None, shell=shell)("command: echo hi") == "[exit 0]\n"
    assert ran == ["echo hi"]  # the stray "command:" label was stripped
    assert "Not run" in Tools(mode="off", log=lambda _m: None, shell=shell)(filectl(op="list", path="."))
    assert "isn't available" in Tools(mode="all", log=lambda _m: None)("petctl emote wave")


def test_unknown_mode_falls_back_to_read():
    assert Tools(mode="everything", log=lambda _m: None).mode == "read"


def test_a_relayed_command_goes_through_the_rules(tmp_path):
    (tmp_path / "notes.txt").write_text("buy milk")

    def reply_with_tool(on_command):
        output = on_command(filectl(op="read", path=str(tmp_path / "notes.txt")))
        assert "buy milk" in output
        return server.Reply("Your note says buy milk.")

    a, asked, played, logs, _ = make([reply_with_tool])
    say(a, "hey bolt read my notes")
    assert "Your note says buy milk." in spoken(played)


# ── server pieces ───────────────────────────────────────────────────────────

def test_whole_samples_carries_an_odd_byte_across_chunks():
    out = b"".join(server.whole_samples([b"\x01", b"\x02\x03", b"\x04\x05"]))
    assert out == b"\x01\x02\x03\x04"  # the lone trailing byte waits for its partner


def test_unsaid_drops_what_was_already_spoken():
    reply = server.unsaid(server.Reply("One. Two.\n\nThree."), ["One.", "Two."])
    assert reply == server.Reply("Three.", streamed=False)


def test_tts_needs_a_voice(monkeypatch):
    monkeypatch.setattr(config, "VOICE_ID", "")
    with pytest.raises(server.TtsError, match="ELEVENLABS_VOICE_ID"):
        server.tts_stream("hi")


def test_tts_request_shape(monkeypatch):
    monkeypatch.setattr(config, "SERVER_URL", "http://s")
    monkeypatch.setattr(config, "API_KEY", "k")
    monkeypatch.setattr(config, "VOICE_ID", "v1")
    response = MagicMock()
    response.iter_content.return_value = [b"\x00\x01"]
    with patch.object(server.requests, "post", return_value=response) as post:
        assert list(server.tts_stream("hello", voice_id="v2")) == [b"\x00\x01"]
    assert post.call_args.args[0] == "http://s/desk/tts"
    assert post.call_args.kwargs["json"]["voice_id"] == "v2"  # a speak_as pick wins
    assert post.call_args.kwargs["headers"] == {"X-Desk-Api-Key": "k"}


def test_parse_result():
    msg = json.dumps({"type": "Results", "is_final": True, "channel": {"alternatives": [{"transcript": "hey bolt"}]}})
    assert parse_result(msg) == ("hey bolt", True)
    assert parse_result("junk") == ("", False)


def test_transcription_falls_back_to_one_upload():
    class Sock:
        def __init__(self):
            self.audio, self.replies = [], [json.dumps({"is_final": True, "channel": {
                "alternatives": [{"transcript": "hey bolt"}]}}), ""]

        def send_binary(self, data):
            self.audio.append(data)

        def send(self, _text):
            pass

        def recv(self):
            return self.replies.pop(0)

        def close(self):
            pass

    late = Sock()
    calls = iter([ConnectionError("down"), late])

    def connect(_rate):
        item = next(calls)
        if isinstance(item, Exception):
            raise item
        return item

    t = Transcription(connect)
    t.add([frame(LOUD)])  # nowhere to go: the live socket never opened
    assert t.finish(frame(LOUD) * 2) == "hey bolt"
    assert b"".join(late.audio) == frame(LOUD) * 2