/* V13 Filters Module - Post-Processing Effects */
import { state } from './state.js';

/**
 * Apply all enabled filters to the canvas
 */
export function applyFilters(ctx, canvas) {
    if (state.glitchEnabled) {
        applyGlitch(ctx, canvas);
    }

    if (state.scanlinesEnabled) {
        applyScanlines(ctx, canvas);
    }

    if (state.vignetteEnabled) {
        applyVignette(ctx, canvas);
    }

    if (state.bloomEnabled) {
        applyBloom(ctx, canvas);
    }

    if (state.pixelateEnabled) {
        applyPixelate(ctx, canvas);
    }

    if (state.invertEnabled) {
        applyInvert(ctx, canvas);
    }
}

/**
 * Glitch Effect - RGB channel separation
 */
function applyGlitch(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;

    // Random offset
    const offset = Math.floor(Math.random() * 10) - 5;

    // Shift red channel
    for (let i = 0; i < data.length; i += 4) {
        if (i + offset * 4 >= 0 && i + offset * 4 < data.length) {
            data[i] = data[i + offset * 4]; // R
        }
    }

    ctx.putImageData(imageData, 0, 0);
}

/**
 * Scanlines - CRT monitor effect
 */
function applyScanlines(ctx, canvas) {
    ctx.globalAlpha = 0.1;
    ctx.fillStyle = '#000000';

    for (let y = 0; y < canvas.height; y += 4) {
        ctx.fillRect(0, y, canvas.width, 2);
    }

    ctx.globalAlpha = 1.0;
}

/**
 * Vignette - Darkened edges
 */
function applyVignette(ctx, canvas) {
    const cx = canvas.width / 2;
    const cy = canvas.height / 2;
    const radius = Math.max(canvas.width, canvas.height) / 2;

    const gradient = ctx.createRadialGradient(cx, cy, radius * 0.3, cx, cy, radius);
    gradient.addColorStop(0, 'rgba(0,0,0,0)');
    gradient.addColorStop(1, 'rgba(0,0,0,0.7)');

    ctx.fillStyle = gradient;
    ctx.fillRect(0, 0, canvas.width, canvas.height);
}

/**
 * Bloom - Glow overflow effect
 * Note: This is a simplified version. True bloom requires multiple passes.
 */
function applyBloom(ctx, canvas) {
    ctx.save();
    ctx.globalCompositeOperation = 'screen';
    ctx.globalAlpha = 0.3;
    ctx.filter = 'blur(20px)';
    ctx.drawImage(canvas, 0, 0);
    ctx.filter = 'none';
    ctx.restore();
}

/**
 * Pixelate - Retro pixel art look
 */
function applyPixelate(ctx, canvas) {
    const pixelSize = 8;
    const w = canvas.width;
    const h = canvas.height;

    // Get current canvas
    const imageData = ctx.getImageData(0, 0, w, h);

    // Downsample
    ctx.imageSmoothingEnabled = false;
    const tempCanvas = document.createElement('canvas');
    tempCanvas.width = Math.floor(w / pixelSize);
    tempCanvas.height = Math.floor(h / pixelSize);
    const tempCtx = tempCanvas.getContext('2d');
    tempCtx.drawImage(canvas, 0, 0, tempCanvas.width, tempCanvas.height);

    // Upsample
    ctx.clearRect(0, 0, w, h);
    ctx.drawImage(tempCanvas, 0, 0, w, h);
    ctx.imageSmoothingEnabled = true;
}

/**
 * Invert Colors - Negative image
 */
function applyInvert(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;

    for (let i = 0; i < data.length; i += 4) {
        data[i] = 255 - data[i];         // R
        data[i + 1] = 255 - data[i + 1]; // G
        data[i + 2] = 255 - data[i + 2]; // B
        // Alpha unchanged
    }

    ctx.putImageData(imageData, 0, 0);
}

/* 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();
}