import ./deps/jquery.js
import type {AppletObject} from ./deps/geotypes/api.ts
import {AppletDescription, AdapParams, params, contains3d} from ./adapptypes.ts
colorsea from ./deps/colorsea.js

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

type Split<S extends string>
   S extends `${infer W} ${infer R}` ? (W | Split<R>) : S

classes := 'point line circle polygon sector plane sphere polyhedron'
type JoyceClass = Split<typeof classes>
function assertJoyceClass(s: string): asserts s is JoyceClass
   unless classes.includes s then throw new Error `Oops ${s} slipped through`

type JoyceName = string  // we use this to indicate where the names
   // from the Joyce commands (which are used as captions in the GeoGebra
   // applet) go.
type GeoName = string  // and this to indicate where GeoGebra identifiers go
type AnyName = GeoName | JoyceName  // and this for slots that can be either

type Description
   otherName: AnyName
   usesCaptions: JoyceName[]
   klass: JoyceClass
   ends?: [GeoName, GeoName]

// We put both JoyceNames and GeoNames in here, pointing to each other
// with the otherName property:
type JoyceElements = Record<AnyName, Description>

adapptScript := findAdappt() as HTMLScriptElement

function findAdappt()
  scripts := document.querySelectorAll 'script'
  for scrip of scripts
     src := scrip.getAttribute 'src'
     if src and src.includes 'adapptlet'
        return scrip

adapParams: AdapParams :=
   typeof GGBApplet is 'undefined'
      ? {loader: 'https://www.geogebra.org/apps/deployggb.js', joyceApplets: []}
      : JSON.parse(adapptScript.dataset.params ?? '') as AdapParams

function postApplets(jApplets: AppletDescription[], codebase = '')
   for each jApp of jApplets
      params := {
         appName: 'classic',
         -enableRightClick,
         // +showMenuBar,
         jApp.width,
         jApp.height,
         appletOnLoad: (api: AppletObject) =>
            elements: JoyceElements := {}
            backgroundRGB := [255, 255, 255] as RGB
            config3d := contains3d jApp.params
            if config3d
               api.enable3D true
               api.setPerspective 'T'
               // Get rid of the xy-plane indicator
               xml .= api.getXML()
               xml = xml.replace /plate.show="\w+"/, 'plate show="false"'
               api.setXML xml
            else if codebase.includes 'web3d'
               api.setPerspective 'G'
            if adapParams.config?.algebra
               api.setPerspective '+A'
            for name, value in jApp.params
               dispatchJcommand
                  api, name, value, elements, backgroundRGB, config3d
            if config3d
               depth .= jApp.width
               if jApp.height > depth then depth = jApp.height
               api.setCoordSystem
                  -10, 10 + jApp.width,
                  -10, 10 + jApp.height,
                  -depth - 10, depth + 10,
                  false
               api.setAxesVisible 3, false, false, false
               api.setGridVisible 3, false
            else
               api.setCoordSystem -10, 10 + jApp.width, -10, 10 + jApp.height
               api.setAxesVisible false, false
               api.setGridVisible false
         } as const
      geoApp := new GGBApplet params
      if codebase then geoApp.setHTML5Codebase codebase
      geoApp.inject jApp.id

// Always use the final joyceApplets if there are any:
if joyceApplets.length
   adapParams.joyceApplets = joyceApplets

if adapParams.joyceApplets.length
   if adapParams.loader
      jQuery.getScript adapParams.loader, =>
         postApplets adapParams.joyceApplets
   else
      postApplets adapParams.joyceApplets, adapParams.codebase

/* That's all of the actions of this script. All of the remainder is
 * implementation.
 */

type DimParts = [string[], string[], string[]] // Gives GeoNames
      // or expressions for 0-, 1-, and 2-dimensional parts for coloring

// need to pass the parts into the callbacks because sometimes the parts
// are not generated until callback time
type GeogebraCallback = (api: AppletObject, parts: DimParts) => void
type Commander
   commands: string[]
   callbacks: GeogebraCallback[]
   parts: DimParts
   auxiliaries: GeoName[]  // extra entities needed in GeoGebra
   ends?: [GeoName, GeoName]

function freshCommander(): Commander
  commands: []
  callbacks: []
  parts: [[], [], []]
  auxiliaries: []

type JoyceArguments =
   Partial<Record<JoyceClass|'subpoints', GeoName[]> & {scalar: number[]}>
type ClassHandler = (
   name: GeoName,
   method: string,
   args: JoyceArguments,
   index: number,
   is3d: boolean) => Commander
type RGB = [number, number, number]
type XYZ = RGB

// Executes the command corresponding to param against the GeoGebra applet
// api, consulting and extending by side effect the elements that are
// present in that applet
function dispatchJcommand(
      api: AppletObject,
      name: string,
      value: string,
      elements: JoyceElements
      backgroundRGB: RGB,
      is3d: boolean): void
   switch name
      'background'
         newback := joyce2rgb value, backgroundRGB
         if adapParams.config?.commands
            console.log 'Setting background to', value, 'interpreted as',
               newback
         for i of [0..2]
            backgroundRGB[i] = newback[i]
         api.setGraphicsOptions 1, bgColor: colorsea(backgroundRGB).hex()
      'title'
         if adapParams.config?.commands
            console.log 'Setting title to', value
         corner := is3d ? 'Corner(-1,1)' : 'Corner(1,1)'
         api.evalCommand `TitlePoint = ${corner}
            Text("${value}", TitlePoint + (2,5))`
      /e\[\d+\]/
         num := parseInt(name.slice(2))
         {commands, callbacks, parts} :=
            jToG value, elements, num, backgroundRGB, is3d
         if commands.length
            lastTried .= 0
            if commands.filter((&)).every (cmd) =>
                  if adapParams.config?.commands
                     console.log 'Translated to:', cmd
                  api.evalCommand(cmd) and ++lastTried
               callbacks.forEach &(api, parts)
            else console.warn
               `Geogebra command '${commands[lastTried]}'
                (part of translation of '${value}')
                failed.`
         else console.warn `Could not parse command '${value}'`
      else console.warn `Unkown param ${name} = ${value}`

// Parses a Joyce element-creating command, extending the elements
// by side effect:
function jToG(
      jCom: string,
      elements: JoyceElements,
      index: number,
      backgroundRGB: RGB
      is3d: boolean): Commander
   [jname, klass, method, data, ...colors] := jCom.split ';'
   if adapParams.config?.commands
      console.log 'Defining', jname, 'as a', klass, 'constructed by',
         method, 'from', data, 'colored as', colors
   cmdr .= freshCommander()
   unless klass in classHandler
      console.warn `Unknown entity class ${klass}`
      return cmdr
   assertJoyceClass klass  // shouldn't need to do that :-/
   name := if /^\p{L}\w*$/u.test jname then jname else geoname jname, elements
   args: JoyceArguments := {}
   usesCaptions := []
   for each jdep of data.split ','
      scalar := parseFloat jdep
      if scalar is scalar // not NaN
         (args.scalar ?= []).push scalar
         continue
      unless jdep in elements
         console.warn `Reference to unknown geometric entity ${jdep} in $jCom}`
         return cmdr
      usesCaptions.push jdep
      {klass: depKlass, otherName: depGeo, ends} := elements[jdep]
      (args[depKlass] ?= []).push depGeo
      if depKlass is 'point'
         (args.subpoints ?= []).push depGeo
      else if depKlass is 'line'
         (args.subpoints ?= []).push ...ends ?? []
   cmdr = classHandler[klass] name, method, args, index, is3d
   unless name is jname then cmdr.callbacks.push (api: AppletObject) =>
      api.setCaption name, jname
      api.setLabelStyle name, 3  // style CAPTION = 3
   if cmdr.auxiliaries.length and not adapParams.config?.showaux
      cmdr.callbacks.push (api: AppletObject) =>
         for each aux of cmdr.auxiliaries
            api.setAuxiliary aux, true
            api.setVisible aux,false
   // Create callback to assign colors
   if colors.length is 4 and colors.every (color) => invisible color
      cmdr.callbacks.push (api: AppletObject) => api.setVisible name, false
   else // we have to decorate
      dimension .= cmdr.parts.findLastIndex .includes name
      cmdr.callbacks.push (api: AppletObject, parts: DimParts) =>
         trace := adapParams.config?.color
         // Operate in order faces, lines, point, caption so that
         // we can adjust components after setting overall color, etc.

         // Color the "Faces"; they default to 'brighter':
         if invisible colors[3]
             for each face of parts[2]
                if face is name
                   console.log 'Fading out interior of', face if trace
                   // hide the interior by making it transparent
                   api.setFilling face, 0
                else if face not in elements
                   console.log 'Hiding face', face if trace
                   api.setVisible face, false
         else
            faceRGB := joyce2rgb(colors[3] or 'brighter', backgroundRGB)
            deep := ['circle', 'polygon', 'sector']
            filling := deep.includes(klass) ? 0.7 : 0.2
            for each face of parts[2]
               console.log 'Coloring face', face, 'to', colors[3] if trace
               api.setVisible face, true
               api.setFilling face, filling
               api.setColor face, ...faceRGB

         // Lines default to black:
         if invisible colors[2]
            for each line of parts[1]
                if line is name or line not in elements
                   console.log 'Hiding line', line if trace
                   api.setVisible line, false
         else
            lineRGB := joyce2rgb(colors[2] or 'black', backgroundRGB)
            for each line of parts[1]
               console.log 'Coloring line', line, 'to', colors[2] if trace
               api.setVisible line, true
               api.setColor line, ...lineRGB

         // Now color the points:
         console.log 'Considering point colors for', name if trace
         if invisible colors[1]
            // Hide all the dim-0 elements that are not distinct independent
            // items:
            for each point of parts[0]
               if point is name or point not in elements
                  console.log 'Hiding point', point if trace
                  api.setVisible point, false
         else if dimension is 0 or colors[1] // Need to color the points
            ptRGB := colors[1] ? joyce2rgb colors[1], backgroundRGB
               : pointDefaultRGB name, method
            for each point of parts[0]
               console.log 'Coloring point', point, 'to', colors[1] if trace
               api.setVisible point, true
               api.setColor point, ...ptRGB

         // Make the caption the correct color
         if invisible colors[0]
            console.log 'Hiding label', name if trace
            api.setLabelVisible name, false
         else if colors[dimension] and colors[dimension] is not colors[0]
            // Have to make a text to provide the caption, since GeoGebra
            // doesn't allow caption different color from entity.
            textName := 'GeoText' + index
            locationExpr := switch klass
               when 'point' then `1.02${name})`
               when 'line'
                  (`Midpoint(${name}) + `
                  + `Rotate(Direction(${name})*Length(${name})*0.02, pi/2)`)
               when 'circle'
                  `Center(${name}) + Radius(${name})*Vector((12/13,5/13))*1.03`
               when 'polygon' then `Centroid(${name})`
               when 'sector'
                  `(5*Center(${name}) - ${cmdr.ends?[0]} - ${cmdr.ends?[1]})/3`
               when 'plane'
                  `Intersect(${name}, PerpendicularLine((0, 0, 0), ${name}))`
               when 'sphere'
                  `Center(${name})+Radius(${name})*Vector((12/13,0,5/13))*1.03`
               when 'polyhedron'
                  // The "ends" are faces or vertices roughly opposite
                  // from each other
                  [ex1, ex2] .= cmdr.ends ?? ['', '']
                  unless parts[0].includes ex1 then ex1 = `Centroid(${ex1})`
                  unless parts[0].includes ex2 then ex2 = `Centroid(${ex2})`
                  `(4*${ex1}+${ex2})/5`
            api.evalCommand `${textName} = Text("${jname}", ${locationExpr})`
            api.setColor textName, ...joyce2rgb colors[0], backgroundRGB
            // and hide the underlying GeoGebra label
            api.setLabelVisible name, false
         else if colors[0]
            // Label gets the correct color from element
            // but we had better make sure it is visible:
            console.log 'Showing label', name if trace
            api.setLabelVisible name, true
         else
            // label color is defaulting. Same as element for points, invisible
            // otherwise:
            show := klass is 'point'
            console.log 'Setting label vis of', name, 'to', show if trace
            api.setLabelVisible name, show

//         window[hideListener] = (arg) =>
//            api.setVisible name, false
//         api.registerObjectUpdateListener name, hideListener
   if cmdr.ends // line or sector
      elements[jname] =
         {otherName: name, usesCaptions, klass, cmdr.ends}
      elements[name] =
         {otherName: jname, usesCaptions, klass, cmdr.ends}
   else // any other geometry
      elements[jname] = {otherName: name, usesCaptions, klass}
      elements[name] = {otherName: jname, usesCaptions, klass}
   cmdr

function invisible(cname: string): boolean
   if adapParams.config?.showall then return false
   cname is '0' or cname is 'none'

function joyce2rgb(cname: string, backgroundRGB?: RGB): RGB
   whiteRGB: RGB := [255, 255, 255]
   bg: RGB := backgroundRGB or whiteRGB
   switch cname
      // RGB values from Duck Duck Go search on "[COLOR] rgb"
      /black/i
         [0,0,0]
      /blue/i
         [0,0,255]
      /cyan/i
         [0,255,255]
      /darkgray/i
         [128,128,128]
      /^gray/i
         [169,169,169]
      /green/i
         [0,255,0]
      /lightgray/i
         [211,211,211]
      /magenta/i
         [255,0,255]
      /orange/i
         [255,165,0]
      /pink/i
         [255,192,203]
      /red/i
         [255,0,0]
      /white/i
         [255,255,255]
      /yellow/i
         [255,255,0]
      /random/i
         colorsea.random().lighten(40).rgb()
      /background/i
         bg
      /brighter/i
         colorsea(bg).lighten(30).rgb()
      /darker/i
         colorsea(bg).darken(20).rgb()
      /^[0-9A-F]{6}$/i
         colorsea(`#${cname}`).rgb()
      /^\d+,\d+,\d+$/
         // HSB specification
         [H,S,B] := cname.split(',').map (s) => parseInt s
         colorsea.hsv(H, S, B).rgb()
      else
         console.warn 'Could not parse color:', cname
         [128, 128, 128]

function pointDefaultRGB(name: string, method: string): RGB
   // Need to short-circuit with green for pivot point, once that is implemented
   switch method
      'free'
         joyce2rgb 'red'
      /.*[Ss]lider$/
         joyce2rgb 'orange'
      else joyce2rgb 'black'

function geoname(jname: JoyceName, elements: JoyceElements): GeoName
   numCode .= 0n
   numCode = numCode*128n + BigInt ch.codePointAt(0) ?? 1 for each ch of jname
   return .= 'Geo' + numCode.toString(36);
   return += '1' while return.value in elements

// Helper for similar point/line functions:
function cutoffExtend(
      method: string, pt: string[], point?: string[], line?: string[]
      ): [string, string]
   direction .= `UnitVector(Vector(${pt[0]},${pt[1]}))`
   if line and (not point or point[0] !== pt[0])
      direction = `UnitVector(${line[0]})`
   displacement := `Distance(${pt[2]}, ${pt[3]})*${direction}`
   source := method is 'cutoff' ? pt[0] : pt[1]
   [source, displacement]

// All of the detailed semantics of each available command lies in this
// function.
classHandler: Record<JoyceClass, ClassHandler> :=
   point: (name, method, args, index, is3d): Commander =>
      return := freshCommander()
      {commands, callbacks, parts, auxiliaries} := return.value
      zeroVector := is3d ? 'Vector((0,0,0))' : 'Vector((0,0))'
      aux := name + 'aUx'
      parts[0].push name
      switch method
         /angle(?:Bisector|Divider)/
            // Note we just ignore a possible plane argument; it's irrelevant
            unless args.subpoints return
            [start, center, end] := args.subpoints
            // see if we need to make the destination segment from start to end
            destination .= ''
            unless args.line?.length is 1 and args.point?[0] is center
               destination = aux + '1'
               auxiliaries.push destination
               commands.push `${destination} = Segment(${start}, ${end})`
            else destination = args.line[0]
            n := method is 'angleBisector' ? 2 : args.scalar?[0]
            inPlane := is3d ? `, Plane(${start}, ${center}, ${end})` : ''
            commands.push
               `${aux}2 = Angle(${start}, ${center}, ${end}${inPlane})`
               `${aux}3 = If(${aux}2 > pi, ${aux}2 - 2*pi, ${aux}2)`
               `${aux}4 = Rotate(${start}, ${aux}3/${n}, ${center}${inPlane})`
               `${name} = Intersect(${destination}, Ray(${center}, ${aux}4))`
            auxiliaries.push ...[2..4].map (i) => `${aux}${i}`
         'circleSlider'
            unless args.circle then return
            commands.push `${name} = Point(${args.circle[0]})`
            if args.scalar and args.scalar.length
               callbacks.push (api: AppletObject) =>
                  api.setCoords name, ...args.scalar as XYZ
         /cutoff|extend/
            pt := args.subpoints
            unless pt and pt.length is 4 then return
            [source, displacement] :=
               cutoffExtend method, pt, args.point, args.line
            commands.push `${name} = Translate(${source}, ${displacement})`
         'first'
            unless args.subpoints then return
            commands.push `${name} = Point(${args.subpoints[0]},${zeroVector})`
         /fixed|free/
            coords := args.scalar
            unless coords then return
            commands.push `${name} = Point({${coords.join ','}})`
            if method is 'fixed'
               callbacks.push (api: AppletObject) => api.setFixed name, true
         'foot'
            pt := args.subpoints
            unless pt then return
            destination := args.plane
               ? args.plane[0]
               : `Line(${pt[1]},${pt[2]})`
            commands.push
               `${name} = ClosestPoint(${destination}, ${pt[0]})`
         'intersection'
            // Checking Joyce source, means intersection of lines, not
            // intersection of line segments
            pt := args.subpoints
            unless pt then return
            l1 := `Line(${pt[0]},${pt[1]})`
            e2 := args.plane ? args.plane[0] : `Line(${pt[2]},${pt[3]})`
            commands.push `${name} = Intersect(${l1},${e2})`
         'last'
            unless args.subpoints then return
            commands.push
               `${name} = Point(${args.subpoints.at(-1)}, ${zeroVector})`
         'lineSegmentSlider'
            segment .= args.line?[0]
            unless segment
               unless args.point then return
               commands.push `${aux} = Segment(${args.point.join ','})`
               auxiliaries.push aux
               segment = aux
            commands.push `${name} = Point(${segment})`
            if args.scalar and args.scalar.length
               callbacks.push (api: AppletObject) =>
                  api.setCoords name, ...args.scalar as XYZ
         'midpoint'
            if args.line
               commands.push `${name} = Midpoint(${args.line[0]})`
            else
               commands.push
                  `${name} = Midpoint(${args.point?[0]},${args.point?[1]})`
         'perpendicular'
            // Note only the two-point option implemented so far
            unless args.subpoints return
            [center, direction] := args.subpoints
            // Note clockwise 90° rotation (3π/2) confirmed in Joyce source
            commands.push `${name} = Rotate(${direction}, 3*pi/2, ${center})`
         /proportion|similar/
            pt .= args.subpoints
            unless pt then return
            // reduce the similar case to general proportion
            if method is 'similar'
               unless pt.length is 5 then return
               sourcePlane .= ''
               destPlane .= ''
               if is3d
                  unless args.plane then return
                  destPlane = `, ${args.plane[0]}`
                  if args.plane.length > 1
                     sourcePlane = `, ${args.plane[1]}`
                  else
                     sourcePlane = `, Plane(${pt[2]}, ${pt[3]}, ${pt[4]})`
               angle := `Angle(${pt[3]}, ${pt[2]}, ${pt[4]}${sourcePlane})`
               commands.push
                  `${aux} = Rotate(${pt[1]}, ${angle}, ${pt[0]}${destPlane})`
               auxiliaries.push aux
               pt = [pt[2], pt[3], pt[2], pt[4], pt[0], pt[1], pt[0], aux]
            len := `Distance(${pt[2]},${pt[3]})*Distance(${pt[4]},${pt[5]})`
               + `/ Distance(${pt[0]},${pt[1]})`
            direction := `UnitVector(Vector(${pt[6]}, ${pt[7]}))`
            commands.push `${name} = Translate(${pt[6]}, ${len}*${direction})`
         'vertex'
            commands.push
               `${name} = Vertex(${args.polygon?[0]},${args.scalar?[0]})`

   line: (name, method, args, index, is3d) =>
      return := freshCommander()
      return.value.ends = ['', '']
      {commands, callbacks, parts, auxiliaries, ends} := return.value
      aux := name + 'aUx'
      parts[1].push name
      madeSegment .= false
      switch method
         'bichord'
            // To match Joyce, we need to get the ordering here correct.
            // we want the order so that start -> end sweeping past the
            // center of the other circle is counterclockwise in the first
            // circle
            cr := args.circle
            unless cr return
            commands.push ...[1..2].map (n) =>
              `${aux}${n} = Intersect(${cr[0]}, ${cr[1]}, ${n})`
            inPlane := is3d ? `Plane(${cr[0]})` : ''
            ctr := cr.map (c) => `Center(${c})`
            condition := (`Angle(${aux}1,${ctr[0]},${ctr[1]}${inPlane})`
               + `< Angle(${aux}2,${ctr[0]},${ctr[1]}${inPlane})`)
            commands.push
              `${aux}3 = If(${condition}, ${aux}2, ${aux}1)`
              `${aux}4 = If(${condition}, ${aux}1, ${aux}2)`
            ends[0] = aux + 3
            ends[1] = aux + 4
            auxiliaries.push ...[1..4].map (n) => aux + n
         'chord'
            // To match Joyce, we need to get the ordering here correct.
            // The complicated condition about distances is modeled after
            // Joyce's code, but it boils down to: take the endpoint of the
            // chord closest to the first subpoint, unless that first
            // subpoint is essentially at the midpoint of the chord, in
            // which case start with the endpoint nearest the second subpoint.
            unless args.subpoints and args.circle then return
            // We intersect with the whole line, not just the segment:
            line := `Line(${args.subpoints.join ','})`
            pA := args.subpoints[0]
            pB := args.subpoints[1]
            commands.push ...[1..2].map (n) =>
              `${aux}${n} = Intersect(${args.circle}, ${line}, ${n})`
            s := `Distance(${aux}1,${aux}2)`
            d := `Distance(${aux}1,${pA}) - Distance(${aux}2,${pA})`
            condition := (`If(${s}/10^9 < abs(${d}), ${d} > 0,`
               + `Distance(${aux}2,${pB}) < Distance(${aux}1,${pB}))`)
            commands.push
              `${aux}3 = If(${condition}, ${aux}2, ${aux}1)`
              `${aux}4 = If(${condition}, ${aux}1, ${aux}2)`
            ends[0] = aux + 3
            ends[1] = aux + 4
            auxiliaries.push ...[1..4].map (n) => aux + n
         'connect'
            unless args.subpoints and args.subpoints.length is 2 then return
            ends[0] = args.subpoints[0]
            ends[1] = args.subpoints[1]
         /cutoff|extend/
            pt := args.subpoints
            unless pt and pt.length is 4 then return
            [source, displacement] :=
               cutoffExtend method, pt, args.point, args.line
            ends[0] = source
            commands.push `${aux} = Translate(${source}, ${displacement})`
            auxiliaries.push aux
            ends[1] = aux
         'parallel'
            unless args.subpoints then return
            [newStart, oldStart, oldEnd] := args.subpoints
            commands.push `${aux}1 = Vector(${oldStart}, ${newStart})`
            auxiliaries.push aux + 1, aux + 2
            ends[0] = newStart
            ends[1] = aux + 2
            if args.line?.length is 1 and args.point?[0] is args.subpoints[0]
               // In this case we are translating an existing segment
               commands.push
                  `${name} = Translate(${args.line[0]}, ${aux}1)`
                  `${aux}2 = Vertex(${name}, 2)`
               madeSegment = true
            else
               commands.push `${aux}2 = Translate(${oldEnd}, ${aux}1)`
      unless madeSegment
         commands.push `${name} = Segment(${ends[0]},${ends[1]})`
      callbacks.push (api: AppletObject) => api.setLabelVisible name, true
      parts[0].push ...ends

   circle: (name, method, args) =>
      return := freshCommander()
      {commands, callbacks, parts, auxiliaries} := return.value
      parts[2].push name
      parts[1].push name
      switch method
         'radius'
            pt := args.subpoints
            unless pt then return
            inPlane := args.plane ? `, ${args.plane[0]}` : ''
            switch pt.length
               when 2
                  [center, point] := pt
                  commands.push
                     `${name} = Circle(${center}, ${point}${inPlane})`
               when 3
                  center := pt[0]
                  radius := `Distance(${pt[1]}, ${pt[2]})`
                  commands.push
                     `${name} = Circle(${center}, ${radius}${inPlane})`
      callbacks.push (api: AppletObject) => api.setLabelVisible name, true

   polygon: (name, method, args, index) =>
      return := freshCommander()
      {commands, callbacks, parts, auxiliaries} := return.value
      parts[2].push name
      // what to push for edges?
      switch method
         'equilateralTriangle'
            pt := args.subpoints
            unless pt then return
            commands.push '' // hack, make sure there is a command
            parts[0].push pt[0], pt[1]
            callbacks.push (api: AppletObject, moreParts: DimParts) =>
               made:= api.evalCommandGetLabels
                  `${name} = Polygon(${pt[1]},${pt[0]}, 3)`
               if not made return
               for each obj of made.split ','
                  if obj is name continue
                  newObj := 'GeoAux' + index + obj
                  api.renameObject obj, newObj
                  switch api.getObjectType newObj
                     'segment'
                        moreParts[1].push newObj
                     'point'
                        moreParts[0].push newObj
                        api.setVisible newObj, false
         /triangle|quadrilateral/
            pt := args.subpoints
            unless pt then return
            commands.push ''
            parts[0].push ...pt
            callbacks.push (api: AppletObject, moreParts: DimParts) =>
               made := api.evalCommandGetLabels
                  `${name} = Polygon(${pt.join ','})`
               if not made return
               for each obj of made.split ','
                  if obj is name continue
                  newObj := 'GeoAux' + index + obj
                  api.renameObject obj, newObj
                  moreParts[1].push newObj

   sector: (name, method, args, index) =>
      return := freshCommander()
      return.value.ends = ['', '']
      {commands, callbacks, parts, auxiliaries, ends} := return.value
      aux := name + 'aUx'
      parts[2].push name
      switch method
         'sector'
            unless args.subpoints?.length is 3 return
            parts[0].push ...args.subpoints
            [center, end, start] := args.subpoints
            ends[0] = start
            ends[1] = end
            parms := center + ', ' + start + ', ' + end
            commands.push
               `${name} = CircularSector(${parms})`
               `${aux}1 = CircularArc(${parms})`
            parts[1].push aux + 1
            callbacks.push (api: AppletObject) =>
               api.setLineThickness name, 1
               // The rest of this function is a weird roundabout way to make
               // the lines of the sector have zero opacity.
               // I got it from
               // https://www.reddit.com/r/geogebra/comments/12cbr85/setlineopacity_command/
               // I don't really understand how/why it works, but it seems to
               // So that's good enough for me
               xml .= api.getXML name
               xml = xml.replace /opacity="\d+"/, 'opacity="0"'
               api.evalXML xml
               // This last step is especially confusing... I think
               // evaluating the modified XML created a sort of second
               // copy of the entity, and so we have to hide the original one
               api.setVisible name, false

   plane: (name, method, args) =>
      return := freshCommander()
      {commands, callbacks, parts, auxiliaries} := return.value
      parts[2].push name
      switch method
         '3points'
            unless args.subpoints?.length is 3 then return
            commands.push `${name} = Plane(${args.subpoints.join ','})`
         'perpendicular'
            unless args.subpoints?.length is 2 then return
            [thru, perp] := args.subpoints
            commands.push
               `${name} = PerpendicularPlane(${thru}, Line(${thru}, ${perp}))`

   sphere: (name, method, args) => freshCommander()

   polyhedron: (name, method, args, index) =>
      return := freshCommander()
      return.value.ends = ['', '']
      {commands, callbacks, parts, auxiliaries, ends} := return.value
      aux := name + 'aUx'
      switch method
         'tetrahedron'
            pt := args.subpoints
            unless pt and pt.length is 4 then return
            commands.push '' // hack, make sure there is a command
            parts[0].push ...pt
            ends[0] = aux + 1
            ends[1] = pt[3]
            callbacks.push (api: AppletObject, moreParts: DimParts) =>
               madeBase := api.evalCommandGetLabels
                  `${ends[0]} = Polygon(${pt[0]},${pt[1]},${pt[2]})`
               if not madeBase return
               for each obj of madeBase.split ','
                  if obj is ends[0] continue
                  newObj := 'GeoAux' + index + obj
                  api.renameObject obj, newObj
                  moreParts[1].push newObj
               made := api.evalCommandGetLabels
                  `${name} = Pyramid(${aux}1, ${pt[3]})`
               if not made return
               for each obj of made.split ','
                  if obj is name continue
                  newObj := 'GeoAux' + index + obj
                  api.renameObject obj, newObj
                  switch api.getObjectType newObj
                     'segment'
                        moreParts[1].push newObj
                     'triangle'
                        moreParts[2].push newObj