import https://code.jquery.com/jquery-3.7.1.js
import type {AppletObject} from ./deps/geogebra/api.ts

type AppletDescription
   html: string
   children: HTMLCollection
   id: string
   width: number
   height: number

joyceApplets: AppletDescription[] := []
$('applet[code="Geometry"]').before (i, html) ->
   id := `joyceApplet${i}`
   joyceApplets.push { html, this.children, id,
      width: parseInt(this.getAttribute('width') ?? '200'),
      height: parseInt(this.getAttribute('height') ?? '200') }
   `<div id="${id}"></div>`

jQuery.getScript 'https://www.geogebra.org/apps/deployggb.js', =>
   for each jApp of joyceApplets
      params := {
         appName: 'classic',
         jApp.width,
         jApp.height,
         appletOnLoad: (api: AppletObject) =>
            for child of jApp.children
               dispatchJcommand api, child
            api.setCoordSystem(-10, 10 + jApp.width, -10, 10 + jApp.height)
         } as const
      geoApp := new GGBApplet params
      geoApp.inject jApp.id

type GeogebraCallback = (api: AppletObject) => void
type Commander
   command: string
   callbacks: GeogebraCallback[]

type ClassHandler = (
   name: string, m: string, data: string, colors: string[]) => Commander

function dispatchJcommand(api: AppletObject, param: Element): void
   val := param.getAttribute 'value'
   unless val return
   switch param.getAttribute 'name'
      'background'
         api.setGraphicsOptions 1, bgColor: `#${val}`
      'title'
         api.evalCommand `TitlePoint = Corner(1,1)
            Text("${val}", TitlePoint + (2,5))`
      /e\[\d+\]/
         {command, callbacks} := jToG val
         if command
            if api.evalCommand command
               for each cb of callbacks
                  cb(api)
            else
               console.log `Geogebra command '${command}' translated from`,
                  val, 'failed.'
         else
            console.log `Could not parse command '${val}'`
      else
         console.log `Unkown param ${param}`

function jToG(jCom: string): Commander
   [name, klass, method, data, ...colors] := jCom.split(';')
   if klass in classHandler
      return classHandler[klass] name, method, data, colors
   console.log `Unknown entity class ${klass}`
   command: '', callbacks: []

classHandler: Record<string, ClassHandler> :=
   point: (name, method, data, colors) =>
      command .= ''
      callbacks: GeogebraCallback[] .= []
      args := data.split(',')
      switch method
         /free|fixed/
            command += `${name} = (${data})`
            if method is 'fixed'
               callbacks.push (api: AppletObject) => api.setFixed(name, true)
         'perpendicular'
            [center, direction] := args
            command += `${name} = Rotate(${direction}, 3*pi/2, ${center})`
         'angleDivider'
            n .= -1
            // use the fact that NaN doesn't equal itself:
            nLoc := args.findIndex((arg) => (n = parseInt arg) is n)
            if n >= 0
               args.splice(nLoc)
               [center, start, end] := args
               command += `${name}aUx1 = Segment(${start}, ${end})
                  ${name}aUx2 = Angle(${start}, ${center}, ${end})
                  ${name}aUx2a = If(${name}aUx2 > pi, ${name}aUx2 - 2*pi, ${name}aUx2)
                  ${name}aUx3 = Rotate(${start}, ${name}aUx2a/${n}, ${center})
                  ${name}aUx4 = Ray(${center}, ${name}aUx3)
                  ${name} = Intersect(${name}aUx1, ${name}aUx4)`
         'intersection'
            command += `${name} = Intersect(${data})`
      return {command, callbacks}

   line: (name, method, data, colors) =>
      command .= ''
      callbacks: GeogebraCallback[] .= []
      args := data.split(',')
      switch method
         'connect'
            command += `${name} = Segment(${data})`
         'parallel'
            [newStart, oldStart, oldEnd] := args
            command += `${name}aUx1 = Vector(${oldStart}, ${newStart})
               ${name}aUx2 = Translate(${oldEnd}, ${name}aUx1)
               ${name} = Segment(${newStart}, ${name}aUx2)`
      return {command, callbacks}

   circle: (name, method, data, colors) =>
      command .= ''
      callbacks: GeogebraCallback[] .= []
      switch method
         'radius'
            [center, point] := data.split(',')
            command += `${name} = Circle(${center}, ${point})`
      return {command, callbacks}