/* V12 Physics Module */
import { state } from './state.js';

// Gravity state (persistent)
let velocityX = 0;
let velocityY = 0;
let offsetX = 0;
let offsetY = 0;

/**
 * Apply gravity pull toward mouse position
 * Returns offset to apply to star position
 */
export function applyGravity(canvasWidth, canvasHeight) {
    if (!state.gravityEnabled) {
        // Reset when disabled
        velocityX *= 0.95;
        velocityY *= 0.95;
        offsetX *= 0.95;
        offsetY *= 0.95;
        return { x: offsetX, y: offsetY };
    }

    // Target position (mouse or center)
    const targetX = state.mouseX || 0;
    const targetY = state.mouseY || 0;

    // Calculate attraction force
    const dx = targetX - offsetX;
    const dy = targetY - offsetY;
    const distance = Math.sqrt(dx * dx + dy * dy);

    if (distance > 5) {
        const force = 0.02; // Gravity strength
        const ax = (dx / distance) * force;
        const ay = (dy / distance) * force;

        velocityX += ax;
        velocityY += ay;
    }

    // Apply friction
    velocityX *= 0.98;
    velocityY *= 0.98;

    // Update position
    offsetX += velocityX;
    offsetY += velocityY;

    return { x: offsetX, y: offsetY };
}

/**
 * Calculate orbital position around center
 */
export function calculateOrbit(time, radius = 100) {
    if (!state.orbitEnabled) return { x: 0, y: 0 };

    const speed = 0.001; // Orbit speed
    const angle = time * speed;

    return {
        x: Math.cos(angle) * radius,
        y: Math.sin(angle) * radius
    };
}

/**
 * Reset physics state
 */
export function resetPhysics() {
    velocityX = 0;
    velocityY = 0;
    offsetX = 0;
    offsetY = 0;
}

/* V15 3D Engine Module - Pseudo-3D Rendering */
import { state } from './state.js';

/**
 * 3D Point class
 */
class Point3D {
    constructor(x, y, z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

/**
 * Project 3D point to 2D screen coordinates
 */
export function project3D(point, fov = 500, distance = 1000) {
    const scale = fov / (fov + point.z + distance);
    return {
        x: point.x * scale,
        y: point.y * scale,
        scale: scale
    };
}

/**
 * Rotate point around X axis
 */
function rotateX(point, angle) {
    const rad = angle * Math.PI / 180;
    const cos = Math.cos(rad);
    const sin = Math.sin(rad);

    return new Point3D(
        point.x,
        point.y * cos - point.z * sin,
        point.y * sin + point.z * cos
    );
}

/**
 * Rotate point around Y axis
 */
function rotateY(point, angle) {
    const rad = angle * Math.PI / 180;
    const cos = Math.cos(rad);
    const sin = Math.sin(rad);

    return new Point3D(
        point.x * cos + point.z * sin,
        point.y,
        -point.x * sin + point.z * cos
    );
}

/**
 * Rotate point around Z axis
 */
function rotateZ(point, angle) {
    const rad = angle * Math.PI / 180;
    const cos = Math.cos(rad);
    const sin = Math.sin(rad);

    return new Point3D(
        point.x * cos - point.y * sin,
        point.x * sin + point.y * cos,
        point.z
    );
}

/**
 * Apply all 3D rotations
 */
export function rotate3D(point, angleX, angleY, angleZ) {
    let p = point;
    if (angleX !== 0) p = rotateX(p, angleX);
    if (angleY !== 0) p = rotateY(p, angleY);
    if (angleZ !== 0) p = rotateZ(p, angleZ);
    return p;
}

/**
 * Generate 3D star points
 */
export function generate3DStarPoints(spikes, outerRadius, innerRadius) {
    const points = [];
    const step = Math.PI / spikes;

    for (let i = 0; i < spikes * 2; i++) {
        const angle = i * step - Math.PI / 2;
        const radius = i % 2 === 0 ? outerRadius : innerRadius;

        points.push(new Point3D(
            Math.cos(angle) * radius,
            Math.sin(angle) * radius,
            0
        ));
    }

    return points;
}

/**
 * Draw 3D star with rotation
 */
export function draw3DStar(ctx, w, h, rOuter, rInner) {
    const cx = w / 2;
    const cy = h / 2;

    // Generate star points
    let points = generate3DStarPoints(state.spikes, rOuter, rInner);

    // Apply 3D rotations
    points = points.map(p => rotate3D(
        p,
        state.rotation3DX || 0,
        state.rotation3DY || 0,
        state.rotation3DZ || 0
    ));

    // Project to 2D
    const projected = points.map(p => project3D(p));

    // Sort by Z-depth (painter's algorithm)
    const avgZ = points.reduce((sum, p) => sum + p.z, 0) / points.length;

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

    ctx.beginPath();
    projected.forEach((p, i) => {
        if (i === 0) {
            ctx.moveTo(p.x, p.y);
        } else {
            ctx.lineTo(p.x, p.y);
        }
    });
    ctx.closePath();

    // Apply lighting based on Z-depth
    const brightness = 1 + (avgZ / 500);
    ctx.globalAlpha = Math.max(0.3, Math.min(1, brightness));

    ctx.fill();
    if (state.lineWidth > 0) ctx.stroke();

    ctx.restore();
}

/**
 * Update 3D rotation (called from animation loop)
 */
export function update3DRotation() {
    if (state.auto3DRotation) {
        state.rotation3DX = (state.rotation3DX || 0) + 0.5;
        state.rotation3DY = (state.rotation3DY || 0) + 0.3;
        state.rotation3DZ = (state.rotation3DZ || 0) + 0.2;

        // Keep angles in 0-360 range
        state.rotation3DX %= 360;
        state.rotation3DY %= 360;
        state.rotation3DZ %= 360;
    }
}

/* V7 Renderer Module */
import { state } from './state.js';
import { drawStarPath } from './shapes.js';
import { drawParticles } from './particles.js';
import { getAudioData } from './audio.js';
import { renderRecursiveFractal } from './fractals.js';
import { applyGravity, calculateOrbit } from './physics.js';
import { applyFilters } from './filters.js';
import { drawMandala, drawSpiral } from './symmetry.js';

export function draw(ctx, canvas) {
    const width = canvas.width;
    const height = canvas.height;

    // Clear & BG
    if (state.trailEnabled && state.speed > 0) {
        // Transparent clear for trails
        ctx.fillStyle = state.bgColor + '1a'; // ~10% opacity
        ctx.fillRect(0, 0, width, height);
    } else {
        ctx.clearRect(0, 0, width, height);
        if (state.bgColor) {
            ctx.fillStyle = state.bgColor;
            ctx.fillRect(0, 0, width, height);
        }
    }

    // Ambient Particles (Behind)
    drawParticles(ctx, width, height);

    // Core Styles
    ctx.lineJoin = 'round';
    ctx.strokeStyle = state.strokeColor;
    ctx.lineWidth = state.lineWidth;

    // Audio Mod
    let rOuter = state.outerRadius;
    let rInner = state.innerRadius;
    let glowVal = state.glow;

    if (state.audioMode) {
        const audio = getAudioData();
        if (audio) {
            const bassBoost = (audio.bass / 255) * 50;
            rOuter += bassBoost;
            rInner += (bassBoost / 2);
            if (state.glow > 0) glowVal += (audio.avg / 5);
        }
    }

    // Glow
    if (glowVal > 0) {
        ctx.shadowBlur = glowVal;
        ctx.shadowColor = state.strokeColor;
    } else {
        ctx.shadowBlur = 0;
        ctx.shadowColor = 'transparent';
    }

    // V8 Rainbow Flow (Dynamic Fill)
    let dynamicFill = null;
    if (state.rainbowMode) {
        const hue = (Date.now() / 20) % 360;
        dynamicFill = `hsl(${hue}, 70%, 50%)`;
    }

    // V8 Cosmic Pulse (Scale Mod)
    let pulseScale = 1;
    if (state.pulseEnabled) {
        pulseScale = 1 + Math.sin(Date.now() * 0.002) * 0.05;
    }

    // Apply pulse to radii
    rOuter *= pulseScale;
    rInner *= pulseScale;

    // V12 Physics (Gravity & Orbit)
    let physicsOffsetX = 0;
    let physicsOffsetY = 0;

    if (state.gravityEnabled) {
        const gravity = applyGravity(width, height);
        physicsOffsetX += gravity.x;
        physicsOffsetY += gravity.y;
    }

    if (state.orbitEnabled) {
        const orbit = calculateOrbit(Date.now(), 80);
        physicsOffsetX += orbit.x;
        physicsOffsetY += orbit.y;
    }

    // Draw Mode with Echoes (V11)
    const echoes = state.echoEnabled ? state.echoCount : 1;

    for (let i = 0; i < echoes; i++) {
        ctx.save();

        if (state.echoEnabled && i > 0) {
            const scale = 1 - (i * 0.1);
            const alpha = 1 - (i / echoes);
            ctx.scale(scale, scale);
            ctx.globalAlpha = alpha;
        }

        // V13 Symmetry Modes
        if (state.mandalaMode) {
            drawMandala(ctx, width, height, rOuter, rInner, dynamicFill);
        }
        else if (state.spiralMode) {
            drawSpiral(ctx, width, height, rOuter, rInner, dynamicFill);
        }
        // V6+ Modes
        else if (state.kaleidoscopeMode) {
            drawKaleidoscope(ctx, width, height, rOuter, rInner, dynamicFill, physicsOffsetX, physicsOffsetY);
        }
        else if (state.wallpaperMode) {
            drawWallpaper(ctx, width, height, rOuter, rInner, dynamicFill, physicsOffsetX, physicsOffsetY);
        } else {
            drawSingleStar(ctx, width, height, rOuter, rInner, dynamicFill, physicsOffsetX, physicsOffsetY);
        }

        ctx.restore();
    }

    // V13 Post-Processing Filters
    applyFilters(ctx, canvas);
}



function drawSingleStar(ctx, w, h, rOuter, rInner, dynamicFill, offsetX = 0, offsetY = 0) {
    const cx = w / 2 + offsetX;
    const cy = h / 2 + offsetY;

    ctx.fillStyle = getFillStyle(ctx, cx, cy, rOuter, dynamicFill);

    // V8 Mouse Parallax
    if (state.parallaxEnabled) {
        const px = (state.mouseX / w - 0.5) * 30;
        const py = (state.mouseY / h - 0.5) * 30;
        ctx.translate(px, py);
    }

    ctx.save();
    ctx.translate(cx, cy);
    ctx.rotate(state.rotation);

    ctx.rotate(state.rotation);

    if (state.fractalMode) {
        renderRecursiveFractal(ctx, w, h, rOuter, rInner);
    } else {
        drawStarPath(ctx, state.spikes, rOuter, rInner, state.curve, state.twist);
        ctx.fill();
        if (state.lineWidth > 0) ctx.stroke();
    }

    ctx.restore();
}

function drawKaleidoscope(ctx, w, h, rOuter, rInner, dynamicFill, offsetX = 0, offsetY = 0) {
    const cx = w / 2;
    const cy = h / 2;
    const segs = state.segments;
    const angle = (Math.PI * 2) / segs;

    for (let i = 0; i < segs; i++) {
        ctx.save();
        ctx.translate(cx, cy);
        ctx.rotate(i * angle);
        ctx.translate(rOuter / 2, 0);
        ctx.rotate(state.rotation);

        const scale = 3 / segs;
        ctx.scale(scale, scale);

        ctx.fillStyle = getFillStyle(ctx, 0, 0, rOuter, dynamicFill);

        if (state.fractalMode) {
            renderRecursiveFractal(ctx, w, h, rOuter, rInner);
        } else {
            drawStarPath(ctx, state.spikes, rOuter, rInner, state.curve, state.twist);
            ctx.fill();
            if (state.lineWidth > 0) ctx.stroke();
        }

        ctx.restore();
    }

    // Center Star
    drawSingleStar(ctx, w, h, rOuter / 2, rInner / 2, dynamicFill);
}

function drawWallpaper(ctx, w, h, rOuter, rInner, dynamicFill, offsetX = 0, offsetY = 0) {
    const rows = state.rows;
    const cols = state.cols;
    const cellW = w / cols;
    const cellH = h / rows;

    for (let r = 0; r < rows; r++) {
        for (let c = 0; c < cols; c++) {
            const cx = (c * cellW) + (cellW / 2);
            const cy = (r * cellH) + (cellH / 2);

            ctx.fillStyle = getFillStyle(ctx, cx, cy, rOuter, dynamicFill);

            ctx.save();
            ctx.translate(cx, cy);
            ctx.rotate(state.rotation);

            if (state.fractalMode) {
                renderRecursiveFractal(ctx, w, h, rOuter, rInner);
            } else {
                drawStarPath(ctx, state.spikes, rOuter, rInner, state.curve, state.twist);
                ctx.fill();
                if (state.lineWidth > 0) ctx.stroke();
            }

            ctx.restore();
        }
    }
}

function getFillStyle(ctx, cx, cy, r, dynamicFill) {
    const color1 = dynamicFill || state.fillColor;
    const color2 = state.rainbowMode ? `hsl(${(Date.now() / 20 + 180) % 360}, 70%, 50%)` : state.fillColor2;

    if (state.useGradient) {
        const gradient = ctx.createRadialGradient(cx, cy, state.innerRadius / 4, cx, cy, r);
        gradient.addColorStop(0, color1);
        gradient.addColorStop(1, color2);
        return gradient;
    }
    return color1;
}