📷 PhotosUI

import SwiftUI
import PhotosUI

struct PhotosPickerView: View {
    @State private var selectedItem: PhotosPickerItem?
    @State private var selectedImage: Image?

    var body: some View {
        VStack(spacing: 20) {
            if let selectedImage {
                selectedImage
                    .resizable()
                    .scaledToFit()
                    .frame(width: 300, height: 300)
                    .cornerRadius(12)
            } else {
                Image(systemName: "photo.on.rectangle.angled")
                    .font(.system(size: 60))
                    .foregroundStyle(.secondary)
            }

            // 단일 사진 선택
            PhotosPicker("사진 선택", selection: $selectedItem, matching: .images)
                .buttonStyle(.borderedProminent)
                .onChange(of: selectedItem) {
                    Task {
                        if let data = try? await selectedItem?.loadTransferable(type: Data.self) {
                            if let uiImage = UIImage(data: data) {
                                selectedImage = Image(uiImage: uiImage)
                            }
                        }
                    }
                }
        }
        .padding()
    }
}

// 다중 선택 예제
struct MultiplePhotosPickerView: View {
    @State private var selectedItems: [PhotosPickerItem] = []
    @State private var selectedImages: [UIImage] = []

    var body: some View {
        VStack {
            ScrollView {
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))]) {
                    ForEach(selectedImages, id: \.self) { image in
                        Image(uiImage: image)
                            .resizable()
                            .scaledToFill()
                            .frame(width: 100, height: 100)
                            .clipped()
                            .cornerRadius(8)
                    }
                }
                .padding()
            }

            PhotosPicker(
                selection: $selectedItems,
                maxSelectionCount: 10,
                matching: .images
            ) {
                Label("사진 선택 (최대 10개)", systemImage: "photo.on.rectangle")
            }
            .buttonStyle(.borderedProminent)
            .padding()
            .onChange(of: selectedItems) {
                Task {
                    selectedImages = []
                    for item in selectedItems {
                        if let data = try? await item.loadTransferable(type: Data.self),
                           let image = UIImage(data: data) {
                            selectedImages.append(image)
                        }
                    }
                }
            }
        }
    }
}

import SwiftUI
import PhotosUI
import AVKit

struct VideoPickerView: View {
    @State private var selectedItem: PhotosPickerItem?
    @State private var videoURL: URL?
    @State private var player: AVPlayer?

    var body: some View {
        VStack {
            if let player {
                VideoPlayer(player: player)
                    .frame(height: 300)
                    .cornerRadius(12)
            } else {
                Image(systemName: "video.circle")
                    .font(.system(size: 60))
                    .foregroundStyle(.secondary)
            }

            // 비디오만 선택
            PhotosPicker("비디오 선택", selection: $selectedItem, matching: .videos)
                .buttonStyle(.borderedProminent)
                .onChange(of: selectedItem) {
                    Task {
                        if let movie = try? await selectedItem?.loadTransferable(type: Movie.self) {
                            player = AVPlayer(url: movie.url)
                        }
                    }
                }
        }
        .padding()
    }
}

// Movie 타입 정의
struct Movie: Transferable {
    let url: URL

    static var transferRepresentation: some TransferRepresentation {
        FileRepresentation(contentType: .movie) { movie in
            SentTransferredFile(movie.url)
        } importing: { received in
            let copy = URL.documentsDirectory.appending(path: "movie.mov")
            if FileManager.default.fileExists(atPath: copy.path()) {
                try FileManager.default.removeItem(at: copy)
            }
            try FileManager.default.copyItem(at: received.file, to: copy)
            return Self.init(url: copy)
        }
    }
}

// Live Photo 선택
struct LivePhotoPickerView: View {
    @State private var selectedItem: PhotosPickerItem?

    var body: some View {
        VStack {
            // Live Photos 포함 선택
            PhotosPicker(
                "사진 선택 (Live Photos 포함)",
                selection: $selectedItem,
                matching: .any(of: [.images, .livePhotos])
            )
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

import SwiftUI
import PhotosUI

struct PHPickerView: UIViewControllerRepresentable {
    @Binding var selectedImages: [UIImage]
    let selectionLimit: Int
    let filter: PHPickerFilter

    func makeUIViewController(context: Context) -> PHPickerViewController {
        var configuration = PHPickerConfiguration()
        configuration.selectionLimit = selectionLimit
        configuration.filter = filter

        let picker = PHPickerViewController(configuration: configuration)
        picker.delegate = context.coordinator
        return picker
    }

    func updateUIViewController(_ uiViewController: PHPickerViewController, context: Context) {}

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    class Coordinator: NSObject, PHPickerViewControllerDelegate {
        let parent: PHPickerView

        init(_ parent: PHPickerView) {
            self.parent = parent
        }

        func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
            picker.dismiss(animated: true)

            var images: [UIImage] = []

            let group = DispatchGroup()

            for result in results {
                group.enter()

                result.itemProvider.loadObject(ofClass: UIImage.self) { object, error in
                    defer { group.leave() }

                    if let image = object as? UIImage {
                        images.append(image)
                    }
                }
            }

            group.notify(queue: .main) {
                self.parent.selectedImages = images
            }
        }
    }
}

// 사용 예제
struct PHPickerExampleView: View {
    @State private var selectedImages: [UIImage] = []
    @State private var showPicker = false

    var body: some View {
        VStack {
            ScrollView {
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))]) {
                    ForEach(selectedImages, id: \.self) { image in
                        Image(uiImage: image)
                            .resizable()
                            .scaledToFill()
                            .frame(width: 100, height: 100)
                            .clipped()
                    }
                }
            }

            Button("사진 선택") {
                showPicker = true
            }
            .buttonStyle(.borderedProminent)
        }
        .sheet(isPresented: $showPicker) {
            PHPickerView(
                selectedImages: $selectedImages,
                selectionLimit: 5,
                filter: .images
            )
        }
    }
}

import SwiftUI
import PhotosUI

struct FilteredPickerView: View {
    @State private var selectedItems: [PhotosPickerItem] = []
    @State private var filterType: PHPickerFilter = .images

    var body: some View {
        VStack(spacing: 20) {
            Text("필터 선택")
                .font(.headline)

            // 이미지만
            PhotosPicker(
                "이미지만 선택",
                selection: $selectedItems,
                matching: .images
            )
            .buttonStyle(.bordered)

            // 비디오만
            PhotosPicker(
                "비디오만 선택",
                selection: $selectedItems,
                matching: .videos
            )
            .buttonStyle(.bordered)

            // Live Photos만
            PhotosPicker(
                "Live Photos만 선택",
                selection: $selectedItems,
                matching: .livePhotos
            )
            .buttonStyle(.bordered)

            // 파노라마 사진만
            PhotosPicker(
                "파노라마 사진만",
                selection: $selectedItems,
                matching: .panoramas
            )
            .buttonStyle(.bordered)

            // 스크린샷만
            PhotosPicker(
                "스크린샷만",
                selection: $selectedItems,
                matching: .screenshots
            )
            .buttonStyle(.bordered)

            // 슬로모션 비디오만
            PhotosPicker(
                "슬로모션 비디오만",
                selection: $selectedItems,
                matching: .slomoVideos
            )
            .buttonStyle(.bordered)

            // 여러 필터 조합
            PhotosPicker(
                "이미지 또는 비디오",
                selection: $selectedItems,
                matching: .any(of: [.images, .videos])
            )
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

// 고급 필터링
struct AdvancedFilterView: View {
    @State private var selectedImages: [UIImage] = []
    @State private var showPicker = false

    var body: some View {
        VStack {
            Button("PNG 이미지만 선택") {
                showPicker = true
            }
            .buttonStyle(.borderedProminent)
        }
        .sheet(isPresented: $showPicker) {
            PHPickerView(
                selectedImages: $selectedImages,
                selectionLimit: 10,
                filter: .any(of: [.images])
            )
        }
    }
}

import SwiftUI
import PhotosUI

struct PhotoGalleryView: View {
    @State private var selectedItems: [PhotosPickerItem] = []
    @State private var photos: [PhotoItem] = []
    @State private var isLoading = false

    var body: some View {
        NavigationStack {
            ScrollView {
                if photos.isEmpty {
                    ContentUnavailableView(
                        "사진이 없습니다",
                        systemImage: "photo.on.rectangle.angled",
                        description: Text("아래 버튼을 눌러 사진을 추가하세요")
                    )
                    .frame(height: 400)
                } else {
                    LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))], spacing: 8) {
                        ForEach(photos) { photo in
                            ZStack(alignment: .topTrailing) {
                                Image(uiImage: photo.image)
                                    .resizable()
                                    .scaledToFill()
                                    .frame(width: 100, height: 100)
                                    .clipped()
                                    .cornerRadius(8)

                                Button {
                                    photos.removeAll { $0.id == photo.id }
                                } label: {
                                    Image(systemName: "xmark.circle.fill")
                                        .foregroundStyle(.white)
                                        .background(Circle().fill(Color.black.opacity(0.5)))
                                }
                                .padding(4)
                            }
                        }
                    }
                    .padding()
                }

                if isLoading {
                    ProgressView("사진 로딩 중...")
                        .padding()
                }
            }
            .navigationTitle("사진 갤러리")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    PhotosPicker(
                        selection: $selectedItems,
                        maxSelectionCount: 20,
                        matching: .images
                    ) {
                        Label("추가", systemImage: "plus")
                    }
                }

                ToolbarItem(placement: .bottomBar) {
                    Text("\(photos.count)개 사진")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }
            .onChange(of: selectedItems) {
                Task {
                    isLoading = true
                    defer { isLoading = false }

                    for item in selectedItems {
                        if let data = try? await item.loadTransferable(type: Data.self),
                           let image = UIImage(data: data) {
                            photos.append(PhotoItem(image: image))
                        }
                    }
                    selectedItems = []
                }
            }
        }
    }
}

struct PhotoItem: Identifiable {
    let id = UUID()
    let image: UIImage
}