/* V13 Symmetry Module - Advanced Symmetry Patterns */
import { state } from './state.js';
import { drawStarPath } from './shapes.js';
import { renderRecursiveFractal } from './fractals.js';

/**
 * Draw Mandala pattern - Radial + reflective symmetry
 */
export function drawMandala(ctx, w, h, rOuter, rInner, dynamicFill) {
    const cx = w / 2;
    const cy = h / 2;
    const layers = 3; // Number of concentric layers

    ctx.save();
    ctx.translate(cx, cy);

    for (let layer = 0; layer < layers; layer++) {
        const layerRadius = rOuter * (1 - layer * 0.3);
        const layerInner = rInner * (1 - layer * 0.3);
        const segments = 8 + layer * 4; // More segments in outer layers

        for (let i = 0; i < segments; i++) {
            ctx.save();
            ctx.rotate((Math.PI * 2 * i) / segments);

            // Draw star at this position
            ctx.beginPath();
            drawStarPath(ctx, state.spikes, layerRadius / 2, layerInner / 2, state.curve, state.twist);
            ctx.fill();
            if (state.lineWidth > 0) ctx.stroke();

            ctx.restore();
        }
    }

    ctx.restore();
}

/**
 * Draw Spiral pattern - Fibonacci/golden spiral
 */
export function drawSpiral(ctx, w, h, rOuter, rInner, dynamicFill) {
    const cx = w / 2;
    const cy = h / 2;
    const spiralTurns = 3;
    const starsPerTurn = 12;
    const totalStars = spiralTurns * starsPerTurn;

    ctx.save();
    ctx.translate(cx, cy);

    for (let i = 0; i < totalStars; i++) {
        const progress = i / totalStars;
        const angle = progress * spiralTurns * Math.PI * 2;
        const radius = progress * Math.max(w, h) / 2;

        const x = Math.cos(angle) * radius;
        const y = Math.sin(angle) * radius;

        const scale = 1 - progress * 0.7; // Stars get smaller

        ctx.save();
        ctx.translate(x, y);
        ctx.rotate(angle);
        ctx.scale(scale, scale);

        ctx.beginPath();
        drawStarPath(ctx, state.spikes, rOuter / 3, rInner / 3, state.curve, state.twist);
        ctx.fill();
        if (state.lineWidth > 0) ctx.stroke();

        ctx.restore();
    }

    ctx.restore();
}

/**
 * Draw Tessellation - Repeating geometric tiles
 */
export function drawTessellation(ctx, w, h, rOuter, rInner, dynamicFill) {
    const tileSize = rOuter * 2;
    const cols = Math.ceil(w / tileSize) + 1;
    const rows = Math.ceil(h / tileSize) + 1;

    for (let row = 0; row < rows; row++) {
        for (let col = 0; col < cols; col++) {
            const x = col * tileSize - tileSize / 2;
            const y = row * tileSize - tileSize / 2;

            // Offset every other row for hexagonal pattern
            const offsetX = (row % 2) * (tileSize / 2);

            ctx.save();
            ctx.translate(x + offsetX, y);
            ctx.rotate(state.rotation);

            ctx.beginPath();
            drawStarPath(ctx, state.spikes, rOuter / 2, rInner / 2, state.curve, state.twist);
            ctx.fill();
            if (state.lineWidth > 0) ctx.stroke();

            ctx.restore();
        }
    }
}

/**
 * Draw Mirror pattern - Bilateral symmetry
 */
export function drawMirror(ctx, w, h, rOuter, rInner, dynamicFill) {
    const cx = w / 2;
    const cy = h / 2;

    // Draw original
    ctx.save();
    ctx.translate(cx - rOuter, cy);
    ctx.rotate(state.rotation);

    ctx.beginPath();
    drawStarPath(ctx, state.spikes, rOuter, rInner, state.curve, state.twist);
    ctx.fill();
    if (state.lineWidth > 0) ctx.stroke();
    ctx.restore();

    // Draw mirrored
    ctx.save();
    ctx.translate(cx + rOuter, cy);
    ctx.scale(-1, 1); // Flip horizontally
    ctx.rotate(state.rotation);

    ctx.beginPath();
    drawStarPath(ctx, state.spikes, rOuter, rInner, state.curve, state.twist);
    ctx.fill();
    if (state.lineWidth > 0) ctx.stroke();
    ctx.restore();
}