import concurrent.futures
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
from pathlib import Path
import subprocess
import sys
import threading
import time
import pytest
from bekci_watch import Frames, Ledger, MetadataFilter, WatchOwner, opaque
from native_speech_mux import NativeSpeechMux, stdio_invocation
from test_native_speech_mux import Harness

def wait(predicate):
    until=time.time()+5
    while time.time()<until:
        if predicate(): return
        time.sleep(.01)
    assert predicate()

class Server:
    def __init__(self, frames, status=200):
        self.requests=[];self.frames=frames;self.status=status;self.closed=threading.Event()
        owner=self
        class H(BaseHTTPRequestHandler):
            def log_message(self,*args): pass
            def do_POST(self):
                owner.requests.append((self.path,self.headers.get('Authorization'),json.loads(self.rfile.read(int(self.headers['Content-Length'])))))
                self.send_response(owner.status);self.send_header('Content-Type','text/event-stream');self.end_headers()
                try:
                    for frame in owner.frames:
                        self.wfile.write(frame);self.wfile.flush()
                    while not owner.closed.wait(.05):
                        self.wfile.write(b': keepalive\n\n');self.wfile.flush()
                except OSError: pass
        self.server=ThreadingHTTPServer(('127.0.0.1',0),H);self.server.daemon_threads=True
        self.origin='http://127.0.0.1:'+str(self.server.server_port)
        threading.Thread(target=self.server.serve_forever,daemon=True).start()
    def close(self): self.closed.set();self.server.shutdown();self.server.server_close()

def frame(event,value,cursor=None):
    return ((f'id: {cursor}\n' if cursor else '')+f'event: {event}\ndata: '+json.dumps(value)+'\n\n').encode()

def started(mux,tid):
    mux._observe_server({'method':'thread/realtime/started','params':{'threadId':tid,'realtimeSessionId':'rt'}})

def meta(): return dict(subscription='s'*40,events_url='/v1/bekci/events',expires_at=(time.time()+60)*1000)
def capture(owner,tid): return owner.capture({'session-id':tid,'thread-id':tid},{'prompt_cache_key':tid})
def notice(i='one'): return dict(notice=dict(id=i,type='arastirma',metin='correction',at=time.time()),cursor='cursor-'+i)

def test_stream_metadata_isolation_split_crlf_and_json():
    seen=[];f=MetadataFilter(seen.append);wire=frame('response.output_text.delta',{'delta':'answer'})+frame('bekci.watch',meta())+b'data: [DONE]\n\n'
    wire=wire.replace(b'\n',b'\r\n');out=b''
    for byte in wire: out+=f.feed(bytes([byte]))
    out+=f.flush()
    assert len(seen)==1 and b'subscription' not in out and b'answer' in out and b'[DONE]' in out

def test_ready_auth_durable_replay_and_epoch_abort(tmp_path):
    n=notice();server=Server([frame('ready',{'cursor':'start'}),frame('notice',n,n['cursor']),frame('notice',n,n['cursor'])])
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    ledger=Ledger(tmp_path/'ledger.db');owner=WatchOwner(mux,ledger,origin=server.origin,test_loopback=True)
    c=capture(owner,'A');p=meta()
    try:
        assert owner.accept(p,c,'member',server.origin+'/v1/responses')=='subscribing'
        wait(lambda:mux._queue.qsize()==1)
        scope=opaque('public-watch','member',p['subscription'])
        wait(lambda:ledger.cursor(scope)==n['cursor'])
        assert server.requests[0]==('/v1/bekci/events','Bearer member',{'subscription':p['subscription']})
        reopened=Ledger(tmp_path/'ledger.db');assert not reopened.claim(scope,'one')
        mux._observe_client({'method':'thread/realtime/stop','params':{'threadId':'A'}})
        wait(lambda:not owner.watches)
        assert owner.accept(p,c,'member',server.origin+'/v1/responses')=='stale_generation'
    finally: owner.close();server.close()

def test_no_ready_wrong_key_untrusted_url_and_two_threads(tmp_path):
    n=notice();server=Server([frame('notice',n,n['cursor'])]);mux=NativeSpeechMux(['unused'],observer=True)
    for t in ('A','B'): started(mux,t)
    owner=WatchOwner(mux,Ledger(tmp_path/'db'),origin=server.origin,test_loopback=True)
    try:
        c=capture(owner,'A')
        assert owner.accept(meta(),c,'member','https://evil.invalid/responses')=='untrusted_route'
        assert owner.accept(meta(),None,'member',server.origin)=='stale_generation'
        p=meta();p['events_url']='https://evil.invalid';assert owner.accept(p,c,'member',server.origin)=='invalid_receipt'
        owner.accept(meta(),c,'member',server.origin);wait(lambda:len(server.requests)>0)
        time.sleep(.1);assert mux._queue.empty() and not mux._bindings
    finally:owner.close();server.close()
    server=Server([frame('ready',{'cursor':'start'}),frame('notice',n,n['cursor'])]);owner=WatchOwner(mux,Ledger(tmp_path/'db2'),origin=server.origin,test_loopback=True)
    try:
        for t in ('A','B'):
            p=meta();p['subscription']=t*40;owner.accept(p,capture(owner,t),'member',server.origin)
        wait(lambda:mux._queue.qsize()==2)
        assert {mux._queue.get()[1][0]['thread_id'] for _ in range(2)}=={'A','B'}
    finally:owner.close();server.close()

def test_launcher_stdio_grammar(tmp_path):
    assert stdio_invocation(['-c','x=true','app-server','--analytics-default-enabled','-c','y="z"'])
    assert not stdio_invocation(['exec','app-server'])
    assert not stdio_invocation(['app-server','--listen','ws://127.0.0.1'])
    assert not stdio_invocation(['app-server','daemon','start'])

@pytest.mark.parametrize('active_owner', [True, False])
def test_http_receipt_through_real_bridge_handler_to_real_pipe(tmp_path, active_owner):
    """Real imported H, real HTTP primary/events, real subprocess append/approval."""
    import os
    import http.client
    import urllib.request
    bridge=tmp_path/'bridge';bridge.mkdir()
    (bridge/'bridge.json').write_text(json.dumps({'aiturk_hat':{'enabled':False},'sesle_model':False,'nokta_karsila':False,'yarim_cevap':False,'ozet_kopru':{'enabled':False},'tasma_bekcisi':False}),encoding='utf-8')
    agent=tmp_path/'agent';agent.mkdir()
    old=dict(os.environ);os.environ['AITURK_CODEX_BRIDGE_HOME']=str(bridge);os.environ['HERMES_HOME']=str(agent)
    try:
        import kopru
    finally: os.environ.clear();os.environ.update(old)
    h=Harness(tmp_path);h.start()
    p=meta();n=notice();requests=[]
    class Primary(BaseHTTPRequestHandler):
        def log_message(self,*args): pass
        def do_POST(self):
            body=json.loads(self.rfile.read(int(self.headers['Content-Length'])))
            requests.append((self.path,self.headers.get('Authorization'),body))
            if self.path=='/v1/bekci/events':
                wire=frame('ready',{'cursor':'start'})+frame('notice',n,n['cursor'])
                kind='text/event-stream'
            elif body.get('stream',True):
                wire=frame('response.output_text.delta',{'type':'response.output_text.delta','delta':'answer'})+frame('bekci.watch',p)+b'data: [DONE]\n\n';kind='text/event-stream'
            else:
                wire=json.dumps({'output':[],'_bekci_watch':p}).encode();kind='application/json'
            self.send_response(200);self.send_header('Content-Type',kind);self.send_header('Content-Length',str(len(wire)));self.end_headers();self.wfile.write(wire)
    upstream=ThreadingHTTPServer(('127.0.0.1',0),Primary);upstream.daemon_threads=True
    threading.Thread(target=upstream.serve_forever,daemon=True).start();origin='http://127.0.0.1:'+str(upstream.server_port)
    owner=WatchOwner(h.mux,Ledger(tmp_path/'http-ledger'),origin=origin,test_loopback=True)
    kopru.WATCH_OWNER=owner if active_owner else None;kopru.MODEL_MAP['ide/test-watch']=('test-route','Sesli-Hizli-Zeki',False)
    kopru.ROUTES['test-route']={'url':origin+'/v1/responses','key':'public-member','flatten_tools':False}
    server=kopru.TS(('127.0.0.1',0),kopru.H);threading.Thread(target=server.serve_forever,daemon=True).start()
    try:
        for stream in (True,False):
            conn=http.client.HTTPConnection('127.0.0.1',server.server_port,timeout=5)
            conn.request('POST','/v1/responses',json.dumps({'model':'ide/test-watch','stream':stream,'prompt_cache_key':'thread-A','input':[]}),{'Content-Type':'application/json','session-id':'thread-A','thread-id':'thread-A'})
            resp=conn.getresponse();data=resp.read();conn.close()
            assert resp.status==200 and b'subscription' not in data and b'_bekci_watch' not in data
        if active_owner:
            approval=json.loads(h.recv());speech=json.loads(h.recv())
            assert approval['method']=='item/commandExecution/requestApproval'
            assert speech['method']=='seen-speech' and speech['params']=={'threadId':'thread-A','text':'correction'}
            assert any(path=='/v1/bekci/events' and auth=='Bearer public-member' for path,auth,_ in requests)
        else:
            assert not any(path=='/v1/bekci/events' for path,_,_ in requests)
    finally:
        owner.close();server.shutdown();server.server_close();upstream.shutdown();upstream.server_close();kopru.WATCH_OWNER=None;h.close()

def test_http_403_expiry_and_crash_claim_never_resend(tmp_path):
    server=Server([],status=403);mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'db'),origin=server.origin,test_loopback=True)
    try:
        owner.accept(meta(),capture(owner,'A'),'wrong-key',server.origin)
        wait(lambda:len(server.requests)==1);wait(lambda:not owner.watches)
        assert not mux._bindings and mux._queue.empty()
    finally:owner.close();server.close()
    n=notice();server=Server([frame('ready',{'cursor':'start'}),frame('notice',n,n['cursor'])])
    ledger=Ledger(tmp_path/'crash');p=meta();scope=opaque('public-watch','member',p['subscription']);assert ledger.claim(scope,'one')
    owner=WatchOwner(mux,Ledger(tmp_path/'crash'),origin=server.origin,test_loopback=True)
    try:
        p['expires_at']=(time.time()+.4)*1000
        owner.accept(p,capture(owner,'A'),'member',server.origin)
        wait(lambda:owner.ledger.cursor(scope)==n['cursor']);wait(lambda:not owner.watches)
        assert mux._queue.empty()
    finally:owner.close();server.close()

def test_receipt_cannot_move_to_other_thread_or_generation(tmp_path):
    server=Server([frame('ready',{'cursor':'start'})]);mux=NativeSpeechMux(['unused'],observer=True)
    started(mux,'A');started(mux,'B');owner=WatchOwner(mux,Ledger(tmp_path/'db'),origin=server.origin,test_loopback=True);p=meta()
    try:
        assert owner.accept(p,capture(owner,'A'),'member',server.origin)=='subscribing'
        assert owner.accept(p,capture(owner,'B'),'member',server.origin)=='receipt_replay_mismatch'
        mux._observe_client({'method':'thread/unsubscribe','params':{'threadId':'A'}})
        wait(lambda:not owner.watches);started(mux,'A')
        assert owner.accept(p,capture(owner,'A'),'member',server.origin)=='receipt_replay_mismatch'
    finally:owner.close();server.close()

@pytest.mark.parametrize('seconds', [16*60, 60*60, 24*60*60, 24*60*60+30])
def test_protocol_lifetime_receipt_admitted(tmp_path, seconds):
    server=Server([frame('ready', {'cursor':'start'})])
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'db'),origin=server.origin,test_loopback=True)
    try:
        p=meta();p['expires_at']=(time.time()+seconds)*1000
        assert owner.accept(p,capture(owner,'A'),'member',server.origin)=='subscribing'
        wait(lambda:len(server.requests)==1)
        wait(lambda:bool(mux._bindings))
        assert owner.watches
    finally: owner.close();server.close()

@pytest.mark.parametrize('expiry', [0, -1, float('inf'), float('-inf'), float('nan'), True, False, 'infinite', None, 10**100])
def test_invalid_or_unbounded_expiry_rejected(tmp_path, expiry):
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'db'))
    p=meta();p['expires_at']=expiry
    assert owner.accept(p,capture(owner,'A'),'member','https://ai.turkservis.online/v1/responses')=='invalid_receipt'
    assert not owner.watches

def test_receipt_beyond_protocol_and_skew_rejected(tmp_path):
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'db'))
    p=meta();p['expires_at']=(time.time()+24*60*60+120)*1000
    assert owner.accept(p,capture(owner,'A'),'member','https://ai.turkservis.online/v1/responses')=='invalid_receipt'


@pytest.mark.parametrize('target', ['Other-Model', 'sesli-hizli-zeki', 'Sesli-Hizli-Zeki-extra'])
@pytest.mark.parametrize('json_response', [False, True])
@pytest.mark.parametrize('jev', [False, True])
def test_actual_handler_nonvoice_preserves_response_pipeline(tmp_path, monkeypatch, target, json_response, jev):
    import http.client
    import kopru
    from unittest.mock import Mock
    # Exceed the sideband frame cap: other models must never enter its buffer.
    wire=(json.dumps({'output':[], 'payload':'x'*270000}).encode() if json_response
          else frame('response.output_text.delta', {'delta':'x'*270000}))
    class Primary(BaseHTTPRequestHandler):
        def log_message(self,*args): pass
        def do_POST(self):
            self.rfile.read(int(self.headers['Content-Length']))
            self.send_response(200)
            self.send_header('Content-Type','application/json' if json_response else 'text/event-stream')
            self.send_header('Content-Length',str(len(wire)));self.end_headers();self.wfile.write(wire)
    upstream=ThreadingHTTPServer(('127.0.0.1',0),Primary)
    threading.Thread(target=upstream.serve_forever,daemon=True).start()
    owner=Mock();monkeypatch.setattr(kopru,'WATCH_OWNER',owner)
    monkeypatch.setitem(kopru.MODEL_MAP,'ide/scope-proof',('aiturk-ide',target,None))
    monkeypatch.setitem(kopru.ROUTES,'aiturk-ide',{'url':f'http://127.0.0.1:{upstream.server_port}/v1/responses','key':'scope-member','flatten_tools':jev})
    monkeypatch.setattr(kopru.jev_denetim,'anahtar',lambda:'test-key' if jev else '')
    wrapped=Mock(side_effect=AssertionError('nonvoice entered watch wrapper'))
    monkeypatch.setattr(kopru,'WatchResponse',wrapped)
    shortcut=Mock(side_effect=AssertionError('nonvoice entered JSON shortcut'))
    monkeypatch.setattr(kopru.H,'_send_json',shortcut)
    calls=[]
    original_stream=kopru.H._stream
    def stream(self,resp,*args,**kwargs):
        calls.append('stream')
        return original_stream(self,resp,*args,**kwargs)
    def denetim(self,resp,tag,rewriter,izle,istek,sira,ac,*,hedef):
        # Verify original upstream object/body reaches Jev, not a watch wrapper.
        calls.append('jev');assert hedef==target and sira
        data=resp.read();resp.close();assert data==wire
        self.send_response(200);self.send_header('Content-Length',str(len(data)))
        self.end_headers();self.wfile.write(data)
    monkeypatch.setattr(kopru.H,'_stream',stream)
    monkeypatch.setattr(kopru.H,'_denetimli_akis',denetim)
    server=kopru.TS(('127.0.0.1',0),kopru.H)
    threading.Thread(target=server.serve_forever,daemon=True).start()
    try:
        conn=http.client.HTTPConnection('127.0.0.1',server.server_port,timeout=5)
        conn.request('POST','/v1/responses',json.dumps({'model':'ide/scope-proof','stream':not json_response,'input':[]}),{'Content-Type':'application/json'})
        response=conn.getresponse();data=response.read();conn.close()
        assert response.status==200 and data==wire
        assert calls==(['jev'] if jev else ['stream'])
        wrapped.assert_not_called();shortcut.assert_not_called();owner.accept.assert_not_called()
    finally:
        server.shutdown();server.server_close();upstream.shutdown();upstream.server_close()


class QuietWatchServer:
    """Real sockets, with no heartbeat; observes client shutdown at the peer."""
    def __init__(self, protocol='HTTP/1.0', delay=0, headers_delay=False, reconnects=False, delayed_headers=False):
        self.requests=[];self.closed=threading.Event();self.peer_closed=threading.Event()
        self.ready=threading.Event();owner=self
        class H(BaseHTTPRequestHandler):
            protocol_version='HTTP/1.1' if protocol=='HTTP/1.1-close' else protocol
            def log_message(self,*args): pass
            def do_POST(self):
                body=json.loads(self.rfile.read(int(self.headers['Content-Length'])))
                owner.requests.append(body);number=len(owner.requests)
                try:
                    if headers_delay:
                        owner.ready.set()
                        self.connection.settimeout(5)
                        if self.connection.recv(1)==b'': owner.peer_closed.set()
                        return
                    if delayed_headers and owner.closed.wait(delay): return
                    self.send_response(200);self.send_header('Content-Type','text/event-stream')
                    if protocol=='HTTP/1.1-close': self.send_header('Connection','close')
                    self.end_headers()
                    self.wfile.write(frame('ready',{'cursor':'start'}));self.wfile.flush();owner.ready.set()
                    if reconnects:
                        n=notice('first' if number<9 else 'ninth')
                        self.wfile.write(frame('notice',n,n['cursor']));self.wfile.flush()
                        if number<9:
                            self.close_connection=True
                            return
                    elif delay and number==1:
                        if not delayed_headers and owner.closed.wait(delay): return
                        n=notice('delayed');self.wfile.write(frame('notice',n,n['cursor']));self.wfile.flush()
                    self.connection.settimeout(5 if not delay else 20)
                    if self.connection.recv(1)==b'': owner.peer_closed.set()
                except OSError: pass
        self.server=ThreadingHTTPServer(('127.0.0.1',0),H);self.server.daemon_threads=True
        self.origin='http://127.0.0.1:'+str(self.server.server_port)
        threading.Thread(target=self.server.serve_forever,daemon=True).start()
    def close(self):
        self.closed.set();self.server.shutdown();self.server.server_close()


@pytest.mark.parametrize('delayed_headers',[False,True])
def test_quiet_watch_delivers_after_more_than_ten_seconds(tmp_path,delayed_headers):
    server=QuietWatchServer(delay=11.2,delayed_headers=delayed_headers)
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'quiet'),origin=server.origin,test_loopback=True)
    try:
        assert owner.accept(meta(),capture(owner,'A'),'member',server.origin)=='subscribing'
        assert server.ready.wait(14)
        until=time.monotonic()+14
        while mux._queue.empty() and time.monotonic()<until: time.sleep(.02)
        assert not mux._queue.empty(), 'valid quiet stream lost delayed notice'
        assert len(server.requests)==1, 'quiet channel spuriously reconnected'
    finally:owner.close();server.close()


@pytest.mark.parametrize('protocol',['HTTP/1.0','HTTP/1.1','HTTP/1.1-close'])
@pytest.mark.parametrize('cancel',['close','expiry','generation'])
@pytest.mark.parametrize('headers_delay',[False,True])
def test_quiet_owned_socket_is_interrupted(tmp_path,protocol,cancel,headers_delay):
    server=QuietWatchServer(protocol=protocol,headers_delay=headers_delay)
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'cancel'),origin=server.origin,test_loopback=True)
    try:
        p=meta()
        if cancel=='expiry':p['expires_at']=(time.time()+.7)*1000
        owner.accept(p,capture(owner,'A'),'member',server.origin)
        assert server.ready.wait(3)
        if not headers_delay:wait(lambda:bool(mux._bindings))
        if cancel=='close':owner.close()
        elif cancel=='generation':mux._observe_client({'method':'thread/realtime/stop','params':{'threadId':'A'}})
        assert server.peer_closed.wait(2), 'owned response/header socket remained open'
        wait(lambda:not owner.watches)
        assert not mux._bindings and mux._queue.empty()
    finally:owner.close();server.close()


def test_ninth_reconnect_delivers_and_preserves_cursor_dedup(tmp_path):
    class FastBackoff:
        def __init__(self):self.event=threading.Event()
        def is_set(self):return self.event.is_set()
        def set(self):self.event.set()
        def wait(self,seconds):return self.event.wait(min(seconds,.01))
    server=QuietWatchServer(reconnects=True)
    mux=NativeSpeechMux(['unused'],observer=True);started(mux,'A')
    owner=WatchOwner(mux,Ledger(tmp_path/'reconnect'),origin=server.origin,test_loopback=True)
    p=meta();c=capture(owner,'A');scope=opaque('public-watch','member',p['subscription']);stop=FastBackoff()
    owner.watches[scope]=stop
    worker=threading.Thread(target=owner._watch,args=(p,c,'member',scope,stop),daemon=True);worker.start()
    try:
        wait(lambda:len(server.requests)>=9)
        wait(lambda:owner.ledger.cursor(scope)=='cursor-ninth')
        assert mux._queue.qsize()==2
        assert all(req.get('cursor')=='cursor-first' for req in server.requests[1:9])
    finally:
        owner.close();worker.join(timeout=3);server.close()
    assert not worker.is_alive()