export type Tile=[number,number]
type Direction='N'|'NE'|'E'|'SE'|'S'|'SW'|'W'|'NW'
export interface Rules {attacks:{repulsor:{range:number};frostburst:{range:number}}}
export interface Observation {
  tick:number
  self:{pos:Tile;hp:number;max_hp:number;state:string;cooldowns:Record<string,number>}
  enemies:{pos:Tile}[]
  moves:{dir:Direction;tile:Tile}[]
  dashes:{dir:Direction;tile:Tile}[]
  danger:{tile:Tile;tick:number}[]
  pickups:{kind:string;ready_in:number;pos:Tile}[]
  zone:{center:Tile;radius:number;next_radius:number|null}
}
type Action={move?:Direction;dash?:Direction;attack?:{name:string;target?:Tile}}
const distance=(a:Tile,b:Tile)=>Math.max(Math.abs(a[0]-b[0]),Math.abs(a[1]-b[1]))

/** Edit this function to change the bot. An empty action idles for the current tick. */
export function decide(obs:Observation,rules:Rules):Action{
  const {self,zone}=obs
  if(self.state!=='idle') return {}
  const danger=(tile:Tile)=>obs.danger.some(d=>d.tick>=obs.tick && d.tick<=obs.tick+1 && distance(tile,d.tile)===0)
  const radius=zone.next_radius??zone.radius,inside=(tile:Tile)=>distance(tile,zone.center)<=radius
  const underFire=danger(self.pos),enemy=obs.enemies[0]
  if(!underFire && inside(self.pos) && enemy){
    const gap=distance(self.pos,enemy.pos)
    if(self.cooldowns.repulsor===0 && gap<=rules.attacks.repulsor.range) return {attack:{name:'repulsor'}}
    if(self.cooldowns.frostburst===0 && gap<=rules.attacks.frostburst.range) return {attack:{name:'frostburst',target:enemy.pos}}
    if(self.cooldowns.ranged===0) return {attack:{name:'ranged',target:enemy.pos}}
  }
  const health=obs.pickups.filter(p=>p.ready_in===0 && p.kind==='health' && inside(p.pos))
    .sort((a,b)=>distance(a.pos,self.pos)-distance(b.pos,self.pos))[0]
  const goal=!inside(self.pos)?zone.center:self.hp<self.max_hp && health?health.pos:enemy?.pos??zone.center
  const score=(tile:Tile)=>distance(tile,goal)+(inside(tile)?0:50)+(danger(tile)?100:0)
  const choices=obs.moves.map(m=>({tile:m.tile,action:{move:m.dir} as Action}))
  if(underFire || !inside(self.pos)) choices.push(...obs.dashes.map(m=>({tile:m.tile,action:{dash:m.dir}})))
  choices.sort((a,b)=>score(a.tile)-score(b.tile))
  const best=choices[0]
  return best && score(best.tile)<score(self.pos)?best.action:{}
}
