import SwiftUI
import PhotosUI

/// 照片选择器，封装了系统相册选择功能
/// 使用UIViewControllerRepresentable包装PHPickerViewController，提供SwiftUI兼容的图片选择界面
struct PhotoPicker: UIViewControllerRepresentable {
    // MARK: - Properties
    
    /// 绑定的已选图片数组，用于存储用户选择的图片
    @Binding var selectedImages: [UIImage]
    
    /// 最多可选图片数量，默认为1
    let selectionLimit: Int
    
    /// 图片过滤器，默认为图片类型，可过滤特定类型的媒体
    let filter: PHPickerFilter
    
    /// 图片上传完成回调，返回上传结果或错误
    var onImageUploaded: ((Result<ImageUploaderGetID.UploadResult, Error>) -> Void)?
    
    // MARK: - Initialization
    
    /// 初始化照片选择器
    /// - Parameters:
    ///   - selectedImages: 绑定的图片数组，用于接收用户选择的图片
    ///   - selectionLimit: 最多可选图片数量，默认为1
    ///   - filter: 媒体类型过滤器，默认为图片
    ///   - onImageUploaded: 图片上传完成后的回调闭包
    init(
        selectedImages: Binding<[UIImage]>,
        selectionLimit: Int = 1,
        filter: PHPickerFilter = .images,
        onImageUploaded: ((Result<ImageUploaderGetID.UploadResult, Error>) -> Void)? = nil
    ) {
        self._selectedImages = selectedImages
        self.selectionLimit = selectionLimit
        self.filter = filter
        self.onImageUploaded = onImageUploaded
    }
    
    // MARK: - UIViewControllerRepresentable
    
    /// 创建并返回配置好的PHPickerViewController
    func makeUIViewController(context: Context) -> PHPickerViewController {
        var configuration = PHPickerConfiguration(photoLibrary: PHPhotoLibrary.shared())
        configuration.filter = filter
        configuration.selectionLimit = selectionLimit
        configuration.preferredAssetRepresentationMode = .current
        
        let picker = PHPickerViewController(configuration: configuration)
        picker.delegate = context.coordinator
        return picker
    }
    
    /// 更新视图控制器（空实现，因为不需要更新）
    func updateUIViewController(_ uiViewController: PHPickerViewController, context: Context) {}
    
    /// 创建协调器，用于处理PHPickerViewController的代理方法
    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
    
    // MARK: - Coordinator
    
    /// 协调器类，处理PHPickerViewController的代理方法
    class Coordinator: NSObject, PHPickerViewControllerDelegate {
        /// 对父视图的弱引用
        let parent: PhotoPicker
        
        /// 图片上传器实例
        private let uploader = ImageUploaderGetID()
        
        init(_ parent: PhotoPicker) {
            self.parent = parent
        }
        
        /// 当用户完成图片选择时调用
        /// - Parameters:
        ///   - picker: 图片选择器实例
        ///   - results: 用户选择的图片结果数组
        func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
            // 清空已选图片
            parent.selectedImages.removeAll()
            
            // 使用DispatchGroup管理多个异步图片加载任务
            let group = DispatchGroup()
            var loadedImages: [Int: UIImage] = [:]  // 用于保持图片顺序的字典
            
            // 遍历所有选中的图片
            for (index, result) in results.enumerated() {
                group.enter()  // 进入组
                
                // 检查是否可以加载图片
                if result.itemProvider.canLoadObject(ofClass: UIImage.self) {
                    // 异步加载图片
                    result.itemProvider.loadObject(ofClass: UIImage.self) { [weak self] (image, error) in
                        if let image = image as? UIImage {
                            // 将加载的图片存入字典，保持原始顺序
                            loadedImages[index] = image
                            
                            // 上传图片
                            self?.uploader.uploadImage(image) { result in
                                // 在主线程中调用上传完成回调
                                DispatchQueue.main.async {
                                    switch result {
                                    case .success(let uploadResult):
                                        print("✅ 上传成功！fileId: \(uploadResult.fileId)")
                                        print("📂 文件信息：")
                                        print("   - 文件名: \(uploadResult.fileName)")
                                        print("   - 文件大小: \(uploadResult.fileSize) 字节")
                                        print("   - 文件URL: \(uploadResult.fileUrl)")
                                        
                                        // 调用上传完成回调
                                        self?.parent.onImageUploaded?(.success(uploadResult))
                                        
                                    case .failure(let error):
                                        print("❌ 上传失败: \(error.localizedDescription)")
                                        // 调用上传完成回调，传递错误
                                        self?.parent.onImageUploaded?(.failure(error))
                                    }
                                }
                            }
                        }
                        group.leave()  // 离开组
                    }
                } else {
                    group.leave()  // 如果无法加载图片，也离开组
                }
            }
            
            // 所有图片加载完成后的处理
            group.notify(queue: .main) {
                // 按原始顺序排序并更新图片数组
                let sortedImages = loadedImages.sorted { $0.key < $1.key }.map { $0.value }
                self.parent.selectedImages.append(contentsOf: sortedImages)
                
                // 关闭图片选择器
                picker.dismiss(animated: true)
            }
        }
    }
}

// MARK: - AvatarUploader

/// 头像上传视图，提供头像选择功能
/// 封装了头像显示和选择逻辑，支持点击选择新头像
struct AvatarUploader: View {
    // MARK: - Properties
    
    /// 绑定的当前选中头像图片
    @Binding var selectedImage: UIImage?
    
    /// 头像显示尺寸
    let size: CGFloat
    
    /// 上传完成回调，返回上传结果或错误
    var onUploadComplete: ((Result<ImageUploaderGetID.UploadResult, Error>) -> Void)?
    
    // MARK: - State
    
    /// 控制图片选择器的显示状态
    @State private var isImagePickerPresented = false
    
    // MARK: - Body
    
    var body: some View {
        // 头像按钮，点击后显示图片选择器
        Button(action: { isImagePickerPresented = true }) {
            ZStack {
                if let selectedImage = selectedImage {
                    // 显示已选中的头像
                    Image(uiImage: selectedImage)
                        .resizable()
                        .scaledToFill()
                        .frame(width: size, height: size)
                        .clipShape(RoundedRectangle(cornerRadius: size * 0.1))
                } else {
                    // 默认头像占位视图
                    Color.gray.opacity(0.1)
                        .frame(width: size, height: size)
                        .overlay(
                            SVGImage(svgName: "Avatar")
                                .frame(width: size * 0.8, height: size * 0.8)
                        )
                        .clipShape(RoundedRectangle(cornerRadius: size * 0.1))
                        .overlay(
                            RoundedRectangle(cornerRadius: size * 0.1)
                                .stroke(Color.gray.opacity(0.3), lineWidth: 1)
                        )
                }
            }
            .frame(width: size, height: size)
            .contentShape(Rectangle())  // 确保整个区域都可点击
        }
        .buttonStyle(PlainButtonStyle())  // 使用无样式按钮
        .sheet(isPresented: $isImagePickerPresented) {
            // 显示图片选择器
            PhotoPicker(
                selectedImages: Binding(
                    get: { [selectedImage].compactMap { $0 } },
                    set: { images in
                        selectedImage = images.first
                    }
                ),
                selectionLimit: 1,  // 限制只能选择一张图片
                onImageUploaded: { result in
                    // 图片上传完成后的处理
                    onUploadComplete?(result)
                }
            )
        }
    }
}