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.bundle(.module).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()

        animationTimer = Timer.scheduledTimer(withTimeInterval: 1/60.0, repeats: true) { _ in
            DispatchQueue.main.async {
                time += 0.016 // ~60fps, slower speed for subtle effect
            }
        }
    }

    private func stopAnimation() {
        animationTimer?.invalidate()
        animationTimer = nil
    }
    
    private static func generateRandomGradient() -> LinearGradient {
        // Generate a random gradient based on current time
        let seed = Int(Date().timeIntervalSince1970) % 1000
        let seed1 = abs(seed % 1000)
        let seed2 = abs((seed / 1000) % 1000)
        
        return LinearGradient(
            colors: [
                Color(
                    red: 0.3 + (Double(seed1 % 600) / 1000.0),
                    green: 0.3 + (Double((seed1 + 200) % 600) / 1000.0),
                    blue: 0.3 + (Double((seed1 + 400) % 600) / 1000.0)
                ),
                Color(
                    red: 0.3 + (Double(seed2 % 600) / 1000.0),
                    green: 0.3 + (Double((seed2 + 200) % 600) / 1000.0),
                    blue: 0.3 + (Double((seed2 + 400) % 600) / 1000.0)
                )
            ],
            startPoint: .topLeading,
            endPoint: .bottomTrailing
        )
    }
}

#Preview {
    ArtworkShader(gradient: nil, isAlive: true)
        .frame(width: 200, height: 200)
        .cornerRadius(12)
}