/* V14 Shaders Module - Advanced Shader-like Effects */
import { state } from './state.js';

/**
 * Apply all enabled shader effects
 */
export function applyShaderEffects(ctx, canvas) {
    if (state.depthFieldEnabled) {
        applyDepthField(ctx, canvas);
    }

    if (state.warpFieldEnabled) {
        applyWarpField(ctx, canvas);
    }

    if (state.chromaticAberrationV2) {
        applyChromaticAberration(ctx, canvas);
    }

    if (state.edgeGlowEnabled) {
        applyEdgeGlow(ctx, canvas);
    }

    if (state.waveDistortEnabled) {
        applyWaveDistortion(ctx, canvas);
    }

    if (state.colorGradingEnabled) {
        applyColorGrading(ctx, canvas);
    }
}

/**
 * Depth Field - Simulated depth of field blur
 */
function applyDepthField(ctx, canvas) {
    const cx = canvas.width / 2;
    const cy = canvas.height / 2;
    const maxDist = Math.sqrt(cx * cx + cy * cy);

    // Simple radial blur simulation
    ctx.save();
    ctx.globalCompositeOperation = 'multiply';

    const gradient = ctx.createRadialGradient(cx, cy, 0, cx, cy, maxDist);
    gradient.addColorStop(0, 'rgba(255,255,255,1)');
    gradient.addColorStop(0.5, 'rgba(255,255,255,0.9)');
    gradient.addColorStop(1, 'rgba(200,200,200,0.7)');

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

/**
 * Warp Field - Space-time distortion
 */
function applyWarpField(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;
    const tempCanvas = document.createElement('canvas');
    tempCanvas.width = canvas.width;
    tempCanvas.height = canvas.height;
    const tempCtx = tempCanvas.getContext('2d');
    tempCtx.putImageData(imageData, 0, 0);

    ctx.clearRect(0, 0, canvas.width, canvas.height);

    const cx = canvas.width / 2;
    const cy = canvas.height / 2;
    const strength = 30;

    for (let y = 0; y < canvas.height; y += 2) {
        for (let x = 0; x < canvas.width; x += 2) {
            const dx = x - cx;
            const dy = y - cy;
            const dist = Math.sqrt(dx * dx + dy * dy);
            const angle = Math.atan2(dy, dx);

            const warp = strength / (dist + 1);
            const newX = x + Math.cos(angle) * warp;
            const newY = y + Math.sin(angle) * warp;

            if (newX >= 0 && newX < canvas.width && newY >= 0 && newY < canvas.height) {
                const pixel = tempCtx.getImageData(newX, newY, 1, 1);
                ctx.putImageData(pixel, x, y);
            }
        }
    }
}

/**
 * Enhanced Chromatic Aberration
 */
function applyChromaticAberration(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;
    const offset = 5;

    // Shift channels
    for (let i = 0; i < data.length; i += 4) {
        const rIdx = i + offset * 4;
        const bIdx = i - offset * 4;

        if (rIdx < data.length) {
            data[i] = data[rIdx]; // R from offset
        }
        if (bIdx >= 0) {
            data[i + 2] = data[bIdx + 2]; // B from -offset
        }
    }

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

/**
 * Edge Glow - Neon edge detection
 */
function applyEdgeGlow(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;
    const w = canvas.width;
    const h = canvas.height;

    // Simple edge detection (Sobel-like)
    const edges = new Uint8ClampedArray(data.length);

    for (let y = 1; y < h - 1; y++) {
        for (let x = 1; x < w - 1; x++) {
            const idx = (y * w + x) * 4;

            // Get surrounding pixels
            const tl = data[((y - 1) * w + (x - 1)) * 4];
            const tr = data[((y - 1) * w + (x + 1)) * 4];
            const bl = data[((y + 1) * w + (x - 1)) * 4];
            const br = data[((y + 1) * w + (x + 1)) * 4];

            const gx = (tr + 2 * data[((y) * w + (x + 1)) * 4] + br) -
                (tl + 2 * data[((y) * w + (x - 1)) * 4] + bl);
            const gy = (bl + 2 * data[((y + 1) * w + x) * 4] + br) -
                (tl + 2 * data[((y - 1) * w + x) * 4] + tr);

            const edge = Math.sqrt(gx * gx + gy * gy);

            if (edge > 50) {
                edges[idx] = 255;     // R
                edges[idx + 1] = 255; // G
                edges[idx + 2] = 255; // B
                edges[idx + 3] = 255; // A
            }
        }
    }

    // Overlay edges with glow
    ctx.save();
    ctx.globalCompositeOperation = 'screen';
    ctx.filter = 'blur(3px)';
    const edgeData = new ImageData(edges, w, h);
    ctx.putImageData(edgeData, 0, 0);
    ctx.filter = 'none';
    ctx.restore();
}

/**
 * Wave Distortion - Sine wave displacement
 */
function applyWaveDistortion(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const tempCanvas = document.createElement('canvas');
    tempCanvas.width = canvas.width;
    tempCanvas.height = canvas.height;
    const tempCtx = tempCanvas.getContext('2d');
    tempCtx.putImageData(imageData, 0, 0);

    ctx.clearRect(0, 0, canvas.width, canvas.height);

    const amplitude = 10;
    const frequency = 0.05;
    const time = Date.now() * 0.001;

    for (let y = 0; y < canvas.height; y++) {
        const offset = Math.sin(y * frequency + time) * amplitude;
        ctx.drawImage(tempCanvas, offset, y, canvas.width, 1, 0, y, canvas.width, 1);
    }
}

/**
 * Color Grading - Professional color correction
 */
function applyColorGrading(ctx, canvas) {
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;

    // Cinematic color grading (teal and orange)
    for (let i = 0; i < data.length; i += 4) {
        const r = data[i];
        const g = data[i + 1];
        const b = data[i + 2];

        // Boost oranges in highlights
        if (r > 128) {
            data[i] = Math.min(255, r * 1.1);
            data[i + 1] = Math.min(255, g * 0.95);
        }

        // Boost teals in shadows
        if (b > 100 && r < 128) {
            data[i + 1] = Math.min(255, g * 1.05);
            data[i + 2] = Math.min(255, b * 1.1);
        }

        // Increase contrast
        data[i] = ((data[i] - 128) * 1.2) + 128;
        data[i + 1] = ((data[i + 1] - 128) * 1.2) + 128;
        data[i + 2] = ((data[i + 2] - 128) * 1.2) + 128;
    }

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