import test, { type TestContext } from 'node:test';
import assert from 'node:assert/strict';
import { KickHostRelay } from '../src/kick/KickHostRelay.ts';
import type { ChannelStatus, EngineEvent } from '../src/types.ts';

const channel: ChannelStatus = {channel_id:1,slug:'streamer',kick_chatroom_id:'123',streamer_id:1,kick_channel_id:'1',kick_user_id:'1',display_name:'Streamer',live_status:'online',moderator_status:'moderator'};
function fixture(t: TestContext) {
  const sent: Record<string,unknown>[] = [], events: EngineEvent[] = [];
  // The transport is faked to exercise actual protocol handlers without
  // connecting to Kick or emitting alerts into a streamer's live overlay.
  const relay: any = new KickHostRelay(event => events.push(event));
  const socket = {readyState:1,send:(raw: string)=>sent.push(JSON.parse(raw)),close(){this.readyState=3;}};
  relay.socket = socket;
  relay.channelsByChatroom.set('chatrooms.123',channel);
  relay.trackedChannelsById.set(1,channel);
  t.after(()=>relay.close());
  return {relay,socket,sent,events};
}

test('answers negotiated JSON heartbeat pings, including batched frames',t=>{
  const {relay,socket,sent}=fixture(t);
  relay.handleMessage(socket,JSON.stringify({id:1,connect:{ping:25,pong:true}}));
  sent.length=0;
  relay.handleMessage(socket,'{}');
  relay.handleMessage(socket,'{}\n{}');
  assert.deepEqual(sent,[{},{},{}]);
});

test('does not send pongs when server did not negotiate them',t=>{
  const {relay,socket,sent}=fixture(t);
  relay.handleMessage(socket,JSON.stringify({connect:{ping:25,pong:false}}));
  sent.length=0;
  relay.handleMessage(socket,'{}');
  assert.equal(sent.length,0);
});

test('detects a silently dead connection and schedules reconnect',t=>{
  t.mock.timers.enable({apis:['setTimeout']});
  const {relay,socket}=fixture(t);
  relay.handleMessage(socket,JSON.stringify({connect:{ping:25,pong:true}}));
  t.mock.timers.tick(34_000);
  assert.equal(socket.readyState,1);
  t.mock.timers.tick(1_001);
  assert.equal(socket.readyState,3);
  assert.ok(relay.retryTimer);
  assert.equal(relay.ready,false);
});

test('incoming ping extends connection lifetime',t=>{
  t.mock.timers.enable({apis:['setTimeout']});
  const {relay,socket}=fixture(t);
  relay.handleMessage(socket,JSON.stringify({connect:{ping:25,pong:true}}));
  t.mock.timers.tick(25_000);
  relay.handleMessage(socket,'{}');
  t.mock.timers.tick(25_000);
  assert.equal(socket.readyState,1);
  assert.equal(relay.ready,true);
});

test('credential expiry closes and reconnects instead of stopping relay',t=>{
  t.mock.timers.enable({apis:['setTimeout']});
  const {relay,socket}=fixture(t);
  relay.scheduleRefresh({ttl:90});
  t.mock.timers.tick(45_000);
  assert.equal(socket.readyState,3);
  assert.ok(relay.retryTimer);
});

test('initial API failure schedules retry after connecting flag is released',async t=>{
  const {relay}=fixture(t);
  relay.socket=null;
  relay.connecting=true;
  relay.postJson=async()=>{throw new Error('simulated HTTP 503');};
  await relay.openConnection();
  assert.equal(relay.connecting,false);
  assert.ok(relay.retryTimer);
});

test('refresh keeps previously working chatroom ids during public API failure',t=>{
  const {relay}=fixture(t);
  relay.resolvedChatroomIds.set(1,{ids:[123,456],expiresAt:Date.now()-1});
  relay.resolveRealtimeChannelIds=async()=>{};
  relay.sync([channel]);
  assert.equal(relay.channelsByChatroom.get('chatrooms.456'),channel);
});

test('translates the current Kick host payload into one configured channel raid',t=>{
  const {relay,socket,events}=fixture(t);
  relay.handleMessage(socket,JSON.stringify({push:{channel:'chatrooms.123',pub:{data:{event:'App\\Events\\StreamHostedEvent',data:{user:{username:'Raider'},message:{numberOfViewers:42}}}}}}));
  assert.equal(events.length,1);
  const event=events[0];
  assert.ok(event);
  assert.equal(event.type,'channel.raid.received');
  assert.equal(event.channel_id,1);
  assert.equal(event.payload.username,'Raider');
  assert.equal(event.payload.viewer_count,42);
});

test('handshake rejection triggers reconnect immediately',t=>{
  const {relay,socket}=fixture(t);
  relay.connectCommandId=12;
  relay.handleMessage(socket,JSON.stringify({id:12,error:{code:109,message:'expired'}}));
  assert.equal(socket.readyState,3);
  assert.ok(relay.retryTimer);
});

test('a server disconnect push closes the stale socket and reconnects',t=>{
  const {relay,socket}=fixture(t);
  relay.handleMessage(socket,JSON.stringify({push:{disconnect:{code:3004,reason:'test'}}}));
  assert.equal(socket.readyState,3);
  assert.ok(relay.retryTimer);
});

test('socket that never finishes handshake cannot stay stuck indefinitely',async t=>{
  t.mock.timers.enable({apis:['setTimeout']});
  const {relay}=fixture(t);
  relay.socket=null;
  relay.connecting=true;
  relay.postJson=async (path: string)=>path==='/connection'
    ? {data:{connections:[{provider:'centrifugo',credentials:{url:'wss://example.invalid'}}]}}
    : {data:{token:'fake-token-only-for-this-offline-test'}};
  const nativeWebSocket=globalThis.WebSocket;
  globalThis.WebSocket=class {static OPEN=1;readyState=0;close(){this.readyState=3;}} as unknown as typeof WebSocket;
  try {
    await relay.openConnection();
    const socket=relay.socket;
    t.mock.timers.tick(10_001);
    assert.equal(socket.readyState,3);
    assert.equal(relay.socket,null);
    assert.ok(relay.retryTimer);
  } finally {globalThis.WebSocket=nativeWebSocket;}
});
