import WebSocket from 'ws'
import {setTimeout as wait} from 'node:timers/promises'
import {isIPv4} from 'node:net'
import {Agent as HttpAgent} from 'node:http'
import {Agent as HttpsAgent} from 'node:https'
import {decide,type Observation,type Rules} from './strategy.ts'

const message='ARENA_URL must be a wss:// endpoint or a numeric IPv4 loopback ws:// endpoint ending in /bot, without credentials, query or fragment'
function endpoint(value:string){
  let address:URL
  try{address=new URL(value)}catch{throw Error(message)}
  const local=address.protocol==='ws:' && isIPv4(address.hostname) && address.hostname.startsWith('127.')
  if((address.protocol!=='wss:' && !local) || !address.hostname || address.pathname!=='/bot' || address.username || address.password || address.search || address.hash)throw Error(message)
  return address
}
const url=endpoint(process.env.ARENA_URL??'ws://127.0.0.1:8100/bot')
const agent=url.protocol==='wss:'?new HttpsAgent({proxyEnv:{},rejectUnauthorized:true}):new HttpAgent({proxyEnv:{}})
const token=process.env.ARENA_TOKEN
if(!token || /\s/.test(token)) throw Error('Set ARENA_TOKEN to your bot token')
const version=process.env.ARENA_VERSION??'v1',ladder=process.env.ARENA_LADDER
const count=process.env.ARENA_MATCHES
const target=count===undefined?Infinity:Number(count)
if(count!==undefined && (!/^[1-9]\d*$/.test(count)||!Number.isSafeInteger(target))) throw Error('ARENA_MATCHES must be a positive integer')
const ticket=JSON.stringify({type:'queue',version,...(ladder?{ladder_id:ladder}:{})})
const fatal=new Set(['missing_authorization','invalid_token','replaced','retired','suspended','banned','account_banned','version_retired','version_unknown','unknown_ladder','ladder_unavailable','enrollment_required'])
const stop=new AbortController()
let socket:WebSocket|undefined,played=0,delay=1000
function shutdown(){
  stop.abort()
  if(socket?.readyState===WebSocket.OPEN){
    const ws=socket
    ws.close(1000,'stopping')
    const timeout=setTimeout(()=>ws.terminate(),3000);timeout.unref()
    ws.once('close',()=>clearTimeout(timeout))
  }else if(socket?.readyState===WebSocket.CONNECTING) socket.terminate()
}
process.once('SIGINT',shutdown);process.once('SIGTERM',shutdown)

type Message={type:string;match_id?:string;rules?:Rules;result?:string;reason?:string;code?:string}
async function session(){
  let match:string|undefined,rules:Rules|undefined
  await new Promise<void>((resolve,reject)=>{
    const ws=new WebSocket(url,{agent,rejectUnauthorized:true,headers:{Authorization:'Bearer '+token},handshakeTimeout:10000,followRedirects:false,perMessageDeflate:false})
    socket=ws
    ws.on('open',()=>ws.send(ticket))
    ws.on('unexpected-response',(_req,res)=>{
      if(res.statusCode && res.statusCode>=300 && res.statusCode<400){
        console.error('Arena WebSocket redirects are refused');stop.abort();process.exitCode=1
      }
      res.resume();ws.terminate()
    })
    ws.on('error',err=>{
      const code=(err as NodeJS.ErrnoException).code??''
      if(/CERT|SELF_SIGNED|ISSUER|VERIFY_LEAF/.test(code)){
        console.error('Arena TLS certificate verification failed');stop.abort();process.exitCode=1
      }
    })
    ws.on('close',()=>{socket=undefined;resolve()})
    ws.on('message',data=>{
      try{
        const m=JSON.parse(data.toString()) as Message
        if(m.type==='hello'){
          match=m.match_id;rules=m.rules;ws.send('{"type":"ready"}');delay=1000
        }else if(m.type==='observation'){
          if(!match || !rules) throw Error('Observation arrived before hello')
          const obs=m as unknown as Observation
          ws.send(JSON.stringify({tick:obs.tick,...decide(obs,rules)}))
        }else if(m.type==='end'){
          console.log(m.result+' ('+m.reason+') '+m.match_id);played++;match=undefined;rules=undefined
          if(played>=target){stop.abort();ws.close(1000)}else ws.send(ticket)
        }else if(m.type==='error'){
          console.error('Arena error: '+m.code)
          if(fatal.has(m.code??'')){stop.abort();process.exitCode=1;ws.close(1000)}
        }
      } catch(err){ws.terminate();reject(err)}
    })
  })
}
while(!stop.signal.aborted){
  await session()
  if(!stop.signal.aborted){
    console.error('Reconnecting in '+delay/1000+' s')
    await wait(delay,undefined,{signal:stop.signal}).catch(err=>{if(!stop.signal.aborted)throw err})
    delay=Math.min(delay*2,30000)
  }
}
