Core Image RAW 9 Processing

import SwiftUI
import CoreImage
import CoreImage.CIFilterBuiltins
import MetalKit

// MARK: - ViewModel
@MainActor
final class RAWEditorViewModel: ObservableObject {
    @Published var exposure: Float = 0.0
    @Published var sharpness: Float = 0.5
    @Published var renderedImage: CGImage?

    private var rawFilter: CIRAWFilter?
    private let context: CIContext

    init() {
        // One context per view, caching enabled for interactive editing
        let device = MTLCreateSystemDefaultDevice()!
        context = CIContext(
            mtlDevice: device,
            options: [
                .cacheIntermediates: true
            ]
        )
    }

    func loadRAW(url: URL) {
        guard let filter = CIRAWFilter(imageURL: url) else {
            print("Failed to create CIRAWFilter for \(url.lastPathComponent)")
            return
        }

        // Check RAW 9 support for this file's camera model
        if let versions = filter.supportedDecoderVersions,
           versions.contains(.version9) {
            filter.decoderVersion = .version9
            print("RAW 9 enabled")
        } else {
            print("RAW 9 not available for this camera model, using default")
        }

        // Scale down for screen resolution — critical for performance
        filter.scaleFactor = 0.25
        rawFilter = filter
        render()
    }

    func render() {
        guard let filter = rawFilter else { return }

        filter.exposure = exposure
        filter.sharpnessAmount = sharpness
        // colorNoiseReductionAmount has no effect in RAW 9 — omit it

        guard let output = filter.outputImage else { return }

        renderedImage = context.createCGImage(
            output,
            from: output.extent
        )
    }

    func queryRAW9Cameras() {
        let models = CIRAWFilter.supportedCameraModels(for: .version9)
        print("RAW 9 supports \(models.count) camera models")
        models.prefix(5).forEach { print(" •", $0) }
    }
}

// MARK: - View
struct RAWEditorView: View {
    @StateObject private var vm = RAWEditorViewModel()
    @State private var showingPicker = false

    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                if let cgImage = vm.renderedImage {
                    Image(cgImage, scale: 1.0, label: Text("RAW Preview"))
                        .resizable()
                        .scaledToFit()
                        .cornerRadius(12)
                        .padding()
                } else {
                    ContentUnavailableView(
                        "No RAW File",
                        systemImage: "photo.badge.plus",
                        description: Text("Tap Open to load a RAW image")
                    )
                }

                GroupBox("RAW 9 Controls") {
                    VStack {
                        LabeledContent("Exposure") {
                            Slider(value: $vm.exposure, in: -3...3)
                                .onChange(of: vm.exposure) { _, _ in vm.render() }
                        }
                        LabeledContent("Sharpness") {
                            Slider(value: $vm.sharpness, in: 0...1)
                                .onChange(of: vm.sharpness) { _, _ in vm.render() }
                        }
                    }
                }
                .padding(.horizontal)

                Button("Query RAW 9 Camera Support") {
                    vm.queryRAW9Cameras()
                }
                .buttonStyle(.bordered)
            }
            .navigationTitle("RAW 9 Editor")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button("Open") { showingPicker = true }
                }
            }
            .fileImporter(
                isPresented: $showingPicker,
                allowedContentTypes: [.rawImage],
                allowsMultipleSelection: false
            ) { result in
                if case .success(let urls) = result, let url = urls.first {
                    vm.loadRAW(url: url)
                }
            }
        }
    }
}

#Preview {
    RAWEditorView()
}