Center Stage Front Camera (iPhone 17)

import AVFoundation
import SwiftUI
import Combine

// MARK: - Camera Manager

@Observable
final class CenterStageCameraManager: NSObject {
    private let session = AVCaptureSession()
    private var device: AVCaptureDevice?
    private var smartFramingObservation: NSKeyValueObservation?

    var previewLayer: AVCaptureVideoPreviewLayer?
    var currentAspectRatio: AVCaptureDevice.AspectRatio = .init(width: 4, height: 3)

    func configure() throws {
        // 1. Find the Center Stage ultra-wide front camera
        let discovery = AVCaptureDevice.DiscoverySession(
            deviceTypes: [.builtInUltraWideCamera],
            mediaType: .video,
            position: .front
        )
        guard let ultraWideFront = discovery.devices.first else {
            throw CameraError.deviceNotFound
        }
        self.device = ultraWideFront

        // 2. Find a format supporting dynamic aspect ratio (4032 for smart framing)
        guard let format = ultraWideFront.formats.first(where: { format in
            format.supportedDynamicAspectRatios.contains(
                AVCaptureDevice.AspectRatio(width: 4, height: 3)
            ) && format.isSmartFramingSupported
        }) else {
            throw CameraError.formatNotFound
        }

        // 3. Configure the device
        try ultraWideFront.lockForConfiguration()
        ultraWideFront.activeFormat = format
        ultraWideFront.dynamicAspectRatio = AVCaptureDevice.AspectRatio(width: 4, height: 3)
        ultraWideFront.unlockForConfiguration()

        // 4. Build the capture session
        session.beginConfiguration()
        let input = try AVCaptureDeviceInput(device: ultraWideFront)
        if session.canAddInput(input) { session.addInput(input) }
        let photoOutput = AVCapturePhotoOutput()
        if session.canAddOutput(photoOutput) { session.addOutput(photoOutput) }
        session.commitConfiguration()

        // 5. Preview layer
        let layer = AVCaptureVideoPreviewLayer(session: session)
        layer.videoGravity = .resizeAspectFill
        self.previewLayer = layer

        // 6. Start smart framing monitor
        startSmartFramingMonitor(on: ultraWideFront)

        session.startRunning()
    }

    private func startSmartFramingMonitor(on device: AVCaptureDevice) {
        let monitor = device.smartFramingMonitor
        // Enable all supported framings (aspect ratios + zoom levels)
        monitor.enabledFramings = monitor.supportedFramings
        monitor.startMonitoring()

        // KVO observe the recommended framing
        smartFramingObservation = monitor.observe(
            \.recommendedFraming,
            options: [.new]
        ) { [weak self, weak device] _, change in
            guard let self, let device,
                  let recommendation = change.newValue as? AVCaptureSmartFramingMonitor.Framing
            else { return }
            self.applyRecommendation(recommendation, to: device)
        }
    }

    private func applyRecommendation(
        _ framing: AVCaptureSmartFramingMonitor.Framing,
        to device: AVCaptureDevice
    ) {
        do {
            try device.lockForConfiguration()
            // Apply aspect ratio first, then zoom for smooth transition
            device.dynamicAspectRatio = framing.aspectRatio
            device.videoZoomFactor = framing.zoomFactor
            device.unlockForConfiguration()
            currentAspectRatio = framing.aspectRatio
        } catch {
            print("Failed to apply framing recommendation: \(error)")
        }
    }

    func stopMonitoring() {
        smartFramingObservation?.invalidate()
        smartFramingObservation = nil
        device?.smartFramingMonitor.stopMonitoring()
    }

    enum CameraError: Error {
        case deviceNotFound
        case formatNotFound
    }
}

// MARK: - SwiftUI Preview Wrapper

struct CameraPreviewView: UIViewRepresentable {
    let previewLayer: AVCaptureVideoPreviewLayer

    func makeUIView(context: Context) -> UIView {
        let view = UIView()
        view.layer.addSublayer(previewLayer)
        return view
    }

    func updateUIView(_ uiView: UIView, context: Context) {
        previewLayer.frame = uiView.bounds
    }
}

// MARK: - Content View

struct CenterStageDemoView: View {
    @State private var camera = CenterStageCameraManager()
    @State private var errorMessage: String?

    var body: some View {
        ZStack {
            if let layer = camera.previewLayer {
                CameraPreviewView(previewLayer: layer)
                    .ignoresSafeArea()
            }
            VStack {
                Spacer()
                Text("Auto-Framing Active")
                    .font(.caption)
                    .padding(8)
                    .background(.ultraThinMaterial, in: Capsule())
                    .padding(.bottom, 40)
            }
        }
        .task {
            do {
                try camera.configure()
            } catch {
                errorMessage = error.localizedDescription
            }
        }
        .onDisappear { camera.stopMonitoring() }
        .alert("Camera Error", isPresented: .constant(errorMessage != nil)) {
            Button("OK") { errorMessage = nil }
        } message: {
            Text(errorMessage ?? "")
        }
    }
}