import json
import subprocess
from pathlib import Path

import pytest

from tests.dashboard_bundle import dashboard


OUTBOX = Path(__file__).parents[1] / "frontend" / "authored-outbox.js"


def run_node(script: str):
    result = subprocess.run(["node", "-e", script], check=True, capture_output=True, text=True)
    return json.loads(result.stdout)


def test_authored_outbox_quarantines_legacy_and_cross_account_messages():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map([['stackchain.authored-outbox.v1', JSON.stringify({{version:1,items:[
  {{id:'legacy',operationId:'legacy',kind:'issue-comment',repository:'o/r',number:1,body:'Old',status:'queued'}}
]}})]]);
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
const calls = [];
const outbox = createAuthoredOutbox({{
  storage, getOwnerLogin:()=>'timmy',
  fetchJson:async url => {{calls.push(url); return {{id:1}};}},
}});
const bound = outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:2,body:'Mine',operationId:'mine'}});
(async()=>{{
  const wrong = await outbox.flush('alexander');
  const right = await outbox.flush('timmy');
  process.stdout.write(JSON.stringify({{bound,wrong,right,calls,remaining:outbox.list()}}));
}})();
"""
    output = run_node(script)

    assert output["bound"]["ownerLogin"] == "timmy"
    assert output["wrong"]["blocked"] == 2
    assert len(output["right"]["confirmed"]) == 1
    assert [item["id"] for item in output["remaining"]] == ["legacy"]
    assert len(output["calls"]) == 1


def test_authored_outbox_persists_each_message_kind_and_flushes_sequentially():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map();
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v),removeItem:k=>values.delete(k)}};
const calls = [];
const outbox = createAuthoredOutbox({{
  storage, getOwnerLogin:()=>'timmy', now:() => 1234,
  fetchJson:async (url, options) => {{
    calls.push({{url,key:options.headers['Idempotency-Key'],body:JSON.parse(options.body)}});
    return {{id:calls.length}};
  }},
}});
outbox.enqueue({{kind:'issue-comment',repository:'stackchain/api',number:7,body:'Issue note',operationId:'issue-op'}});
outbox.enqueue({{kind:'pull-comment',repository:'stackchain/web',number:8,body:'PR note',operationId:'pull-op'}});
outbox.enqueue({{kind:'update-reply',notificationId:9,body:'Update note',operationId:'update-op'}});
const persisted = createAuthoredOutbox({{storage,fetchJson:outbox.fetchJson}}).list();
outbox.flush('timmy').then(result => process.stdout.write(JSON.stringify({{persisted,calls,result,remaining:outbox.list()}})));
"""
    output = run_node(script)

    assert [item["kind"] for item in output["persisted"]] == [
        "issue-comment", "pull-comment", "update-reply"
    ]
    assert [item["operationId"] for item in output["persisted"]] == ["issue-op", "pull-op", "update-op"]
    assert output["calls"] == [
        {"url": "api/v1/repos/stackchain/api/issues/7/comments", "key": "issue-op", "body": {"body": "Issue note"}},
        {"url": "api/v1/repos/stackchain/web/pulls/8/comments", "key": "pull-op", "body": {"body": "PR note"}},
        {"url": "api/v1/notifications/9/reply", "key": "update-op", "body": {"body": "Update note"}},
    ]
    assert len(output["result"]["confirmed"]) == 3
    assert output["remaining"] == []


def test_authored_outbox_classifies_failures_and_continues_past_attention_items():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map();
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v),removeItem:k=>values.delete(k)}};
let phase = 'permanent';
const calls = [];
const outbox = createAuthoredOutbox({{
  storage,
  getOwnerLogin:()=>'timmy',
  fetchJson:async (_url, options) => {{
    const body = JSON.parse(options.body).body; calls.push(body);
    if (body === 'Bad' && phase === 'permanent') {{ const e = new Error('Reply rejected'); e.status=422; throw e; }}
    if (body === 'Later' && phase === 'transient') {{ const e = new Error('Offline'); e.status=503; throw e; }}
    return {{id:calls.length}};
  }},
}});
const bad=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Bad',operationId:'a'}});
outbox.enqueue({{kind:'pull-comment',repository:'o/r',number:2,body:'Good',operationId:'b'}});
outbox.flush('timmy').then(async first => {{
  phase='transient';
  outbox.enqueue({{kind:'update-reply',notificationId:3,body:'Later',operationId:'c'}});
  const second=await outbox.flush('timmy');
  process.stdout.write(JSON.stringify({{first,second,calls,remaining:outbox.list(),badId:bad.id}}));
}});
"""
    output = run_node(script)

    assert output["calls"] == ["Bad", "Good", "Later"]
    assert len(output["first"]["confirmed"]) == 1
    assert output["remaining"][0]["id"] == output["badId"]
    assert output["remaining"][0]["status"] == "attention"
    assert output["remaining"][0]["error"] == "Reply rejected"
    assert output["remaining"][1]["status"] == "queued"


def test_authored_outbox_retry_is_single_flight_and_edit_rotates_identity():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map();
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v),removeItem:k=>values.delete(k)}};
let release; const gate=new Promise(resolve=>release=resolve); let calls=0; let sequence=0;
const outbox=createAuthoredOutbox({{
  storage, getOwnerLogin:()=>'timmy', createOperationId:()=> 'new-' + (++sequence),
  fetchJson:async()=>{{calls++; await gate; return {{id:1}};}},
}});
const item=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Old',operationId:'old'}});
const edited=outbox.update(item.id,{{body:'New'}});
const flush=outbox.flush('timmy'); const retry=outbox.retry(item.id, 'timmy'); release();
Promise.all([flush,retry]).then(results=>process.stdout.write(JSON.stringify({{edited,calls,results,remaining:outbox.list()}})));
"""
    output = run_node(script)

    assert output["edited"]["body"] == "New"
    assert output["edited"]["operationId"] == "new-1"
    assert output["calls"] == 1
    assert output["remaining"] == []


def test_authored_outbox_deduplicates_repeated_queue_attempts_by_operation_id():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map();
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
const outbox=createAuthoredOutbox({{storage,getOwnerLogin:()=>'timmy'}});
const first=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Same',operationId:'stable'}});
const second=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Same',operationId:'stable'}});
process.stdout.write(JSON.stringify({{first,second,items:outbox.list()}}));
"""
    output = run_node(script)

    assert output["first"] == output["second"]
    assert len(output["items"]) == 1


def test_authored_outbox_mirrors_to_background_sync_and_reconciles_worker_results():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map(); const mirrors=[]; let requested=0;
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
const backgroundSync = {{
  reconcile: async (items, lane) => mirrors.push({{items:items.map(item=>({{...item}})),lane}}),
  requestSync: async () => {{requested += 1;}},
}};
const outbox=createAuthoredOutbox({{storage,getOwnerLogin:()=>'timmy',backgroundSync}});
const sent=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Sent',operationId:'sent'}});
const failed=outbox.enqueue({{kind:'update-reply',notificationId:2,body:'Fix me',operationId:'failed'}});
setTimeout(() => {{
  const reconciled=outbox.reconcileBackground([
    {{...sent,status:'sent'}},
    {{...failed,status:'attention',error:'Reply rejected'}},
  ]);
  setTimeout(() => process.stdout.write(JSON.stringify({{mirrors,requested,reconciled}})), 0);
}}, 0);
"""
    output = run_node(script)

    assert output["mirrors"][0]["lane"] == "authored"
    assert [item["operationId"] for item in output["mirrors"][-1]["items"]] == ["failed"]
    assert output["requested"] >= 1
    assert [(item["operationId"], item["status"]) for item in output["reconciled"]] == [
        ("failed", "attention")
    ]


def test_authored_outbox_waits_for_durable_background_admission():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map();
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
let release; const gate = new Promise(resolve => release = resolve); const events = [];
const outbox = createAuthoredOutbox({{
  storage, getOwnerLogin:()=> 'timmy',
  backgroundSync: {{
    reconcile: async (_items, lane) => {{ events.push('mirror:' + lane); await gate; events.push('committed'); }},
    requestSync: async () => events.push('registered'),
  }},
}});
const admission = outbox.enqueueDurably({{
  kind:'issue-comment',repository:'o/r',number:1,body:'Do not lose',operationId:'message-1'
}}).then(result => {{ events.push('confirmed'); return result; }});
Promise.resolve().then(async () => {{
  const pending = events.slice(); release(); const result = await admission;
  process.stdout.write(JSON.stringify({{pending,events,result,items:outbox.list()}}));
}});
"""
    output = run_node(script)

    assert output["pending"] == ["mirror:authored"]
    assert output["events"] == ["mirror:authored", "committed", "registered", "confirmed"]
    assert output["result"]["durability"] == "background"
    assert output["items"][0]["operationId"] == "message-1"


def test_authored_outbox_foreground_send_uses_atomic_background_delivery():
    script = f"""
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
const values = new Map(); let backgroundCalls=0; let directCalls=0;
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
const backgroundSync = {{
  reconcile: async()=>{{}}, requestSync:async()=>{{}},
  send: async (item, owner) => {{backgroundCalls += 1; return {{message:{{id:3,owner}}}};}},
}};
const outbox=createAuthoredOutbox({{
  storage,getOwnerLogin:()=>'timmy',backgroundSync,
  fetchJson:async()=>{{directCalls += 1; return {{id:4}};}},
}});
outbox.enqueue({{kind:'pull-comment',repository:'o/r',number:2,body:'Review',operationId:'once'}});
(async()=>{{
  const result=await outbox.flush('timmy');
  process.stdout.write(JSON.stringify({{backgroundCalls,directCalls,result,remaining:outbox.list()}}));
}})();
"""
    output = run_node(script)

    assert output["backgroundCalls"] == 1
    assert output["directCalls"] == 0
    assert output["result"]["confirmed"] == [{"id": 3, "owner": "timmy"}]
    assert output["remaining"] == []


@pytest.mark.anyio
async def test_mobile_dashboard_loads_and_operates_authored_message_outbox():
    html = await dashboard()

    assert '<script src="static/authored-outbox.js"></script>' in html
    assert "const authoredOutbox = createAuthoredOutbox({" in html
    assert "activeFlushLogin = contextIdentityFresh ?" in html
    assert "flushAuthoredOutbox();" in html
    assert "await authoredOutbox.enqueueDurably" in html
    assert "Saving for background delivery…" in html
    assert "Saved for next launch; background delivery unavailable." in html
    assert "authoredOutbox.retry(item.outbox_id, activeFlushLogin)" in html
    assert "authoredOutbox.discard(item.outbox_id)" in html
    assert "if (result?.queued)" in html
    assert "backgroundSync: backgroundIssueSync" in html
    assert "authoredOutbox.reconcileBackground(records)" in html