class FractalCard extends HTMLElement {
    connectedCallback() {
        const seed = this.getAttribute('seed') || '42';
        const color = this.getAttribute('color') || '#ff00ff';
        
        this.attachShadow({ mode: 'open' });
        this.shadowRoot.innerHTML = `
            <style>
                :host {
                    display: block;
                }
                
                .fractal-container {
                    position: relative;
                    aspect-ratio: 1;
                    background: rgba(255, 255, 255, 0.05);
                    border-radius: 1rem;
                    overflow: hidden;
                    cursor: pointer;
                    transition: all 0.3s ease;
                }
                
                .fractal-container:hover {
                    transform: scale(1.05);
                    box-shadow: 0 10px 30px ${color}40;
                }
                
                .fractal-canvas {
                    width: 100%;
                    height: 100%;
                }
                
                .overlay {
                    position: absolute;
                    bottom: 0;
                    left: 0;
                    right: 0;
                    background: linear-gradient(transparent, rgba(0, 0, 0, 0.8));
                    padding: 1rem;
                    transform: translateY(100%);
                    transition: transform 0.3s ease;
                }
                
                .fractal-container:hover .overlay {
                    transform: translateY(0);
                }
                
                .label {
                    color: white;
                    font-weight: 600;
                    font-size: 0.875rem;
                }
            </style>
            
            <div class="fractal-container">
                <canvas class="fractal-canvas"></canvas>
                <div class="overlay">
                    <div class="label">Fractal #${seed}</div>
                </div>
            </div>
        `;
        
        this.setupFractal(seed, color);
    }
    
    setupFractal(seed, color) {
        const canvas = this.shadowRoot.querySelector('.fractal-canvas');
        const ctx = canvas.getContext('2d');
        
        const resizeCanvas = () => {
            canvas.width = canvas.offsetWidth;
            canvas.height = canvas.offsetHeight;
            drawFractal();
        };
        
        const drawFractal = () => {
            const width = canvas.width;
            const height = canvas.height;
            
            ctx.fillStyle = '#000';
            ctx.fillRect(0, 0, width, height);
            
            // Generate fractal pattern based on seed
            const centerX = width / 2;
            const centerY = height / 2;
            const maxRadius = Math.min(width, height) / 2;
            
            for (let i = 0; i < 360; i += 0.5) {
                const angle = i * Math.PI / 180;
                const seedNum = parseInt(seed);
                const radius = maxRadius * (0.5 + 0.3 * Math.sin(angle * seedNum * 0.01));
                
                const x = centerX + radius * Math.cos(angle);
                const y = centerY + radius * Math.sin(angle);
                
                const hue = (i + seedNum * 10) % 360;
                ctx.fillStyle = `hsla(${hue}, 70%, 50%, 0.8)`;
                ctx.beginPath();
                ctx.arc(x, y, 2, 0, Math.PI * 2);
                ctx.fill();
            }
            
            // Add some recursive patterns
            const drawRecursive = (x, y, size, depth) => {
                if (depth === 0 || size < 2) return;
                
                ctx.strokeStyle = color + '40';
                ctx.lineWidth = 1;
                ctx.beginPath();
                ctx.arc(x, y, size, 0, Math.PI * 2);
                ctx.stroke();
                
                const newSize = size * 0.5;
                const offset = size * 0.7;
                
                drawRecursive(x - offset, y, newSize, depth - 1);
                drawRecursive(x + offset, y, newSize, depth - 1);
                drawRecursive(x, y - offset, newSize, depth - 1);
                drawRecursive(x, y + offset, newSize, depth - 1);
            };
            
            drawRecursive(centerX, centerY, maxRadius * 0.3, 4);
        };
        
        resizeCanvas();
        window.addEventListener('resize', resizeCanvas);
    }
}

customElements.define('fractal-card', FractalCard);