//
//  CharacterAvatar.swift
//  lichunWebsocket
//
//  Unified character avatar component with proper image loading
//  Uses SDWebImage for reliable SVG loading with SwiftUI lifecycle handling
//

import SwiftUI
import SDWebImage

/// A reusable avatar component for displaying character images
/// Uses SDWebImage UIKit API for reliable SVG support
struct CharacterAvatar: View {
    // MARK: - Properties

    /// The URL string for the avatar image
    let imageURL: String

    /// The character's name (used for placeholder initial)
    let name: String

    /// Size of the avatar (width and height)
    var size: CGFloat = AppSpacing.avatarSizeMedium

    /// Whether to show the gradient border
    var showBorder: Bool = true

    /// Custom border gradient colors
    var borderGradient: [Color] = [AppColors.primary, AppColors.accent]

    /// Border line width (auto-calculated if nil)
    var borderWidth: CGFloat? = nil

    /// Whether to show the shadow glow effect
    var showGlow: Bool = true

    /// Whether to show loading indicator
    var showLoadingIndicator: Bool = true

    /// Whether to animate the border rotation
    var animateBorder: Bool = false

    // MARK: - State

    @State private var borderRotation: Double = 0
    @State private var loadedImage: UIImage? = nil
    @State private var isLoading: Bool = false

    // MARK: - Computed Properties

    private var computedBorderWidth: CGFloat {
        borderWidth ?? (size > 80 ? 3 : 2)
    }

    private var url: URL? {
        guard !imageURL.isEmpty else { return nil }
        return URL(string: imageURL)
    }

    // MARK: - Body

    var body: some View {
        Group {
            if let image = loadedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFill()
            } else if isLoading {
                placeholderView
                    .overlay(
                        ProgressView()
                            .progressViewStyle(CircularProgressViewStyle(tint: AppColors.primary))
                            .scaleEffect(0.8)
                    )
            } else {
                placeholderView
            }
        }
        .frame(width: size, height: size)
        .clipShape(Circle())
        .overlay(borderOverlay)
        .modifier(GlowModifier(showGlow: showGlow, color: borderGradient.first ?? AppColors.primary, size: size))
        .onAppear {
            loadImage()
            if animateBorder && showBorder {
                withAnimation(
                    .linear(duration: 8.0)
                    .repeatForever(autoreverses: false)
                ) {
                    borderRotation = 360
                }
            }
        }
        .onChange(of: imageURL) { _ in
            loadImage()
        }
    }

    // MARK: - Image Loading

    private func loadImage() {
        guard let url = url else {
            // Avatar logging disabled - uncomment for debugging
            // print("🖼️ CharacterAvatar: No URL for '\(name)' - imageURL is '\(imageURL)'")
            loadedImage = nil
            return
        }

        // Avatar logging disabled - uncomment for debugging
        // print("🖼️ CharacterAvatar: Loading image for '\(name)' from: \(url.absoluteString)")
        isLoading = true

        SDWebImageManager.shared.loadImage(
            with: url,
            options: [.retryFailed, .scaleDownLargeImages],
            progress: nil
        ) { image, data, error, cacheType, finished, imageURL in
            DispatchQueue.main.async {
                isLoading = false
                if let image = image {
                    // Avatar logging disabled - uncomment for debugging
                    // print("🖼️ CharacterAvatar: ✅ Loaded image for '\(name)' - size: \(image.size)")
                    // Resize for better quality at the target size
                    let targetSize = CGSize(width: size * UIScreen.main.scale, height: size * UIScreen.main.scale)
                    loadedImage = image.sd_resizedImage(with: targetSize, scaleMode: .aspectFill)
                } else if let error = error {
                    // Avatar logging disabled - uncomment for debugging
                    // print("🖼️ CharacterAvatar: ❌ Failed to load image for '\(name)': \(error.localizedDescription)")
                    _ = error // Suppress unused variable warning
                } else {
                    // Avatar logging disabled - uncomment for debugging
                    // print("🖼️ CharacterAvatar: ⚠️ No image returned for '\(name)'")
                }
            }
        }
    }

    // MARK: - Subviews

    @ViewBuilder
    private var placeholderView: some View {
        Circle()
            .fill(
                LinearGradient(
                    colors: [
                        AppColors.cardBackground.lighter(by: 0.15),
                        AppColors.cardBackground
                    ],
                    startPoint: .topLeading,
                    endPoint: .bottomTrailing
                )
            )
            .overlay(
                Text(String(name.prefix(1)).uppercased())
                    .font(.system(size: size * 0.4, weight: .bold, design: .rounded))
                    .foregroundStyle(
                        LinearGradient(
                            colors: borderGradient,
                            startPoint: .top,
                            endPoint: .bottom
                        )
                    )
            )
    }

    @ViewBuilder
    private var borderOverlay: some View {
        if showBorder {
            Circle()
                .strokeBorder(
                    LinearGradient(
                        colors: borderGradient,
                        startPoint: .topLeading,
                        endPoint: .bottomTrailing
                    ),
                    lineWidth: computedBorderWidth
                )
                .rotationEffect(.degrees(animateBorder ? borderRotation : 0))
        }
    }
}

// MARK: - Glow Modifier

private struct GlowModifier: ViewModifier {
    let showGlow: Bool
    let color: Color
    let size: CGFloat

    func body(content: Content) -> some View {
        if showGlow {
            content
                .shadow(
                    color: color.opacity(0.2),
                    radius: size > 80 ? 12 : 8,
                    x: 0,
                    y: 4
                )
        } else {
            content
        }
    }
}

// MARK: - Convenience Initializers

extension CharacterAvatar {
    /// Initialize with a Person object
    init(
        person: Person,
        size: CGFloat = AppSpacing.avatarSizeMedium,
        showBorder: Bool = true,
        borderGradient: [Color] = [AppColors.primary, AppColors.accent],
        borderWidth: CGFloat? = nil,
        showGlow: Bool = true,
        animateBorder: Bool = false
    ) {
        self.imageURL = person.image
        self.name = person.firstname
        self.size = size
        self.showBorder = showBorder
        self.borderGradient = borderGradient
        self.borderWidth = borderWidth
        self.showGlow = showGlow
        self.animateBorder = animateBorder

        // Avatar logging disabled - uncomment for debugging
        // if person.image.isEmpty {
        //     print("🖼️ CharacterAvatar(Person): ⚠️ Empty image URL for person '\(person.firstname)' (id: \(person.id))")
        // }
    }
}

// MARK: - Preview

#if DEBUG
struct CharacterAvatar_Previews: PreviewProvider {
    static var previews: some View {
        VStack(spacing: 20) {
            // With valid URL
            CharacterAvatar(
                imageURL: "https://api.dicebear.com/7.x/avataaars/svg?seed=test",
                name: "John"
            )

            // Empty URL (shows placeholder)
            CharacterAvatar(
                imageURL: "",
                name: "Jane",
                size: 80
            )

            // Large size with animated border
            CharacterAvatar(
                imageURL: "https://api.dicebear.com/7.x/avataaars/svg?seed=large",
                name: "Alex",
                size: 120,
                borderGradient: [.pink, .purple],
                animateBorder: true
            )

            // No border, no glow
            CharacterAvatar(
                imageURL: "",
                name: "Sam",
                size: 60,
                showBorder: false,
                showGlow: false
            )
        }
        .padding()
        .background(AppColors.background)
    }
}
#endif