// Online example: https://turtletoy.net/turtle/f4cfd82958

// You can find the Turtle API reference here: https://turtletoy.net/syntax
// Global code will be evaluated once.

// Total steps for simulation
const totalSimulationSteps = 2000;          // min=0 max=4000 step = 10
// Total amount of lines to draw
const lineAmount = 6000;                    // min=1 max=15000 step = 10
// Number of lines drawn per batch
const batchEachWalk = 20;                   // min=1 max=105 step = 5
// Opacity of the drawing
const drawingOpacity = -0.2;                // min=-1.0 max=1.0 step = 0.05
// Radius for circle calculations
const circleRadius = 72;                    // min=1 max=105 step = 1
// Flag to decide if background is drawn
const bDrawBackground = 0;                  // min=0 max=1 step = 1

Canvas.setpenopacity(drawingOpacity); // Set the opacity for drawing

const turtle = new Turtle(); // Initialize the Turtle object

// Utility function to draw a line
function line(x1, y1, x2, y2) {
    turtle.penup();
    turtle.goto(x1, y1);
    turtle.pendown();
    turtle.goto(x2, y2);
}

// Utility function to draw a square
function square(x, y, size) {
    let sz = size * 0.5;
    line(x - sz, y - sz, x + sz, y - sz);
    line(x + sz, y - sz, x + sz, y + sz);
    line(x + sz, y + sz, x - sz, y + sz);
    line(x - sz, y + sz, x - sz, y - sz);
}

// Function to create a random point outside a circle
function randomPointOutsideCircle(canvasSize, r) {
    const halfCanvasSize = canvasSize * 0.5;
    while (true) {
        const x = randomInRange(-halfCanvasSize, halfCanvasSize);
        const y = randomInRange(-halfCanvasSize, halfCanvasSize);
        if (Math.sqrt(x * x + y * y) >= r) {
            return { x, y };
        }
    }
}

const canvasSize = 256; // Size of the canvas
const squareSize = 20;  // Size of the square

// Function to draw a random rectangle
function drawRandomRect() {
    const coord = randomPointOutsideCircle(canvasSize, circleRadius * 1.2);
    square(coord.x, coord.y, squareSize);
}

const forceScale = 0.5; // Scale of the force applied

// Calculate the number of walks
const numWalks = lineAmount / batchEachWalk;

// Define rotation centers
const rotationCenters = [{ x: 0, y: 0 }];

// Particle class definition
class Particle {
    constructor(x, y) {
        this.position = { x: x, y: y };
        this.oldPosition = { x: x, y: y };
        this.bFree = true; // Flag to determine if the particle is free
    }
    
    // Method to get the velocity of a particle
    getVelocity() {
        return {
            x: this.position.x - this.oldPosition.x,
            y: this.position.y - this.oldPosition.y
        };
    }
}

// Ribbon class definition
class Ribbon {
    constructor(startX, startY, numSegments, segmentLength, simulationSteps, constraintIterations) {
        this.particles = []; // Array to hold particles
        this.numSegments = numSegments;
        this.segmentLength = segmentLength;
        this.simulationSteps = simulationSteps;
        this.constraintIterations = constraintIterations;
        
        // Initialize particle positions
        let l = Math.sqrt(startX * startX + startY * startY);
        let dx = startX / l;
        let dy = startY / l;
        for (let i = 0; i <= numSegments; i++) {
            this.particles.push(new Particle(startX + i * dx * segmentLength, startY + i * dy * segmentLength));
        }
        this.particles[0].bFree = false; // First particle is fixed
    }
    
    // Method to calculate external force on a particle
    calculateExternalForce(particle) {
        let force = { x: 0, y: 0 };
        let closestCenter = null;
        let closestDistance = Infinity;

        // Find the closest rotation center
        for (let center of rotationCenters) {
            let dx = particle.position.x - center.x;
            let dy = particle.position.y - center.y;
            let distance = Math.sqrt(dx * dx + dy * dy);
            if (distance < closestDistance) {
                closestDistance = distance;
                closestCenter = center;
            }
        }

        // Calculate force based on the closest center
        if (closestCenter) {
            let dx = particle.position.x - closestCenter.x;
            let dy = particle.position.y - closestCenter.y;
            force.x = -forceScale * dy;
            force.y = forceScale * dx;
        }

        return force;
    }

    // Verlet integration for particle movement
    verletIntegrate(dt) {
        const substepTime = 0.01;
        const substepTimeSqr = dt * dt;
        for (let particle of this.particles) {
            if (particle.bFree) {
                let tempPos = { ...particle.position };
                let velocity = particle.getVelocity();
                let externalForce = this.calculateExternalForce(particle);
                particle.position.x += velocity.x + externalForce.x * substepTimeSqr;
                particle.position.y += velocity.y + externalForce.y * substepTimeSqr;
                particle.oldPosition = tempPos;
            }
        }
    }

    // Solve distance constraints between particles
    solveDistanceConstraint(p1, p2, desiredDistance) {
        let dx = p2.position.x - p1.position.x;
        let dy = p2.position.y - p1.position.y;
        let currentDistance = Math.sqrt(dx * dx + dy * dy);
        let difference = desiredDistance - currentDistance;
        
        let normalizedDX = dx / currentDistance;
        let normalizedDY = dy / currentDistance;

        let offsetX = normalizedDX * difference;
        let offsetY = normalizedDY * difference;

        if (p1.bFree && p2.bFree) {
            p1.position.x -= offsetX * 0.5;
            p1.position.y -= offsetY * 0.5;
            p2.position.x += offsetX * 0.5;
            p2.position.y += offsetY * 0.5;
        } else if (p1.bFree) {
            p1.position.x -= offsetX;
            p1.position.y -= offsetY;
        } else if (p2.bFree) {
            p2.position.x += offsetX;
            p2.position.y += offsetY;
        }
    }

    // Solve all constraints for the ribbon
    solveConstraints() {
        for (let iterationIdx = 0; iterationIdx < this.constraintIterations; iterationIdx++) {
            for (let i = 0; i < this.numSegments; i++) {
                this.solveDistanceConstraint(this.particles[i], this.particles[i + 1], this.segmentLength);
            }
        }
    }

    // Simulate the movement of the ribbon
    simulate() {
        for (let step = 0; step < this.simulationSteps; step++) {
            this.verletIntegrate(0.001);
            this.solveConstraints();
        }
    }
}

// Function to get a random point within a circle
function randomPointInCircle(R) {
    let r = Math.sqrt(Math.random()) * R; // Uniform distribution
    let theta = Math.random() * 2 * Math.PI;
    let x = r * Math.cos(theta);
    let y = r * Math.sin(theta);
    return { x, y };
}

// Create a random ribbon
function randomRibbon() {
    let point = randomPointInCircle(circleRadius);
    let startX = point.x;
    let startY = point.y;
    let numSegments = Math.floor(20 * Math.random()) + 20;
    let segmentLength = 0.1 * Math.random() + 0.5;
    let simulationSteps = totalSimulationSteps;
    let constraintIterations = 5;

    return new Ribbon(startX, startY, numSegments, segmentLength, simulationSteps, constraintIterations);
}

// Simulate and draw each ribbon
function walk(i) {
    for (let k = 0; k < batchEachWalk; k++) {
        let ribbon = randomRibbon();
        ribbon.simulate();
        for (let i = 0; i <= ribbon.numSegments; i++) {
            if (i < ribbon.numSegments) {
                turtle.penup();
                turtle.goto(ribbon.particles[i].position.x, ribbon.particles[i].position.y);
                turtle.pendown();
                turtle.goto(ribbon.particles[i + 1].position.x, ribbon.particles[i + 1].position.y);
            }
        }
        if (bDrawBackground) {
            drawRandomRect();
        }
    }

    return i < numWalks;
}