import AVFoundation

// 카메라 권한 요청
func requestCameraPermission() {
    let status = AVCaptureDevice.authorizationStatus(for: .video)
    
    switch status {
    case .authorized:
        // 이미 권한 있음 - 바로 세션 설정 시작
        setupCaptureSession()
        
    case .notDetermined:
        // 아직 요청 안 함 - 권한 요청
        AVCaptureDevice.requestAccess(for: .video) { granted in
            if granted {
                DispatchQueue.main.async {
                    self.setupCaptureSession()
                }
            }
        }
        
    case .denied, .restricted:
        // 거부됨 - 설정 앱으로 안내
        showPermissionAlert()
        
    @unknown default:
        break
    }
}

import UIKit
import AVFoundation

class CameraViewController: UIViewController {
    
    // 핵심 프로퍼티들
    private let captureSession = AVCaptureSession()
    private var videoDeviceInput: AVCaptureDeviceInput?
    private let photoOutput = AVCapturePhotoOutput()
    private var previewLayer: AVCaptureVideoPreviewLayer?
    
    // 세션 설정은 백그라운드 큐에서 실행 (중요!)
    private let sessionQueue = DispatchQueue(label: "session.queue")
    
    override func viewDidLoad() {
        super.viewDidLoad()
        requestCameraPermission()
    }
    
    func setupCaptureSession() {
        // 반드시 백그라운드 큐에서 실행
        sessionQueue.async {
            self.configureCaptureSession()
        }
    }
    
    private func configureCaptureSession() {
        // 세션 설정 시작
        captureSession.beginConfiguration()
        
        // 세션 프리셋 설정 (화질 결정)
        captureSession.sessionPreset = .photo
        
        // 1. 카메라 디바이스 가져오기
        guard let videoDevice = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: .back
        ) else {
            print("카메라 디바이스를 찾을 수 없음 😱")
            captureSession.commitConfiguration()
            return
        }
        
        // 2. 디바이스 입력 생성
        do {
            let videoInput = try AVCaptureDeviceInput(device: videoDevice)
            
            if captureSession.canAddInput(videoInput) {
                captureSession.addInput(videoInput)
                self.videoDeviceInput = videoInput
            }
        } catch {
            print("입력 생성 실패: \(error)")
            captureSession.commitConfiguration()
            return
        }
        
        // 3. 사진 출력 추가
        if captureSession.canAddOutput(photoOutput) {
            captureSession.addOutput(photoOutput)
            
            // HEIF 포맷 지원 여부 확인
            photoOutput.isHighResolutionCaptureEnabled = true
        }
        
        // 세션 설정 완료
        captureSession.commitConfiguration()
        
        // 세션 시작
        captureSession.startRunning()
        
        // 메인 스레드에서 프리뷰 레이어 설정
        DispatchQueue.main.async {
            self.setupPreviewLayer()
        }
    }
}

private func setupPreviewLayer() {
    // 프리뷰 레이어 생성
    let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
    previewLayer.videoGravity = .resizeAspectFill
    previewLayer.frame = view.bounds
    
    // 뷰의 레이어에 추가
    view.layer.insertSublayer(previewLayer, at: 0)
    self.previewLayer = previewLayer
}

// 화면 회전 시 프리뷰 레이어 크기 업데이트
override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    previewLayer?.frame = view.bounds
}

// 뷰가 사라질 때 세션 중지 (배터리 절약!)
override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    sessionQueue.async {
        self.captureSession.stopRunning()
    }
}

// 뷰가 다시 나타날 때 세션 재시작
override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    sessionQueue.async {
        if !self.captureSession.isRunning {
            self.captureSession.startRunning()
        }
    }
}

// 사진 촬영 버튼 액션
@IBAction func capturePhoto(_ sender: UIButton) {
    // 촬영 설정 구성
    let photoSettings = AVCapturePhotoSettings()
    
    // 플래시 설정
    if videoDeviceInput?.device.isFlashAvailable == true {
        photoSettings.flashMode = .auto
    }
    
    // 고해상도 촬영 활성화
    photoSettings.isHighResolutionPhotoEnabled = true
    
    // HEIF 포맷 사용 (iOS 11+, 용량 절약)
    if photoOutput.availablePhotoCodecTypes.contains(.hevc) {
        let settings = AVCapturePhotoSettings(
            format: [AVVideoCodecKey: AVVideoCodecType.hevc]
        )
        photoOutput.capturePhoto(with: settings, delegate: self)
    } else {
        photoOutput.capturePhoto(with: photoSettings, delegate: self)
    }
}

// AVCapturePhotoCaptureDelegate 구현
extension CameraViewController: AVCapturePhotoCaptureDelegate {
    
    // 촬영 완료 콜백
    func photoOutput(
        _ output: AVCapturePhotoOutput,
        didFinishProcessingPhoto photo: AVCapturePhoto,
        error: Error?
    ) {
        if let error = error {
            print("촬영 실패: \(error) 😭")
            return
        }
        
        // 이미지 데이터 추출
        guard let imageData = photo.fileDataRepresentation() else {
            print("이미지 데이터 변환 실패")
            return
        }
        
        // UIImage로 변환
        guard let image = UIImage(data: imageData) else { return }
        
        // 사진 라이브러리에 저장
        saveToPhotoLibrary(image: image)
        
        // 또는 이미지뷰에 표시
        DispatchQueue.main.async {
            self.previewImageView.image = image
        }
    }
}

import Photos

func saveToPhotoLibrary(image: UIImage) {
    PHPhotoLibrary.requestAuthorization { status in
        guard status == .authorized else {
            print("사진 라이브러리 접근 권한 없음 😤")
            return
        }
        
        PHPhotoLibrary.shared().performChanges({
            PHAssetChangeRequest.creationRequestForAsset(from: image)
        }) { success, error in
            if success {
                print("사진 저장 완료! 🎉")
            } else if let error = error {
                print("저장 실패: \(error)")
            }
        }
    }
}

// Live Photo 설정
func setupLivePhoto() {
    let photoSettings = AVCapturePhotoSettings()
    
    // Live Photo 지원 여부 확인
    if photoOutput.isLivePhotoCaptureSupported {
        // 임시 파일 경로 설정
        let livePhotoMovieURL = URL(
            fileURLWithPath: NSTemporaryDirectory()
        ).appendingPathComponent("\(UUID().uuidString).mov")
        
        photoSettings.livePhotoMovieFileURL = livePhotoMovieURL
    }
    
    photoOutput.capturePhoto(with: photoSettings, delegate: self)
}

// Live Photo 처리 델리게이트
func photoOutput(
    _ output: AVCapturePhotoOutput,
    didFinishRecordingLivePhotoMovieForEventualFileAt outputFileURL: URL,
    resolvedSettings: AVCaptureResolvedPhotoSettings
) {
    print("Live Photo 영상 녹화 완료: \(outputFileURL)")
}

func photoOutput(
    _ output: AVCapturePhotoOutput,
    didFinishProcessingLivePhotoToMovieFileAt outputFileURL: URL,
    duration: CMTime,
    photoDisplayTime: CMTime,
    resolvedSettings: AVCaptureResolvedPhotoSettings,
    error: Error?
) {
    if let error = error {
        print("Live Photo 처리 실패: \(error)")
        return
    }
    print("Live Photo 완성! 🎬 경로: \(outputFileURL)")
}

class VideoRecordingViewController: UIViewController {
    
    private let captureSession = AVCaptureSession()
    private let movieOutput = AVCaptureMovieFileOutput()
    private let sessionQueue = DispatchQueue(label: "video.session.queue")
    
    func setupVideoSession() {
        sessionQueue.async {
            self.captureSession.beginConfiguration()
            self.captureSession.sessionPreset = .high
            
            // 비디오 입력 추가
            guard let videoDevice = AVCaptureDevice.default(
                .builtInWideAngleCamera,
                for: .video,
                position: .back
            ),
            let videoInput = try? AVCaptureDeviceInput(device: videoDevice),
            self.captureSession.canAddInput(videoInput) else { return }
            
            self.captureSession.addInput(videoInput)
            
            // 오디오 입력 추가 (마이크)
            guard let audioDevice = AVCaptureDevice.default(for: .audio),
            let audioInput = try? AVCaptureDeviceInput(device: audioDevice),
            self.captureSession.canAddInput(audioInput) else { return }
            
            self.captureSession.addInput(audioInput)
            
            // 비디오 파일 출력 추가
            if self.captureSession.canAddOutput(self.movieOutput) {
                self.captureSession.addOutput(self.movieOutput)
                
                // 비디오 안정화 설정 (손떨림 보정)
                if let connection = self.movieOutput.connection(with: .video) {
                    if connection.isVideoStabilizationSupported {
                        connection.preferredVideoStabilizationMode = .auto
                    }
                }
            }
            
            self.captureSession.commitConfiguration()
            self.captureSession.startRunning()
        }
    }
    
    // 녹화 시작
    func startRecording() {
        guard !movieOutput.isRecording else { return }
        
        // 임시 파일 경로 생성
        let outputURL = URL(fileURLWithPath: NSTemporaryDirectory())
            .appendingPathComponent("\(UUID().uuidString).mov")
        
        movieOutput.startRecording(to: outputURL, recordingDelegate: self)
        print("녹화 시작! 🔴")
    }
    
    // 녹화 종료
    func stopRecording() {
        guard movieOutput.isRecording else { return }
        movieOutput.stopRecording()
        print("녹화 종료! ⏹️")
    }
}

// 녹화 완료 델리게이트
extension VideoRecordingViewController: AVCaptureFileOutputRecordingDelegate {
    
    func fileOutput(
        _ output: AVCaptureFileOutput,
        didFinishRecordingTo outputFileURL: URL,
        from connections: [AVCaptureConnection],
        error: Error?
    ) {
        if let error = error {
            print("녹화 실패: \(error) 😭")
            return
        }
        
        print("녹화 완료! 파일 경로: \(outputFileURL)")
        
        // 사진 라이브러리에 저장
        PHPhotoLibrary.requestAuthorization { status in
            if status == .authorized {
                PHPhotoLibrary.shared().performChanges({
                    PHAssetChangeRequest.creationRequestForAssetFromVideo(
                        atFileURL: outputFileURL
                    )
                }) { success, error in
                    // 임시 파일 삭제
                    try? FileManager.default.removeItem(at: outputFileURL)
                    
                    if success {
                        print("비디오 저장 완료! 🎉")
                    }
                }
            }
        }
    }
}

class RealtimeVideoProcessor: NSObject {
    
    private let captureSession = AVCaptureSession()
    private let videoDataOutput = AVCaptureVideoDataOutput()
    
    // 프레임 처리용 별도 큐 (메인 스레드 블로킹 방지)
    private let videoDataOutputQueue = DispatchQueue(
        label: "video.data.output",
        qos: .userInitiated,
        attributes: [],
        autoreleaseFrequency: .workItem
    )
    
    func setupRealtimeCapture() {
        captureSession.beginConfiguration()
        captureSession.sessionPreset = .high
        
        // 카메라 입력 설정
        guard let videoDevice = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: .front  // 전면 카메라
        ),
        let videoInput = try? AVCaptureDeviceInput(device: videoDevice),
        captureSession.canAddInput(videoInput) else { return }
        
        captureSession.addInput(videoInput)
        
        // 비디오 데이터 출력 설정
        videoDataOutput.videoSettings = [
            kCVPixelBufferPixelFormatTypeKey as String:
                kCVPixelFormatType_32BGRA  // BGRA 포맷
        ]
        
        // 처리 못한 프레임은 드롭 (실시간 처리 유지)
        videoDataOutput.alwaysDiscardsLateVideoFrames = true
        
        // 델리게이트 설정
        videoDataOutput.setSampleBufferDelegate(
            self,
            queue: videoDataOutputQueue
        )
        
        if captureSession.canAddOutput(videoDataOutput) {
            captureSession.addOutput(videoDataOutput)
        }
        
        captureSession.commitConfiguration()
        captureSession.startRunning()
    }
}

// 실시간 프레임 처리 델리게이트
extension RealtimeVideoProcessor: AVCaptureVideoDataOutputSampleBufferDelegate {
    
    func captureOutput(
        _ output: AVCaptureOutput,
        didOutput sampleBuffer: CMSampleBuffer,
        from connection: AVCaptureConnection
    ) {
        // 여기서 각 프레임을 처리!
        // sampleBuffer에서 픽셀 버퍼 추출
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        
        // CIImage로 변환 (Core Image 필터 적용 가능)
        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
        
        // 예: 흑백 필터 적용
        let filter = CIFilter(name: "CIPhotoEffectMono")!
        filter.setValue(ciImage, forKey: kCIInputImageKey)
        
        if let outputImage = filter.outputImage {
            // 처리된 이미지를 화면에 표시
            DispatchQueue.main.async {
                // MTKView나 GLKView에 렌더링
                self.renderFilteredImage(outputImage)
            }
        }
        
        // Vision 프레임워크로 얼굴 감지
        detectFaces(in: pixelBuffer)
    }
    
    // 프레임 드롭 알림
    func captureOutput(
        _ output: AVCaptureOutput,
        didDrop sampleBuffer: CMSampleBuffer,
        from connection: AVCaptureConnection
    ) {
        // 처리 속도가 느려서 프레임 드롭 발생
        // 처리 로직 최적화 필요 신호!
        print("⚠️ 프레임 드롭 발생!")
    }
}

import Vision

func detectFaces(in pixelBuffer: CVPixelBuffer) {
    // 얼굴 감지 요청 생성
    let faceDetectionRequest = VNDetectFaceRectanglesRequest { request, error in
        if let error = error {
            print("얼굴 감지 오류: \(error)")
            return
        }
        
        guard let observations = request.results as? [VNFaceObservation] else {
            return
        }
        
        DispatchQueue.main.async {
            // 감지된 얼굴 수 출력
            print("감지된 얼굴: \(observations.count)개 😊")
            
            // 각 얼굴의 위치 정보 처리
            for face in observations {
                // boundingBox는 0~1 사이 정규화된 좌표
                let boundingBox = face.boundingBox
                print("얼굴 위치: \(boundingBox)")
                
                // 화면 좌표로 변환해서 박스 그리기
                self.drawFaceBox(boundingBox: boundingBox)
            }
        }
    }
    
    // 요청 실행
    let handler = VNImageRequestHandler(
        cvPixelBuffer: pixelBuffer,
        orientation: .up,
        options: [:]
    )
    
    do {
        try handler.perform([faceDetectionRequest])
    } catch {
        print("Vision 요청 실패: \(error)")
    }
}

// 탭 제스처로 포커스 설정
@objc func handleTapToFocus(_ gesture: UITapGestureRecognizer) {
    let tapPoint = gesture.location(in: view)
    
    // 화면 좌표를 카메라 좌표로 변환
    guard let devicePoint = previewLayer?.captureDevicePointConverted(
        fromLayerPoint: tapPoint
    ) else { return }
    
    focusAt(point: devicePoint)
}

func focusAt(point: CGPoint) {
    guard let device = videoDeviceInput?.device else { return }
    
    do {
        try device.lockForConfiguration()
        
        // 포커스 설정
        if device.isFocusPointOfInterestSupported {
            device.focusPointOfInterest = point
            device.focusMode = .autoFocus
        }
        
        // 노출 설정
        if device.isExposurePointOfInterestSupported {
            device.exposurePointOfInterest = point
            device.exposureMode = .autoExpose
        }
        
        // 화이트밸런스 자동 설정
        if device.isWhiteBalanceModeSupported(.autoWhiteBalance) {
            device.whiteBalanceMode = .autoWhiteBalance
        }
        
        device.unlockForConfiguration()
        
    } catch {
        print("카메라 설정 실패: \(error)")
    }
}

// 핀치 줌 구현
@objc func handlePinchZoom(_ gesture: UIPinchGestureRecognizer) {
    guard let device = videoDeviceInput?.device else { return }
    
    let maxZoom = min(device.activeFormat.videoMaxZoomFactor, 10.0)
    let currentZoom = device.videoZoomFactor
    
    if gesture.state == .changed {
        let newZoom = max(1.0, min(currentZoom * gesture.scale, maxZoom))
        
        do {
            try device.lockForConfiguration()
            device.videoZoomFactor = newZoom
            device.unlockForConfiguration()
        } catch {
            print("줌 설정 실패: \(error)")
        }
        
        gesture.scale = 1.0  // 스케일 리셋
    }
}

// 노출 보정값 설정 (-3.0 ~ +3.0 EV)
func setExposureCompensation(_ value: Float) {
    guard let device = videoDeviceInput?.device else { return }
    
    let clampedValue = max(
        device.minExposureTargetBias,
        min(value, device.maxExposureTargetBias)
    )
    
    do {
        try device.lockForConfiguration()
        device.setExposureTargetBias(clampedValue) { _ in
            print("노출 보정 완료: \(clampedValue) EV")
        }
        device.unlockForConfiguration()
    } catch {
        print("노출 설정 실패: \(error)")
    }
}

// 전/후면 카메라 전환
func switchCamera() {
    guard let currentInput = videoDeviceInput else { return }
    
    let currentPosition = currentInput.device.position
    let newPosition: AVCaptureDevice.Position = 
        currentPosition == .back ? .front : .back
    
    guard let newDevice = AVCaptureDevice.default(
        .builtInWideAngleCamera,
        for: .video,
        position: newPosition
    ) else { return }
    
    sessionQueue.async {
        do {
            let newInput = try AVCaptureDeviceInput(device: newDevice)
            
            self.captureSession.beginConfiguration()
            self.captureSession.removeInput(currentInput)
            
            if self.captureSession.canAddInput(newInput) {
                self.captureSession.addInput(newInput)
                self.videoDeviceInput = newInput
            }
            
            self.captureSession.commitConfiguration()
            print("카메라 전환 완료! 🔄")
            
        } catch {
            print("카메라 전환 실패: \(error)")
        }
    }
}

import CoreImage
import MetalKit

class FilterCameraViewController: UIViewController {
    
    // Metal 기반 렌더링 뷰 (성능 최고!)
    private var metalView: MTKView!
    private var ciContext: CIContext!
    private var commandQueue: MTLCommandQueue!
    
    // 현재 적용 중인 필터
    private var currentFilter: CIFilter?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupMetal()
        setupCamera()
    }
    
    private func setupMetal() {
        guard let device = MTLCreateSystemDefaultDevice() else { return }
        
        metalView = MTKView(frame: view.bounds, device: device)
        metalView.framebufferOnly = false
        metalView.isPaused = true
        metalView.enableSetNeedsDisplay = false
        view.insertSubview(metalView, at: 0)
        
        commandQueue = device.makeCommandQueue()
        ciContext = CIContext(mtlDevice: device)
    }
    
    // 필터 적용 및 렌더링
    func renderFilteredImage(_ image: CIImage) {
        guard let drawable = metalView.currentDrawable,
              let commandBuffer = commandQueue.makeCommandBuffer() else { return }
        
        // 필터 적용
        var filteredImage = image
        
        if let filter = currentFilter {
            filter.setValue(image, forKey: kCIInputImageKey)
            filteredImage = filter.outputImage ?? image
        }
        
        // Metal drawable에 렌더링
        let renderDestination = CIRenderDestination(
            width: Int(metalView.drawableSize.width),
            height: Int(metalView.drawableSize.height),
            pixelFormat: metalView.colorPixelFormat,
            commandBuffer: commandBuffer
        ) { () -> MTLTexture in
            return drawable.texture
        }
        
        try? ciContext.startTask(toRender: filteredImage, to: renderDestination)
        
        commandBuffer.present(drawable)
        commandBuffer.commit()
    }
    
    // 필터 변경
    func applyFilter(named filterName: String) {
        currentFilter = CIFilter(name: filterName)
        print("필터 적용: \(filterName) ✨")
    }
}

// 인기 필터 목록 예시
extension FilterCameraViewController {
    
    func applyVintageFilter() {
        // 빈티지 효과 (여러 필터 체이닝)
        let sepia = CIFilter(name: "CISepiaTone")!
        sepia.setValue(0.8, forKey: kCIInputIntensityKey)
        currentFilter = sepia
    }
    
    func applyBlurFilter(radius: Float = 10.0) {
        // 가우시안 블러
        let blur = CIFilter(name: "CIGaussianBlur")!
        blur.setValue(radius, forKey: kCIInputRadiusKey)
        currentFilter = blur
    }
    
    func applyColorInvertFilter() {
        // 색상 반전
        currentFilter = CIFilter(name: "CIColorInvert")
    }
    
    func applyVignetteFilter() {
        // 비네팅 효과
        let vignette = CIFilter(name: "CIVignette")!
        vignette.setValue(1.5, forKey: kCIInputIntensityKey)
        vignette.setValue(1.0, forKey: kCIInputRadiusKey)
        currentFilter = vignette
    }
}

import AVFoundation

func trimVideo(
    inputURL: URL,
    startTime: Double,
    endTime: Double,
    completion: @escaping (URL?) -> Void
) {
    let asset = AVAsset(url: inputURL)
    
    // 내보내기 세션 생성
    guard let exportSession = AVAssetExportSession(
        asset: asset,
        presetName: AVAssetExportPresetHighestQuality
    ) else {
        completion(nil)
        return
    }
    
    // 출력 파일 경로
    let outputURL = URL(fileURLWithPath: NSTemporaryDirectory())
        .appendingPathComponent("\(UUID().uuidString).mp4")
    
    // 트리밍 범위 설정
    let startCMTime = CMTime(seconds: startTime, preferredTimescale: 600)
    let endCMTime = CMTime(seconds: endTime, preferredTimescale: 600)
    let timeRange = CMTimeRange(start: startCMTime, end: endCMTime)
    
    exportSession.outputURL = outputURL
    exportSession.outputFileType = .mp4
    exportSession.timeRange = timeRange
    
    // 내보내기 실행
    exportSession.exportAsynchronously {
        switch exportSession.status {
        case .completed:
            print("트리밍 완료! ✂️")
            completion(outputURL)
        case .failed:
            print("트리밍 실패: \(exportSession.error?.localizedDescription ?? "")")
            completion(nil)
        case .cancelled:
            print("트리밍 취소됨")
            completion(nil)
        default:
            break
        }
    }
}

// 비디오 합치기 (Composition)
func mergeVideos(
    urls: [URL],
    completion: @escaping (URL?) -> Void
) {
    let composition = AVMutableComposition()
    
    guard let videoTrack = composition.addMutableTrack(
        withMediaType: .video,
        preferredTrackID: kCMPersistentTrackID_Invalid
    ),
    let audioTrack = composition.addMutableTrack(
        withMediaType: .audio,
        preferredTrackID: kCMPersistentTrackID_Invalid
    ) else { return }
    
    var currentTime = CMTime.zero
    
    for url in urls {
        let asset = AVAsset(url: url)
        let duration = asset.duration
        let timeRange = CMTimeRange(start: .zero, duration: duration)
        
        do {
            // 비디오 트랙 추가
            if let assetVideoTrack = asset.tracks(withMediaType: .video).first {
                try videoTrack.insertTimeRange(
                    timeRange,
                    of: assetVideoTrack,
                    at: currentTime
                )
            }
            
            // 오디오 트랙 추가
            if let assetAudioTrack = asset.tracks(withMediaType: .audio).first {
                try audioTrack.insertTimeRange(
                    timeRange,
                    of: assetAudioTrack,
                    at: currentTime
                )
            }
            
            currentTime = CMTimeAdd(currentTime, duration)
            
        } catch {
            print("트랙 추가 실패: \(error)")
        }
    }
    
    // 합쳐진 비디오 내보내기
    let outputURL = URL(fileURLWithPath: NSTemporaryDirectory())
        .appendingPathComponent("\(UUID().uuidString).mp4")
    
    guard let exportSession = AVAssetExportSession(
        asset: composition,
        presetName: AVAssetExportPresetHighestQuality
    ) else { return }
    
    exportSession.outputURL = outputURL
    exportSession.outputFileType = .mp4
    
    exportSession.exportAsynchronously {
        if exportSession.status == .completed {
            print("비디오 합치기 완료! 🎬")
            completion(outputURL)
        } else {
            completion(nil)
        }
    }
}

// iOS 16+ Cinematic Mode 지원 확인
if #available(iOS 16.0, *) {
    // 시네마틱 모드 지원 여부 확인
    let cinematicFormats = videoDevice.formats.filter { format in
        format.isCinematicVideoCaptureSupported
    }
    
    if !cinematicFormats.isEmpty {
        print("시네마틱 모드 지원! 🎬")
        
        // 시네마틱 포맷 설정
        if let cinematicFormat = cinematicFormats.last {
            try? videoDevice.lockForConfiguration()
            videoDevice.activeFormat = cinematicFormat
            videoDevice.unlockForConfiguration()
        }
    }
}

// iOS 17+ Deferred Photo Delivery
if #available(iOS 17.0, *) {
    if photoOutput.isAutoDeferredPhotoDeliverySupported {
        photoOutput.isAutoDeferredPhotoDeliveryEnabled = true
        print("지연 사진 전달 활성화! 📸")
    }
}

// 이미지 회전 문제 해결
extension UIImage {
    func fixedOrientation() -> UIImage {
        if imageOrientation == .up { return self }
        
        UIGraphicsBeginImageContextWithOptions(size, false, scale)
        draw(in: CGRect(origin: .zero, size: size))
        let normalizedImage = UIGraphicsGetImageFromCurrentImageContext()!
        UIGraphicsEndImageContext()
        
        return normalizedImage
    }
}

// 사용 예시
func photoOutput(
    _ output: AVCapturePhotoOutput,
    didFinishProcessingPhoto photo: AVCapturePhoto,
    error: Error?
) {
    guard let imageData = photo.fileDataRepresentation(),
          let image = UIImage(data: imageData) else { return }
    
    // 회전 보정 후 사용
    let fixedImage = image.fixedOrientation()
    
    DispatchQueue.main.async {
        self.imageView.image = fixedImage
    }
}

// 메모리 효율적인 프레임 처리 패턴
func captureOutput(
    _ output: AVCaptureOutput,
    didOutput sampleBuffer: CMSampleBuffer,
    from connection: AVCaptureConnection
) {
    // autorelease pool로 메모리 즉시 해제
    autoreleasepool {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        
        // 프레임 처리 로직
        processFrame(pixelBuffer)
        
        // pixelBuffer는 이 블록 끝에서 자동 해제
    }
}

// 세션 프리셋 선택 가이드
func selectSessionPreset(for purpose: String) -> AVCaptureSession.Preset {
    switch purpose {
    case "photo":
        return .photo          // 최고 화질 사진
    case "video_4k":
        return .hd4K3840x2160  // 4K 비디오 (iPhone 6s+)
    case "video_1080p":
        return .hd1920x1080    // 1080p 비디오
    case "video_720p":
        return .hd1280x720     // 720p 비디오
    case "realtime":
        return .medium         // 실시간 처리용 (낮은 해상도)
    default:
        return .high
    }
}