import SwiftUI
import Metal

struct ArtworkShader: View {
    let gradient: LinearGradient?
    let isAlive: Bool
    @State private var time: Float = 0.0
    @State private var pausedTime: Float = 0.0
    @State private var animationTimer: Timer?
    @State private var generatedGradient: LinearGradient
    
    init(gradient: LinearGradient? = nil, isAlive: Bool = true) {
        self.gradient = gradient
        self.isAlive = isAlive
        self._generatedGradient = State(initialValue: gradient ?? Self.generateRandomGradient())
    }
    
    var body: some View {
        Rectangle()
            .fill(generatedGradient)
            .visualEffect { content, proxy in
                content
                    .colorEffect(
                        ShaderLibrary.default.thermal(
                            .float(isAlive ? time : pausedTime),
                            .float2(proxy.size)
                        )
                    )
            }
            .onAppear {
                if isAlive {
                    // Start animation from current time (or 0 if first time)
                    time = pausedTime
                    startAnimation()
                }
            }
            .onDisappear {
                stopAnimation()
            }
            .onChange(of: isAlive) { _, newValue in
                if newValue {
                    // Resume animation from paused time
                    time = pausedTime
                    startAnimation()
                } else {
                    // Pause animation and save current time
                    pausedTime = time
                    stopAnimation()
                }
            }
    }
    
    private func startAnimation() {
        // Stop any existing timer first
        stopAnimation()
        
        guard isAlive else { return }
        
        animationTimer = Timer.scheduledTimer(withTimeInterval: 1/60.0, repeats: true) { _ in
            DispatchQueue.main.async {
                time += 0.032 // ~60fps, 2x speed
            }
        }
    }
    
    private func stopAnimation() {
        animationTimer?.invalidate()
        animationTimer = nil
    }
    
    private static func generateRandomGradient() -> LinearGradient {
        // Predefined color sets for better visual consistency
        let colorSets: [(Color, Color)] = [
            // Sunset vibes
            (Color(red: 1.0, green: 0.4, blue: 0.0), Color(red: 1.0, green: 0.8, blue: 0.0)),
            // Ocean blues
            (Color(red: 0.0, green: 0.4, blue: 1.0), Color(red: 0.0, green: 0.8, blue: 0.6)),
            // Purple dreams
            (Color(red: 0.6, green: 0.2, blue: 1.0), Color(red: 1.0, green: 0.2, blue: 0.8)),
            // Forest greens
            (Color(red: 0.2, green: 0.8, blue: 0.4), Color(red: 0.0, green: 0.6, blue: 0.8)),
            // Warm earth tones
            (Color(red: 0.8, green: 0.3, blue: 0.1), Color(red: 1.0, green: 0.6, blue: 0.2)),
            // Cool mint
            (Color(red: 0.2, green: 0.9, blue: 0.7), Color(red: 0.4, green: 0.7, blue: 1.0)),
            // Neon cyber
            (Color(red: 1.0, green: 0.0, blue: 0.5), Color(red: 0.0, green: 1.0, blue: 1.0)),
            // Golden hour
            (Color(red: 1.0, green: 0.7, blue: 0.0), Color(red: 1.0, green: 0.4, blue: 0.6)),
            // Deep space
            (Color(red: 0.1, green: 0.2, blue: 0.8), Color(red: 0.4, green: 0.0, blue: 0.6)),
            // Tropical
            (Color(red: 0.0, green: 0.9, blue: 0.5), Color(red: 1.0, green: 0.8, blue: 0.0)),
            // Aurora
            (Color(red: 0.2, green: 1.0, blue: 0.4), Color(red: 0.6, green: 0.4, blue: 1.0)),
            // Fire
            (Color(red: 1.0, green: 0.2, blue: 0.0), Color(red: 1.0, green: 0.6, blue: 0.0))
        ]
        
        let selectedColors = colorSets.randomElement() ?? colorSets[0]
        
        // Random gradient direction
        let gradientTypes: [(UnitPoint, UnitPoint)] = [
            (.topLeading, .bottomTrailing),
            (.topTrailing, .bottomLeading),
            (.top, .bottom),
            (.leading, .trailing)
        ]
        
        let selectedGradient = gradientTypes.randomElement() ?? (.topLeading, .bottomTrailing)
        
        return LinearGradient(
            colors: [selectedColors.0, selectedColors.1],
            startPoint: selectedGradient.0,
            endPoint: selectedGradient.1
        )
    }
}

// Preview with different modes
#Preview {
    let sampleGradient = LinearGradient(
        colors: [
            Color(red: 0.8, green: 0.4, blue: 0.9),
            Color(red: 0.4, green: 0.6, blue: 1.0)
        ],
        startPoint: .topLeading,
        endPoint: .bottomTrailing
    )
    
    VStack(spacing: 20) {
        // Alive with custom gradient
        ArtworkShader(gradient: sampleGradient, isAlive: true)
            .frame(width: 200, height: 200)
            .cornerRadius(12)
        
        HStack(spacing: 16) {
            // Static with random gradient
            ArtworkShader(isAlive: false)
                .frame(width: 80, height: 80)
                .cornerRadius(8)
            
            // Alive with random gradient
            ArtworkShader(isAlive: true)
                .frame(width: 80, height: 80)
                .cornerRadius(8)
            
            // Another random one for variety
            ArtworkShader(isAlive: false)
                .frame(width: 80, height: 80)
                .cornerRadius(8)
        }
    }
    .padding()
    .background(Constants.Colors.Background.primary)
}