use itertools::izip;
use std::{f64::consts::{FRAC_1_SQRT_2, PI, SQRT_2}, rc::Rc};
use nalgebra::Vector3;
use sycamore::prelude::*;
use web_sys::{console, wasm_bindgen::JsValue};

use crate::{
    AppState,
    assembly::{
        Assembly,
        Element,
        ElementColor,
        InversiveDistanceRegulator,
        Point,
        PointCoordinateRegulator,
        Regulator,
        Sphere,
    },
    engine,
    engine::{DescentHistory, point},
    specified::SpecifiedValue,
};

// Convenience: macro to allow elision of const array lengths
// adapted from https://stackoverflow.com/a/59905715
macro_rules! const_array {
    ($name: ident: $ty: ty = $value: expr) => {
        const $name: [$ty; $value.len()] = $value;
    }
}

// Convenience: use sqrt() as a function to get the square root of
// anything that can be losslessly converted to f64, since we happen
// to always want our sqrts to be f64.
// RUST KVETCHES: (I) Why is this so convoluted?
// In particular, what would be so bad about allowing
// const fn sqrt<T: Into<f64>>(x: T) -> f64 { (x as f64).sqrt() }
// ???
// (II) Oh dear, sqrt is not computable in a const context, so we have to
// roll our own. I hope I get it right! I definitely don't know how to ensure
// that the final double is correctly rounded :-(

const SIXTH: f64 = 1./6.;
const FOURTH: f64 = 1./4.;
const fn invsqrt(xin: f64) -> f64 {
   if !xin.is_finite() { return f64::NAN; }
   let mut log4 = 0;
   let mut x = xin;
   while x < 1. { x *= 4.; log4 -= 1; }
   while x > 4. { x *= FOURTH; log4 += 1; }
   let mut next = 1.1 - SIXTH * x;
   let mut diff = 1.;
   while diff > 4. * f64::EPSILON { // termination condition??
       let last = next;
       next = last * (1.5 - 0.5 * x * last * last);
       diff = next - last;
       if diff < 0. { diff *= -1.; }
   }
   while log4 > 0 { next *= 0.5; log4 -= 1; }
   while log4 < 0 { next *= 2.; log4 += 1; }
   return next;
}

#[const_trait]
trait ConstSqrt {fn sqr(self) -> f64;}
impl const ConstSqrt for f64 {fn sqr(self) -> f64 {self * invsqrt(self)}}
impl const ConstSqrt for i32 {fn sqr(self) -> f64 {(self as f64).sqr()}}
const fn sqrt<T: const ConstSqrt>(x: T) -> f64 {x.sqr()}

// RUST KVETCHES: (I) It is annoying that we must redundantly specify
// the type of the well-typed RHS to assign it to a const.
// See https://github.com/rust-lang/rfcs/pull/3546
// Can we fix this in husht? Seems like we will need to be able to do full
// rust type inference in the transpiler; how will we accomplish that?
// (2) It is very annoying that there doesn't seem to be any way to specify
// that we want an expression like `5.0 / 2` to be evaluated by converting
// the 2 to a float, because of the "orphan rule". Can we fix this in husht?
// Again, it seems we would need full rust type inference.

// FIXME: replace with std::f64::consts::PHI when that gets stabilized
const PHI: f64 = (1. + sqrt(5)) / 2.;

const fn gray(level: f32) -> ElementColor { [level, level, level] }
const GRAY: ElementColor  = gray(0.75);
const RED: ElementColor   = [1.,   0.,   0.25];
const GREEN: ElementColor = [0.25, 1.,   0.];
const BLUE: ElementColor  = [0.,   0.25, 1.];

// --- loaders ---

/* DEBUG */
// each of these functions loads an example assembly for testing. once we've
// done more work on saving and loading assemblies, we should come back to this
// code to see if it can be simplified

fn load_general(assembly: &Assembly) {
    let _ = assembly.try_insert_element(
        Sphere::new(
            "gemini_a", "Castor", [1.00, 0.25, 0.00],
            engine::sphere(0.5, 0.5, 0.0, 1.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "gemini_b", "Pollux", BLUE,
            engine::sphere(-0.5, -0.5, 0.0, 1.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "ursa_major", "Ursa major", [0.25, 0.00, 1.00],
            engine::sphere(-0.5, 0.5, 0.0, 0.75),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "ursa_minor", "Ursa minor", GREEN,
            engine::sphere(0.5, -0.5, 0.0, 0.5),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "moon_deimos", "Deimos", [0.75, 0.75, 0.00],
            engine::sphere(0.0, 0.15, 1.0, 0.25),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "moon_phobos", "Phobos", [0.00, 0.75, 0.50],
            engine::sphere(0.0, -0.15, -1.0, 0.25),
        )
    );
}

fn load_low_curvature(assembly: &Assembly) {
    // create the spheres
    const A: f64 = sqrt(0.75);
    let _ = assembly.try_insert_element(
        Sphere::new(
            "central", "Central", GRAY,
            engine::sphere(0.0, 0.0, 0.0, 1.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "assemb_plane", "Assembly plane", GRAY,
            engine::sphere_with_offset(0.0, 0.0, 1.0, 0.0, 0.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "side1", "Side 1", RED,
            engine::sphere_with_offset(1.0, 0.0, 0.0, 1.0, 0.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "side2", "Side 2", GREEN,
            engine::sphere_with_offset(-0.5, A, 0.0, 1.0, 0.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "side3", "Side 3", BLUE,
            engine::sphere_with_offset(-0.5, -A, 0.0, 1.0, 0.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "corner1", "Corner 1", GRAY,
            engine::sphere(-4.0/3.0, 0.0, 0.0, 1.0/3.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "corner2", "Corner 2", GRAY,
            engine::sphere(2.0/3.0, -4.0/3.0 * A, 0.0, 1.0/3.0),
        )
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "corner3", "Corner 3", GRAY,
            engine::sphere(2.0/3.0, 4.0/3.0 * A, 0.0, 1.0/3.0),
        )
    );
    
    // impose the desired tangencies and make the sides planar
    let index_range = 1..=3;
    let [central, assemb_plane] = ["central", "assemb_plane"].map(
        |id| assembly.find_element(id)
    );
    let sides = index_range.clone().map(
        |k| assembly.find_element(&format!("side{k}"))
    );
    let corners = index_range.map(
        |k| assembly.find_element(&format!("corner{k}"))
    );
    for plane in [assemb_plane.clone()].into_iter().chain(sides.clone()) {
        // fix the curvature of each plane
        let curvature = plane.regulators().with_untracked(
            |regs| regs.first().unwrap().clone()
        );
        curvature.set_point().set(SpecifiedValue::try_from("0".to_string()).unwrap());
    }
    let all_perpendicular = [central.clone()].into_iter()
        .chain(sides.clone())
        .chain(corners.clone());
    for sphere in all_perpendicular {
        // make each side and packed sphere perpendicular to the assembly plane
        let right_angle = InversiveDistanceRegulator::new([sphere, assemb_plane.clone()]);
        right_angle.set_point.set(SpecifiedValue::try_from("0".to_string()).unwrap());
        assembly.insert_regulator(Rc::new(right_angle));
    }
    for sphere in sides.clone().chain(corners.clone()) {
        // make each side and corner sphere tangent to the central sphere
        let tangency = InversiveDistanceRegulator::new([sphere.clone(), central.clone()]);
        tangency.set_point.set(SpecifiedValue::try_from("-1".to_string()).unwrap());
        assembly.insert_regulator(Rc::new(tangency));
    }
    for (side_index, side) in sides.enumerate() {
        // make each side tangent to the two adjacent corner spheres
        for (corner_index, corner) in corners.clone().enumerate() {
            if side_index != corner_index {
                let tangency = InversiveDistanceRegulator::new([side.clone(), corner]);
                tangency.set_point.set(SpecifiedValue::try_from("-1".to_string()).unwrap());
                assembly.insert_regulator(Rc::new(tangency));
            }
        }
    }
}

fn load_pointed(assembly: &Assembly) {
    let _ = assembly.try_insert_element(
        Point::new(
            "point_front",
            "Front point",
            [0.75_f32, 0.75_f32, 0.75_f32],
            engine::point(0.0, 0.0, FRAC_1_SQRT_2),
        )
    );
    let _ = assembly.try_insert_element(
        Point::new(
            "point_back",
            "Back point",
            [0.75_f32, 0.75_f32, 0.75_f32],
            engine::point(0.0, 0.0, -FRAC_1_SQRT_2),
        )
    );
    for index_x in 0..=1 {
        for index_y in 0..=1 {
            let x = index_x as f64 - 0.5;
            let y = index_y as f64 - 0.5;
            
            let _ = assembly.try_insert_element(
                Sphere::new(
                    &format!("sphere{index_x}{index_y}"),
                    &format!("Sphere {index_x}{index_y}"),
                    [0.5*(1.0 + x) as f32, 0.5*(1.0 + y) as f32, 0.5*(1.0 - x*y) as f32],
                    engine::sphere(x, y, 0.0, 1.0),
                )
            );
            
            let _ = assembly.try_insert_element(
                Point::new(
                    &format!("point{index_x}{index_y}"),
                    &format!("Point {index_x}{index_y}"),
                    [0.5*(1.0 + x) as f32, 0.5*(1.0 + y) as f32, 0.5*(1.0 - x*y) as f32],
                    engine::point(x, y, 0.0),
                )
            );
        }
    }
}

// to finish describing the tridiminished icosahedron, set the inversive
// distance regulators as follows:
//   A-A   -0.25
//   A-B     "
//   B-C     "
//   C-C     "
//   A-C   -0.25 * φ^2 = -0.6545084971874737
fn load_tridiminished_icosahedron(assembly: &Assembly) {
    // create the vertices
    const COLOR_A: ElementColor = [1.00, 0.25, 0.25];
    const COLOR_B: ElementColor = [0.75, 0.75, 0.75];
    const COLOR_C: ElementColor = [0.25, 0.50, 1.00];
    let vertices = [
        Point::new("a1", "A₁", COLOR_A, point( 0.25,  0.75,  0.75)),
        Point::new("a2", "A₂", COLOR_A, point( 0.75,  0.25,  0.75)),
        Point::new("a3", "A₃", COLOR_A, point( 0.75,  0.75,  0.25)),
        Point::new("b1", "B₁", COLOR_B, point( 0.75, -0.25, -0.25)),
        Point::new("b2", "B₂", COLOR_B, point(-0.25,  0.75, -0.25)),
        Point::new("b3", "B₃", COLOR_B, point(-0.25, -0.25,  0.75)),
        Point::new("c1", "C₁", COLOR_C, point( 0.0,  -1.0,  -1.0)),
        Point::new("c2", "C₂", COLOR_C, point(-1.0,   0.0,  -1.0)),
        Point::new("c3", "C₃", COLOR_C, point(-1.0,  -1.0,   0.0)),
    ];
    for vertex in vertices {
        let _ = assembly.try_insert_element(vertex);
    }
    
    // create the faces
    const SQRT_1_6: f64 = invsqrt(6.);
    const SQRT_2_3: f64 = 2. * SQRT_1_6;
    let faces = [
        Sphere::new(
            "face1", "Face 1", GRAY,
            engine::sphere_with_offset(
                SQRT_2_3, -SQRT_1_6, -SQRT_1_6, -SQRT_1_6, 0.0),
        ),
        Sphere::new(
            "face2", "Face 2", GRAY,
            engine::sphere_with_offset(
                -SQRT_1_6, SQRT_2_3, -SQRT_1_6, -SQRT_1_6, 0.0),
        ),
        Sphere::new(
            "face3", "Face 3", GRAY,
            engine::sphere_with_offset(
                -SQRT_1_6, -SQRT_1_6, SQRT_2_3, -SQRT_1_6, 0.0),
        ),
    ];
    for face in faces {
        face.ghost().set(true);
        let _ = assembly.try_insert_element(face);
    }
    
    let index_range = 1..=3;
    for j in index_range.clone() {
        // make each face planar
        let face = assembly.elements_by_id.with_untracked(
            |elts_by_id| elts_by_id[&format!("face{j}")].clone()
        );
        let curvature_regulator = face.regulators().with_untracked(
            |regs| regs.first().unwrap().clone()
        );
        curvature_regulator.set_point().set(
            SpecifiedValue::try_from("0".to_string()).unwrap()
        );
        
        // put each A vertex on the face it belongs to
        let vertex_a = assembly.elements_by_id.with_untracked(
            |elts_by_id| elts_by_id[&format!("a{j}")].clone()
        );
        let incidence_a = InversiveDistanceRegulator::new([face.clone(), vertex_a.clone()]);
        incidence_a.set_point.set(SpecifiedValue::try_from("0".to_string()).unwrap());
        assembly.insert_regulator(Rc::new(incidence_a));
        
        // regulate the B-C vertex distances
        let vertices_bc = ["b", "c"].map(
            |series| assembly.elements_by_id.with_untracked(
                |elts_by_id| elts_by_id[&format!("{series}{j}")].clone()
            )
        );
        assembly.insert_regulator(
            Rc::new(InversiveDistanceRegulator::new(vertices_bc))
        );
        
        // get the pair of indices adjacent to `j`
        let adjacent_indices = [j % 3 + 1, (j + 1) % 3 + 1];
        
        for k in adjacent_indices.clone() {
            for series in ["b", "c"] {
                // put each B and C vertex on the faces it belongs to
                let vertex = assembly.elements_by_id.with_untracked(
                    |elts_by_id| elts_by_id[&format!("{series}{k}")].clone()
                );
                let incidence = InversiveDistanceRegulator::new([face.clone(), vertex.clone()]);
                incidence.set_point.set(SpecifiedValue::try_from("0".to_string()).unwrap());
                assembly.insert_regulator(Rc::new(incidence));
                
                // regulate the A-B and A-C vertex distances
                assembly.insert_regulator(
                    Rc::new(InversiveDistanceRegulator::new([vertex_a.clone(), vertex]))
                );
            }
        }
        
        // regulate the A-A and C-C vertex distances
        let adjacent_pairs = ["a", "c"].map(
            |series| adjacent_indices.map(
                |index| assembly.elements_by_id.with_untracked(
                    |elts_by_id| elts_by_id[&format!("{series}{index}")].clone()
                )
            )
        );
        for pair in adjacent_pairs {
            assembly.insert_regulator(
                Rc::new(InversiveDistanceRegulator::new(pair))
            );
        }
    }
}

// to finish describing the dodecahedral circle packing, set the inversive
// distance regulators to -1. some of the regulators have already been set
fn load_dodecahedral_packing(assembly: &Assembly) {
    // add the substrate
    let _ = assembly.try_insert_element(
        Sphere::new(
            "substrate", "Substrate", GRAY,
            engine::sphere(0.0, 0.0, 0.0, 1.0),
        )
    );
    let substrate = assembly.elements_by_id.with_untracked(
        |elts_by_id| elts_by_id["substrate"].clone()
    );
    
    // fix the substrate's curvature
    substrate.regulators().with_untracked(
        |regs| regs.first().unwrap().clone()
    ).set_point().set(
        SpecifiedValue::try_from("0.5".to_string()).unwrap()
    );
    
    // add the circles to be packed
    const COLOR_A: ElementColor = [1.00_f32, 0.25_f32, 0.00_f32];
    const COLOR_B: ElementColor = [1.00_f32, 0.00_f32, 0.25_f32];
    const COLOR_C: ElementColor = [0.25_f32, 0.00_f32, 1.00_f32];
    const PHI_INV: f64 = 1.0 / PHI;
    const COORD_SCALE: f64 = sqrt(PHI + 2.0);
    const_array!(FACE_SCALES: f64 = [PHI_INV, (13.0 / 12.0) / COORD_SCALE]);
    const_array!(FACE_RADII: f64 = [PHI_INV, 5.0 / 12.0]);
    let mut faces = Vec::<Rc<dyn Element>>::new();
    let subscripts = ["₀", "₁"];
    for j in 0..2 {
        for k in 0..2 {
            let small_coord = FACE_SCALES[k] * if j > 0 {1.} else {-1.};
            let big_coord = FACE_SCALES[k] * PHI * if k > 0 {1.} else {-1.};
            
            let id_num = format!("{j}{k}");
            let label_sub = format!("{}{}", subscripts[j], subscripts[k]);
            
            // add the A face
            let id_a = format!("a{id_num}");
            let _ = assembly.try_insert_element(
                Sphere::new(
                    &id_a,
                    &format!("A{label_sub}"),
                    COLOR_A,
                    engine::sphere(0.0, small_coord, big_coord, FACE_RADII[k]),
                )
            );
            faces.push(
                assembly.elements_by_id.with_untracked(
                    |elts_by_id| elts_by_id[&id_a].clone()
                )
            );
            
            // add the B face
            let id_b = format!("b{id_num}");
            let _ = assembly.try_insert_element(
                Sphere::new(
                    &id_b,
                    &format!("B{label_sub}"),
                    COLOR_B,
                    engine::sphere(small_coord, big_coord, 0.0, FACE_RADII[k]),
                )
            );
            faces.push(
                assembly.elements_by_id.with_untracked(
                    |elts_by_id| elts_by_id[&id_b].clone()
                )
            );
            
            // add the C face
            let id_c = format!("c{id_num}");
            let _ = assembly.try_insert_element(
                Sphere::new(
                    &id_c,
                    &format!("C{label_sub}"),
                    COLOR_C,
                    engine::sphere(big_coord, 0.0, small_coord, FACE_RADII[k]),
                )
            );
            faces.push(
                assembly.elements_by_id.with_untracked(
                    |elts_by_id| elts_by_id[&id_c].clone()
                )
            );
        }
    }
    
    // make each face sphere perpendicular to the substrate
    for face in faces {
        let right_angle = InversiveDistanceRegulator::new([face, substrate.clone()]);
        right_angle.set_point.set(SpecifiedValue::try_from("0".to_string()).unwrap());
        assembly.insert_regulator(Rc::new(right_angle));
    }
    
    // set up the tangencies that define the packing
    for [long_edge_plane, short_edge_plane] in [["a", "b"], ["b", "c"], ["c", "a"]] {
        for k in 0..2 {
            let long_edge_ids = [
                format!("{long_edge_plane}{k}0"),
                format!("{long_edge_plane}{k}1")
            ];
            let short_edge_ids = [
                format!("{short_edge_plane}0{k}"),
                format!("{short_edge_plane}1{k}")
            ];
            let [long_edge, short_edge] = [long_edge_ids, short_edge_ids].map(
                |edge_ids| edge_ids.map(
                    |id| assembly.elements_by_id.with_untracked(
                        |elts_by_id| elts_by_id[&id].clone()
                    )
                )
            );
            
            // set up the short-edge tangency
            let short_tangency = InversiveDistanceRegulator::new(short_edge.clone());
            if k == 0 {
                short_tangency.set_point.set(SpecifiedValue::try_from("-1".to_string()).unwrap());
            }
            assembly.insert_regulator(Rc::new(short_tangency));
            
            // set up the side tangencies
            for i in 0..2 {
                for j in 0..2 {
                    let side_tangency = InversiveDistanceRegulator::new(
                        [long_edge[i].clone(), short_edge[j].clone()]
                    );
                    if i == 0 && k == 0 {
                        side_tangency.set_point.set(SpecifiedValue::try_from("-1".to_string()).unwrap());
                    }
                    assembly.insert_regulator(Rc::new(side_tangency));
                }
            }
        }
    }
}

// the initial configuration of this test assembly deliberately violates the
// constraints, so loading the assembly will trigger a non-trivial realization
fn load_balanced(assembly: &Assembly) {
    // create the spheres
    const R_OUTER: f64 = 10.0;
    const R_INNER: f64 = 4.0;
    let spheres = [
        Sphere::new(
            "outer","Outer", GRAY, engine::sphere(0.0, 0.0, 0.0, R_OUTER)),
        Sphere::new("a", "A", RED,  engine::sphere(0.0, 4.0, 0.0, R_INNER)),
        Sphere::new("b", "B", BLUE, engine::sphere(0.0, -4.0, 0.0, R_INNER)),
    ];
    for sphere in spheres {
        let _ = assembly.try_insert_element(sphere);
    }
    
    // get references to the spheres
    let [outer, a, b] = ["outer", "a", "b"].map(
        |id| assembly.find_element(id)
    );
    
    // fix the diameters of the outer, sun, and moon spheres
    for (sphere, radius) in [
        (outer.clone(), R_OUTER),
        (a.clone(), R_INNER),
        (b.clone(), R_INNER),
    ] {
        let curvature_regulator = sphere.regulators().with_untracked(
            |regs| regs.first().unwrap().clone()
        );
        let curvature = 0.5 / radius;
        curvature_regulator.set_point().set(
            SpecifiedValue::try_from(curvature.to_string()).unwrap()
        );
    }
    
    // set the inversive distances between the spheres. as described above, the
    // initial configuration deliberately violates these constraints
    for inner in [a, b] {
        let tangency = InversiveDistanceRegulator::new([outer.clone(), inner]);
        tangency.set_point.set(SpecifiedValue::try_from("1".to_string()).unwrap());
        assembly.insert_regulator(Rc::new(tangency));
    }
}

// the initial configuration of this test assembly deliberately violates the
// constraints, so loading the assembly will trigger a non-trivial realization
fn load_off_center(assembly: &Assembly) {
    // create a point almost at the origin and a sphere centered on the origin
    let _ = assembly.try_insert_element(
        Point::new("point", "Point", GRAY, point(1e-9, 0.0, 0.0)),
    );
    let _ = assembly.try_insert_element(
        Sphere::new(
            "sphere", "Sphere", GRAY, engine::sphere(0.0, 0.0, 0.0, 1.0)),
    );

    
    // get references to the elements
    let point_and_sphere = ["point", "sphere"].map(
        |id| assembly.find_element(id)
    );
    
    // put the point on the sphere
    let incidence = InversiveDistanceRegulator::new(point_and_sphere);
    incidence.set_to(0.);
    assembly.insert_regulator(Rc::new(incidence));
}

// setting the inversive distances between the vertices to -2 gives a regular
// tetrahedron with side length 1, whose insphere and circumsphere have radii
// sqrt(1/6) and sqrt(3/2), respectively. to measure those radii, set an
// inversive distance of -1 between the insphere and each face, and then set an
// inversive distance of 0 between the circumsphere and each vertex
fn load_radius_ratio(assembly: &Assembly) {
    let index_range = 1..=4;
    
    // create the spheres
    let spheres = [
        Sphere::new(
            "sphere_faces", "Insphere", GRAY,
            engine::sphere(0.0, 0.0, 0.0, 0.5),
        ),
        Sphere::new(
            "sphere_vertices", "Circumsphere", GRAY,
            engine::sphere(0.0, 0.0, 0.0, 0.25),
        ),
    ];
    for sphere in spheres {
        let _ = assembly.try_insert_element(sphere);
    }
    
    // create the vertices
    let vertices = izip!(
        index_range.clone(),
        [
            [1.00_f32, 0.50_f32, 0.75_f32],
            [1.00_f32, 0.75_f32, 0.50_f32],
            [1.00_f32, 1.00_f32, 0.50_f32],
            [0.75_f32, 0.50_f32, 1.00_f32],
        ].into_iter(),
        [
            engine::point(-0.6, -0.8, -0.6),
            engine::point(-0.6, 0.8, 0.6),
            engine::point(0.6, -0.8, 0.6),
            engine::point(0.6, 0.8, -0.6),
        ].into_iter()
    ).map(
        |(k, color, representation)| {
            Point::new(
                &format!("v{k}"),
                &format!("Vertex {k}"),
                color,
                representation,
            )
        }
    );
    for vertex in vertices {
        let _ = assembly.try_insert_element(vertex);
    }
    
    // create the faces
    let base_dir = Vector3::new(1.0, 0.75, 1.0).normalize();
    let offset = base_dir.dot(&Vector3::new(-0.6, 0.8, 0.6));
    let faces = izip!(
        index_range.clone(),
        [
            [1.00_f32, 0.00_f32, 0.25_f32],
            [1.00_f32, 0.25_f32, 0.00_f32],
            [0.75_f32, 0.75_f32, 0.00_f32],
            [0.25_f32, 0.00_f32, 1.00_f32],
        ].into_iter(),
        [
            engine::sphere_with_offset(base_dir[0], base_dir[1], base_dir[2], offset, 0.0),
            engine::sphere_with_offset(base_dir[0], -base_dir[1], -base_dir[2], offset, 0.0),
            engine::sphere_with_offset(-base_dir[0], base_dir[1], -base_dir[2], offset, 0.0),
            engine::sphere_with_offset(-base_dir[0], -base_dir[1], base_dir[2], offset, 0.0),
        ].into_iter()
    ).map(
        |(k, color, representation)| {
            Sphere::new(
                &format!("f{k}"),
                &format!("Face {k}"),
                color,
                representation,
            )
        }
    );
    for face in faces {
        face.ghost().set(true);
        let _ = assembly.try_insert_element(face);
    }
    
    // impose the constraints
    for j in index_range.clone() {
        let [face_j, vertex_j] = [format!("f{j}"),format!("v{j}")]
            .map(|id| assembly.find_element(&id));

        
        // make the faces planar
        let curvature_regulator = face_j.regulators().with_untracked(
            |regs| regs.first().unwrap().clone()
        );
        curvature_regulator.set_to(0.);
        
        for k in index_range.clone().filter(|&index| index != j) {
            let vertex_k = assembly.find_element(&format!("v{k}"));
            
            // fix the distances between the vertices
            if j < k {
                let distance_regulator = InversiveDistanceRegulator::new(
                    [vertex_j.clone(), vertex_k.clone()]
                );
                assembly.insert_regulator(Rc::new(distance_regulator));
            }
            
            // put the vertices on the faces
            let incidence_regulator = InversiveDistanceRegulator::new([face_j.clone(), vertex_k.clone()]);
            incidence_regulator.set_to(0.);
            assembly.insert_regulator(Rc::new(incidence_regulator));
        }
    }
}

// to finish setting up the problem, fix the following curvatures:
//   sun      1
//   moon     5/3 = 1.666666666666666...
//   chain1   2
// a tiny `x` or `z` nudge of the outer sphere reliably prevents realization
// failures before they happen, or resolves them after they happen. the result
// depends sensitively on the translation direction, suggesting that realization
// is failing because the engine is having trouble breaking a symmetry
// /* TO DO */
// the engine's performance on this problem is scale-dependent! with the current
// initial conditions, realization fails for any order of imposing the remaining
// curvature constraints. scaling everything up by a factor of ten, as done in
// the original problem, makes realization succeed reliably. one potentially
// relevant difference is that a lot of the numbers in the current initial
// conditions are exactly representable as floats, unlike the analogous numbers
// in the scaled-up problem. the inexact representations might break the
// symmetry that's getting the engine stuck
fn load_irisawa_hexlet(assembly: &Assembly) {
    let index_range = 1..=6;
    let colors = [
        [1.00, 0.00, 0.25],
        [1.00, 0.25, 0.00],
        [0.75, 0.75, 0.00],
        [0.25, 1.00, 0.00],
        [0.00, 0.25, 1.00],
        [0.25, 0.00, 1.00],
    ].into_iter();
    
    // create the spheres
    let spheres = [
        Sphere::new(
            "outer", "Outer", gray(0.5),
            engine::sphere(0.0, 0.0, 0.0, 1.5),
        ),
        Sphere::new(
            "sun", "Sun", GRAY,
            engine::sphere(0.0, -0.75, 0.0, 0.75),
        ),
        Sphere::new(
            "moon", "Moon", gray(0.25),
            engine::sphere(0.0, 0.75, 0.0, 0.75),
        ),
    ].into_iter().chain(
        index_range.clone().zip(colors).map(
            |(k, color)| {
                let ang = (k as f64) * PI/3.0;
                Sphere::new(
                    &format!("chain{k}"),
                    &format!("Chain {k}"),
                    color,
                    engine::sphere(1.0 * ang.sin(), 0.0, 1.0 * ang.cos(), 0.5),
                )
            }
        )
    );
    for sphere in spheres {
        let _ = assembly.try_insert_element(sphere);
    }
    
    // put the outer sphere in ghost mode and fix its curvature
    let outer = assembly.find_element("outer");
    outer.ghost().set(true);
    let outer_curvature_regulator = outer.regulators().with_untracked(
        |regs| regs.first().unwrap().clone()
    );
    outer_curvature_regulator.set_point().set(
        SpecifiedValue::try_from((1.0 / 3.0).to_string()).unwrap()
    );
    
    // impose the desired tangencies
    let [sun, moon] = ["sun", "moon"].map(|id| assembly.find_element(id));
    let chain = index_range.map(
        |k| assembly.find_element(&format!("chain{k}"))
    );
    for (chain_sphere, chain_sphere_next) in chain.clone().zip(chain.cycle().skip(1)) {
        for (other_sphere, inversive_distance) in [
            (outer.clone(), "1"),
            (sun.clone(), "-1"),
            (moon.clone(), "-1"),
            (chain_sphere_next.clone(), "-1"),
        ] {
            let tangency = InversiveDistanceRegulator::new([chain_sphere.clone(), other_sphere]);
            tangency.set_point.set(SpecifiedValue::try_from(inversive_distance.to_string()).unwrap());
            assembly.insert_regulator(Rc::new(tangency));
        }
    }
    
    let outer_sun_tangency = InversiveDistanceRegulator::new([outer.clone(), sun]);
    outer_sun_tangency.set_point.set(SpecifiedValue::try_from("1".to_string()).unwrap());
    assembly.insert_regulator(Rc::new(outer_sun_tangency));
    
    let outer_moon_tangency = InversiveDistanceRegulator::new([outer.clone(), moon]);
    outer_moon_tangency.set_point.set(SpecifiedValue::try_from("1".to_string()).unwrap());
    assembly.insert_regulator(Rc::new(outer_moon_tangency));
}

const HPHI:  f64 = PHI / 2.;          // "half phi"
const RTHPHI: f64 = sqrt(HPHI);       // "root half phi"
const RTPHIPH: f64 = sqrt(PHI + 0.5); // "root phi plus (half)"
const P: bool = true; // Pinned
const F: bool = false; // Free

// Initial data for the vertices commmon to 554aug2 and 554domed.
// Used the Vectornaut near_miss branch final positions for 554aug2,
// to the 3 decimal places currently shown.
const_array!(ACRON554_COMMON: (&str, [f64; 3], bool, usize, &str) = [
    // id,       coordinates,  Pin/Free, level, earlier neighbor IDs.
    ("A_NE", [ 0.5,    0.5,   0.],      P, 0, ""),
    ("A_NW", [-0.5,    0.5,   0.],      P, 0, ""),
    ("A_SE", [ 0.5,   -0.5,   0.],      P, 0, ""),
    ("A_SW", [-0.5,   -0.5,   0.],      P, 0, ""),
    ("Z_E",  [ 0.229, -0.002, 0.821],   F, 1, "A_NE,A_SE"),
    ("Z_S",  [ 0.002, -0.229, 0.821],   F, 1, "A_SE,A_SW"),
    ("B_NE", [ HPHI,   HPHI,  RTHPHI],  P, 2, "Z_E"),
    ("B_NW", [-HPHI,   HPHI,  RTHPHI],  P, 2, ""),
    ("B_SW", [-HPHI,  -HPHI,  RTHPHI],  P, 2, "Z_S"),
    ("B_SE", [ 0.812, -0.812, 0.89],    F, 2, "Z_E,Z_S"),
    ("Y_NE", [ 0.11,   0.103, 1.019],   F, 3, "B_NE"),
    ("Y_NW", [-0.103,  0.103, 1.02],    F, 3, "B_NW"),
    ("Y_SE", [ 0.11,  -0.11,  1.017],   F, 3, "B_SE"),
    ("Y_SW", [-0.103, -0.11,  1.019],   F, 3, "B_SW"),
    ("C_N",  [ 0.,     1.,    RTPHIPH], P, 4, "Y_NE,Y_NW"),
    ("C_W",  [-1.,     0.,    RTPHIPH], P, 4, "Y_NW,Y_SW"),
    ("C_E",  [ 1.006, -0.006, 1.45],    F, 4, "Y_NE,Y_SE"),
    ("C_S",  [ 0.006, -1.006, 1.45],    F, 4, "Y_SE,Y_SW"),
    ("D_NE", [ 0.2,    0.181, 2.011],   F, 5, "Y_NE,C_N,C_E"),
    ("D_NW", [-0.181,  0.181, 2.014],   F, 5, "Y_NW,C_N,C_W"),
    ("D_SE", [ 0.2,   -0.2,   2.009],   F, 5, "Y_SE,C_E,C_S"),
    ("D_SW", [-0.181, -0.2,   2.011],   F, 5, "Y_SW,C_W,C_S"),
    ("E_N",  [ 0.012,  1.055, 2.46],    F, 6, "C_N,D_NE,D_NW"),
    ("E_W",  [-1.055, -0.012, 2.46],    F, 6, "C_W,D_NW,D_SW"),
    ("E_E",  [ 1.079, -0.012, 2.447],   F, 6, "C_E,D_NE,D_SE"),
    ("E_S",  [ 0.012, -1.079, 2.447],   F, 6, "C_S,D_SE,D_SW"),
    ("F_NE", [ 0.296,  0.265, 3.003],   F, 7, "D_NE,E_N,E_E"),
    ("F_NW", [-0.265,  0.265, 3.007],   F, 7, "D_NW,E_N,E_W"),
    ("F_SE", [ 0.296, -0.296, 3.0],     F, 7, "D_SE,E_E,E_S"),
    ("F_SW", [-0.265, -0.296, 3.003],   F, 7, "D_SW,E_W,E_S"),
    // The following must be in order around the octagon (in some orientation)
    ("G_1",  [ 0.517,  1.19,  3.312],   F, 8, "E_N,F_NE"),
    ("G_2",  [ 1.224,  0.483, 3.304],   F, 8, "E_E,F_NE"),
    ("G_4",  [ 1.224, -0.517, 3.298],   F, 8, "E_E,F_SE"),
    ("G_5",  [ 0.517, -1.224, 3.298],   F, 8, "E_S,F_SE"),
    ("G_7",  [-0.483, -1.224, 3.304],   F, 8, "E_S,F_SW"),
    ("G_8",  [-1.19,  -0.517, 3.312],   F, 8, "E_W,F_SW"),
    ("G_10", [-1.19,   0.483, 3.318],   F, 8, "E_W,F_NW"),
    ("G_11", [-0.483,  1.19,  3.318],   F, 8, "E_N,F_NW"),
]);

const_array!(LEVEL_COLORS: ElementColor = [
    [0.75, 0.,   0.75],
    [1.,   0.4,  0.6],
    [1.,   0.,   0.25],
    [1.,   0.75, 0.25],
    [0.75, 0.5,  0.],
    [0.9,  0.9,  0.],
    [0.25, 0.75, 0.],
    [0.,   0.5,  0.75],
    [0.25, 0.,   1.],
]);

fn load_554aug2(assembly: &Assembly) {
    // first a plane for the octagon
    let oct_id = "f_g";
    let engsph = engine::sphere_with_offset(
        0., 0., 1., ACRON554_COMMON[37].1[2], 0.);
    let octaface = Sphere::new(oct_id, "Octagon", [0.7, 0.7, 0.7], engsph);
    octaface.ghost().set(true);
    assembly.try_insert_element(octaface);
    let face_rc = assembly.find_element(oct_id);
    let face_curvature = face_rc.regulators().with_untracked(
        |regs| regs.first().unwrap().clone()
    );
    face_curvature.set_to(0.);
    // Octagon vertices and side/diagonal lengths
    let mut oct_verts = Vec::<Rc<dyn Element>>::new();
    const OCT_LONG: usize = 4;
    const OCT_N_DIAG: usize = 5;
    const OCT_N: usize = 8;
    const OCT_DIST: [f64; OCT_N_DIAG] = [0., // dummy at start
        -0.5,
        -0.5*(2. + SQRT_2),
        -0.5*(3. + 2.*SQRT_2),
        -0.5*(4. + 2.*SQRT_2)
    ];
    // Now process the acron data
    for (id, v, pinned, l, _neighbors) in ACRON554_COMMON {
        let pt = Point::new(id, id, LEVEL_COLORS[l], point(v[0], v[1], v[2]));
        assembly.try_insert_element(pt);
        if pinned { // regulate each coordinate to its given value
            let mut freeze = Vec::<Rc<dyn Regulator>>::new();
            // QUESTION: Would there be a way to insert an Rc<Element> into
            // an assembly to avoid the need to re-lookup pt in the assembly
            // after just inserting it?
            let pt_rc = assembly.elements_by_id.with_untracked(
                |elts| elts[id].clone()
            );
            // filter the three coordinate regulators into freeze
            pt_rc.regulators().with_untracked( |regs| {
                for reg in regs {
                    if let Some(_pcr) = reg
                      .as_any().downcast_ref::<PointCoordinateRegulator>() {
                        freeze.push(reg.clone())
                    }
                }
            });
            // now set them to their originally specified values.
            let mut coord: usize = 0;
            for reg in freeze {
                reg.set_to(v[coord]);
                coord += 1;
            }
        }
        // If part of the octagon, make incident to the plane:
        if l == 8 {
            let pt_rc = assembly.find_element(id);
            let oct_index = oct_verts.len();
            oct_verts.push(pt_rc.clone());
            let incidence = InversiveDistanceRegulator::new(
                [face_rc.clone(), pt_rc.clone()]);
            incidence.set_to(0.0);
            assembly.insert_regulator(Rc::new(incidence));
            // And regulate the length to the other vertices of the octagon
            for offset in 1..OCT_N_DIAG {
                if offset <= oct_index {
                    let dist = InversiveDistanceRegulator::new(
                        [oct_verts[oct_index - offset].clone(), pt_rc.clone()]);
                    dist.set_to(OCT_DIST[offset]);
                    assembly.insert_regulator(Rc::new(dist));
                }
                if offset < OCT_LONG &&  oct_index + offset >= OCT_N {
                    let forward = oct_index + offset - OCT_N;
                    let dist = InversiveDistanceRegulator::new(
                        [oct_verts[forward].clone(), pt_rc.clone()]);
                    dist.set_to(OCT_DIST[offset]);
                    assembly.insert_regulator(Rc::new(dist));
                }
            }
        }
    }
}

// --- chooser ---

/* DEBUG */
#[component]
pub fn TestAssemblyChooser() -> View {
    // create an effect that loads the selected test assembly
    let assembly_name = create_signal("general".to_string());
    create_effect(move || {
        // get name of chosen assembly
        let name = assembly_name.get_clone();
        console::log_1(
            &JsValue::from(format!("Showing assembly \"{}\"", name.clone()))
        );
        
        batch(|| {
            let state = use_context::<AppState>();
            let assembly = &state.assembly;
            
            // clear state
            assembly.regulators.update(|regs| regs.clear());
            assembly.elements.update(|elts| elts.clear());
            assembly.elements_by_id.update(|elts_by_id| elts_by_id.clear());
            assembly.descent_history.set(DescentHistory::new());
            state.selection.update(|sel| sel.clear());
            
            // load assembly
            match name.as_str() {
                "general" => load_general(assembly),
                "low-curvature" => load_low_curvature(assembly),
                "pointed" => load_pointed(assembly),
                "tridiminished-icosahedron" => load_tridiminished_icosahedron(assembly),
                "dodecahedral-packing" => load_dodecahedral_packing(assembly),
                "balanced" => load_balanced(assembly),
                "off-center" => load_off_center(assembly),
                "radius-ratio" => load_radius_ratio(assembly),
                "irisawa-hexlet" => load_irisawa_hexlet(assembly),
                "aug554" => load_554aug2(assembly),
                _ => (),
            };
        });
    });

    // FIXME: Non-DRY -- should not need to reiterate thie list of assembly
    //        labels
    // build the chooser
    view! {
        select(bind:value = assembly_name) {
            option(value = "general") { "General" }
            option(value = "low-curvature") { "Low-curvature" }
            option(value = "pointed") { "Pointed" }
            option(value = "tridiminished-icosahedron") { "Tridiminished icosahedron" }
            option(value = "dodecahedral-packing") { "Dodecahedral packing" }
            option(value = "balanced") { "Balanced" }
            option(value = "off-center") { "Off-center" }
            option(value = "radius-ratio") { "Radius ratio" }
            option(value = "irisawa-hexlet") { "Irisawa hexlet" }
            option(value = "aug554") { "McNeill acron 554" }
            option(value = "empty") { "Empty" }
        }
    }
}