let numPoints = 150; // min=20, max=300, step=5, Total number of points in the spiral
let a = 0; // min=0, max=50, step=0.1, Starting radius
let b = 0.28; // min=0, max=3, step=0.001, Controls the tightness of the spiral
let s = 1.88; // min=0, max=3, step=0.001, Controls the spacing of the spiral

// You can find the Turtle API reference here: https://turtletoy.net/syntax
Canvas.setpenopacity(0.12);

// Global code will be evaluated once.
const turtle = new Turtle();

function drawRandomCubicHermiteSpline(pStart, pEnd, numPoints, aScale) {
    // Generates a set of random control points between pStart and pEnd
    function generateRandomControlPoints(pStart, pEnd, numPoints) {
        let points = [pStart];
        let dx = pEnd.x - pStart.x;
        let dy = pEnd.y - pStart.y;
        let dTotal = Math.sqrt(dx * dx + dy * dy);
        let normalDirection = { x: -dy / dTotal, y: dx / dTotal };

        for (let i = 1; i < numPoints - 1; i++) {
            let t = i / (numPoints - 1);
            let p = { x: pStart.x + dx * t, y: pStart.y + dy * t };
            let f = Math.random() * 2 - 1;
            let offsetMagnitude = Math.sin(t * Math.PI * f) * (Math.random() * dTotal * aScale);
            p.x += offsetMagnitude * normalDirection.x;
            p.y += offsetMagnitude * normalDirection.y;
            points.push(p);
        }

        points.push(pEnd);
        return points;
    }

    // Calculates tangent using two points.
    function calculateTangent(p0, p1) {
        return { x: p1.x - p0.x, y: p1.y - p0.y };
    }

    // Calculates tangents for each control point
    function calculateTangents(points) {
        let tangents = [];
        for (let i = 0; i < points.length; i++) {
            if (i == 0) {
                tangents.push(calculateTangent(points[i], points[i + 1]));
            } else if (i == points.length - 1) {
                tangents.push(calculateTangent(points[i - 1], points[i]));
            } else {
                let tangent = calculateTangent(points[i - 1], points[i + 1]);
                tangents.push({ x: tangent.x / 2, y: tangent.y / 2 });
            }
        }
        return tangents;
    }

    // Computes a point on the Cubic Hermite spline
    function hermiteInterpolate(p0, p1, t0, t1, t) {
        let h00 = (2 * t ** 3) - (3 * t ** 2) + 1;
        let h10 = (t ** 3) - (2 * t ** 2) + t;
        let h01 = (-2 * t ** 3) + (3 * t ** 2);
        let h11 = (t ** 3) - (t ** 2);
        return {
            x: h00 * p0.x + h10 * t0.x + h01 * p1.x + h11 * t1.x,
            y: h00 * p0.y + h10 * t0.y + h01 * p1.y + h11 * t1.y
        };
    }

    // Generate control points
    let controlPoints = generateRandomControlPoints(pStart, pEnd, numPoints);

    // Calculate tangents for control points
    let tangents = calculateTangents(controlPoints);

    // Draw the spline by interpolating between each pair of points
    for (let i = 0; i < controlPoints.length - 1; i++) {
        let p0 = controlPoints[i];
        let p1 = controlPoints[i + 1];
        let t0 = tangents[i];
        let t1 = tangents[i + 1];

        turtle.penup();
        turtle.goto(p0.x, p0.y);
        turtle.pendown();

        for (let t = 0; t <= 1; t += 0.1) { // Smaller step for a smoother curve
            let point = hermiteInterpolate(p0, p1, t0, t1, t);
            turtle.goto(point.x, point.y);
        }
        turtle.penup();
    }
}

// generate a spiral path
function generateSpiralPoints(numPoints, a, b, s = 0.1, yOffset = 0) {
    let points = [];
    for (let i = 0; i < numPoints; i++) {
        // Angle increases linearly with each point
        let theta = i * s; // Adjust the s multiplier to change spacing between points

        // Radius increases with theta to create the spiral
        let r = a + b * theta; // 'a' is the starting radius, 'b' controls how tightly the spiral winds

        // Convert polar coordinates (r, theta) to Cartesian coordinates (x, y)
        let x = r * Math.cos(theta);
        let y = r * Math.sin(theta) + yOffset;

        points.push({ x, y });
    }
    return points;
}


let spiralPoints = generateSpiralPoints(numPoints, a, b, s, -12);

// draw the figure below
for (let j = 0; j < 16; j++) {
    for (let i = 0; i < j * 2 + 1; i++) {
        let x = -90 + j * 12;
        drawRandomCubicHermiteSpline({ x: x, y: 75 }, { x: x, y: 95 }, j * 2.5, 0.2);
    }
}

// The walk function will be called until it returns false.
function walk(i) {

    if (i < spiralPoints.length - 1) {
        // Use the current and next point in the spiral as start and end points for the spline
        let pStart = spiralPoints[i];
        let pEnd = spiralPoints[i + 1];
        let nCurves = i * 0.4;
        // Call the function to draw the spline segment between these points
        for (let k = 0; k < nCurves; k++) {
            drawRandomCubicHermiteSpline(pStart, pEnd, i * 0.05, 0.1 * i / spiralPoints.length);
        }

        return true; // Continue walking
    }
    return false; // Stop walking once we've processed all points
}