🖼️ ExtensibleImage

import UIKit
import ExtensibleImage
import CoreImage

@Observable
class ExtensibleImageManager {
    var currentImage: EIImage?

    // 새 이미지 생성
    func createNewImage(size: CGSize) {
        // 빈 캔버스 생성
        currentImage = EIImage(
            size: size,
            colorSpace: CGColorSpace(name: CGColorSpace.sRGB)!
        )
    }

    // UIImage에서 생성
    func createFromUIImage(_ uiImage: UIImage) {
        guard let cgImage = uiImage.cgImage else { return }
        currentImage = EIImage(cgImage: cgImage)
    }

    // 파일에서 로드
    func loadImage(from url: URL) throws {
        currentImage = try EIImage(contentsOf: url)
    }

    // 파일로 저장
    func saveImage(to url: URL) throws {
        guard let image = currentImage else { return }
        try image.write(to: url, options: [
            .compressionQuality: 0.9,
            .preserveMetadata: true
        ])
    }

    // UIImage로 변환 (화면 표시용)
    func toUIImage() -> UIImage? {
        guard let image = currentImage else { return nil }
        return UIImage(eiImage: image)
    }
}

import ExtensibleImage

@Observable
class LayerManager {
    var image: EIImage

    init(size: CGSize) {
        self.image = EIImage(
            size: size,
            colorSpace: CGColorSpace(name: CGColorSpace.sRGB)!
        )
    }

    // 새 레이어 추가
    func addLayer(name: String, content: UIImage) {
        guard let cgImage = content.cgImage else { return }

        let layer = EILayer(
            name: name,
            content: cgImage,
            blendMode: .normal,
            opacity: 1.0
        )

        image.addLayer(layer)
    }

    // 텍스트 레이어 추가
    func addTextLayer(text: String, font: UIFont, color: UIColor) {
        // 텍스트를 이미지로 렌더링
        let attributes: [NSAttributedString.Key: Any] = [
            .font: font,
            .foregroundColor: color
        ]

        let textSize = (text as NSString).size(withAttributes: attributes)
        let renderer = UIGraphicsImageRenderer(size: textSize)

        let textImage = renderer.image { context in
            (text as NSString).draw(at: .zero, withAttributes: attributes)
        }

        guard let cgImage = textImage.cgImage else { return }

        let layer = EILayer(
            name: "Text: \(text)",
            content: cgImage,
            blendMode: .normal,
            opacity: 1.0
        )

        image.addLayer(layer)
    }

    // 레이어 불투명도 조정
    func setLayerOpacity(at index: Int, opacity: Float) {
        guard index < image.layers.count else { return }
        image.layers[index].opacity = opacity
    }

    // 레이어 블렌드 모드 변경
    func setLayerBlendMode(at index: Int, mode: CGBlendMode) {
        guard index < image.layers.count else { return }
        image.layers[index].blendMode = mode
    }

    // 레이어 삭제
    func removeLayer(at index: Int) {
        guard index < image.layers.count else { return }
        image.removeLayer(at: index)
    }

    // 레이어 순서 변경
    func moveLayer(from: Int, to: Int) {
        guard from < image.layers.count, to < image.layers.count else { return }
        let layer = image.layers.remove(at: from)
        image.layers.insert(layer, at: to)
    }
}

import CoreImage
import ExtensibleImage

@Observable
class FilterManager {
    private let context = CIContext()

    // 블러 필터 적용
    func applyBlur(to layer: EILayer, radius: Double) -> EILayer {
        let ciImage = CIImage(cgImage: layer.content)

        let filter = CIFilter.gaussianBlur()
        filter.inputImage = ciImage
        filter.radius = Float(radius)

        guard let output = filter.outputImage,
              let cgImage = context.createCGImage(output, from: output.extent) else {
            return layer
        }

        return EILayer(
            name: layer.name,
            content: cgImage,
            blendMode: layer.blendMode,
            opacity: layer.opacity
        )
    }

    // 색상 조정 필터
    func applyColorAdjustment(
        to layer: EILayer,
        brightness: Double = 0,
        contrast: Double = 1,
        saturation: Double = 1
    ) -> EILayer {
        let ciImage = CIImage(cgImage: layer.content)

        let filter = CIFilter.colorControls()
        filter.inputImage = ciImage
        filter.brightness = Float(brightness)
        filter.contrast = Float(contrast)
        filter.saturation = Float(saturation)

        guard let output = filter.outputImage,
              let cgImage = context.createCGImage(output, from: output.extent) else {
            return layer
        }

        return EILayer(
            name: layer.name,
            content: cgImage,
            blendMode: layer.blendMode,
            opacity: layer.opacity
        )
    }

    // 비네트 효과
    func applyVignette(to layer: EILayer, intensity: Double = 1) -> EILayer {
        let ciImage = CIImage(cgImage: layer.content)

        let filter = CIFilter.vignette()
        filter.inputImage = ciImage
        filter.intensity = Float(intensity)

        guard let output = filter.outputImage,
              let cgImage = context.createCGImage(output, from: output.extent) else {
            return layer
        }

        return EILayer(
            name: layer.name,
            content: cgImage,
            blendMode: layer.blendMode,
            opacity: layer.opacity
        )
    }

    // 흑백 변환
    func applyMonochrome(to layer: EILayer) -> EILayer {
        let ciImage = CIImage(cgImage: layer.content)

        let filter = CIFilter.photoEffectMono()
        filter.inputImage = ciImage

        guard let output = filter.outputImage,
              let cgImage = context.createCGImage(output, from: output.extent) else {
            return layer
        }

        return EILayer(
            name: layer.name,
            content: cgImage,
            blendMode: layer.blendMode,
            opacity: layer.opacity
        )
    }
}

import ExtensibleImage
import ImageIO

@Observable
class MetadataManager {
    // 메타데이터 읽기
    func readMetadata(from image: EIImage) -> [String: Any] {
        return image.metadata ?? [:]
    }

    // 메타데이터 추가/수정
    func setMetadata(_ metadata: [String: Any], to image: EIImage) {
        image.metadata = metadata
    }

    // GPS 정보 추가
    func addGPSMetadata(
        to image: EIImage,
        latitude: Double,
        longitude: Double
    ) {
        var metadata = image.metadata ?? [:]

        metadata["GPS"] = [
            kCGImagePropertyGPSLatitude: latitude,
            kCGImagePropertyGPSLongitude: longitude
        ]

        image.metadata = metadata
    }

    // EXIF 정보 추가
    func addEXIFMetadata(
        to image: EIImage,
        aperture: Double,
        exposureTime: Double,
        iso: Int
    ) {
        var metadata = image.metadata ?? [:]

        metadata["EXIF"] = [
            kCGImagePropertyExifApertureValue: aperture,
            kCGImagePropertyExifExposureTime: exposureTime,
            kCGImagePropertyExifISOSpeedRatings: [iso]
        ]

        image.metadata = metadata
    }

    // 커스텀 메타데이터
    func addCustomMetadata(
        to image: EIImage,
        key: String,
        value: Any
    ) {
        var metadata = image.metadata ?? [:]
        metadata[key] = value
        image.metadata = metadata
    }

    // 편집 히스토리 추가
    func addEditHistory(to image: EIImage, edit: String) {
        var metadata = image.metadata ?? [:]
        var history = (metadata["EditHistory"] as? [String]) ?? []

        history.append("\(Date()): \(edit)")
        metadata["EditHistory"] = history

        image.metadata = metadata
    }
}

import ExtensibleImage

struct EditOperation: Codable {
    enum OperationType: String, Codable {
        case brightness, contrast, saturation, blur, crop
    }

    let id: UUID
    let type: OperationType
    let parameters: [String: Double]
    let timestamp: Date
}

@Observable
class NonDestructiveEditor {
    private var originalImage: EIImage
    private var editHistory: [EditOperation] = []
    var currentImage: EIImage

    init(image: EIImage) {
        self.originalImage = image
        self.currentImage = image
    }

    // 편집 적용 (히스토리 저장)
    func applyEdit(_ operation: EditOperation) {
        editHistory.append(operation)
        reapplyAllEdits()
    }

    // 실행 취소
    func undo() {
        guard !editHistory.isEmpty else { return }
        editHistory.removeLast()
        reapplyAllEdits()
    }

    // 원본으로 복원
    func resetToOriginal() {
        editHistory.removeAll()
        currentImage = originalImage
    }

    // 모든 편집 재적용
    private func reapplyAllEdits() {
        currentImage = originalImage

        for operation in editHistory {
            switch operation.type {
            case .brightness:
                if let value = operation.parameters["value"] {
                    applyBrightnessFilter(value: value)
                }
            case .contrast:
                if let value = operation.parameters["value"] {
                    applyContrastFilter(value: value)
                }
            case .saturation:
                if let value = operation.parameters["value"] {
                    applySaturationFilter(value: value)
                }
            case .blur:
                if let radius = operation.parameters["radius"] {
                    applyBlurFilter(radius: radius)
                }
            case .crop:
                // 크롭 로직
                break
            }
        }
    }

    // 필터 적용 헬퍼 메서드
    private func applyBrightnessFilter(value: Double) {
        // Core Image 필터 적용
    }

    private func applyContrastFilter(value: Double) {
        // Core Image 필터 적용
    }

    private func applySaturationFilter(value: Double) {
        // Core Image 필터 적용
    }

    private func applyBlurFilter(radius: Double) {
        // Core Image 필터 적용
    }

    // 편집 히스토리 내보내기
    func exportEditHistory() -> Data? {
        try? JSONEncoder().encode(editHistory)
    }
}

import SwiftUI
import PhotosUI

struct ImageEditorView: View {
    @State private var imageManager = ExtensibleImageManager()
    @State private var layerManager: LayerManager?
    @State private var filterManager = FilterManager()
    @State private var selectedPhoto: PhotosPickerItem?
    @State private var displayImage: UIImage?

    var body: some View {
        NavigationStack {
            VStack {
                if let image = displayImage {
                    Image(uiImage: image)
                        .resizable()
                        .scaledToFit()
                        .frame(maxHeight: 400)
                } else {
                    ContentUnavailableView(
                        "이미지 없음",
                        systemImage: "photo",
                        description: Text("사진을 선택하세요")
                    )
                }

                if let manager = layerManager {
                    List {
                        Section("레이어") {
                            ForEach(manager.image.layers.indices, id: \.self) { index in
                                HStack {
                                    Text(manager.image.layers[index].name)
                                    Spacer()
                                    Text("\(Int(manager.image.layers[index].opacity * 100))%")
                                        .foregroundStyle(.secondary)
                                }
                            }
                        }

                        Section("필터") {
                            Button("블러 효과") {
                                applyBlur()
                            }

                            Button("흑백 변환") {
                                applyMonochrome()
                            }
                        }
                    }
                    .frame(height: 300)
                }
            }
            .navigationTitle("ExtensibleImage")
            .toolbar {
                PhotosPicker(selection: $selectedPhoto, matching: .images) {
                    Label("사진 선택", systemImage: "photo")
                }
            }
            .onChange(of: selectedPhoto) { oldValue, newValue in
                Task {
                    await loadPhoto(newValue)
                }
            }
        }
    }

    private func loadPhoto(_ item: PhotosPickerItem?) async {
        guard let item,
              let data = try? await item.loadTransferable(type: Data.self),
              let uiImage = UIImage(data: data) else { return }

        imageManager.createFromUIImage(uiImage)
        layerManager = LayerManager(size: uiImage.size)
        displayImage = uiImage
    }

    private func applyBlur() {
        guard let manager = layerManager,
              !manager.image.layers.isEmpty else { return }

        let layer = manager.image.layers[0]
        let filtered = filterManager.applyBlur(to: layer, radius: 10)
        manager.image.layers[0] = filtered

        displayImage = imageManager.toUIImage()
    }

    private func applyMonochrome() {
        guard let manager = layerManager,
              !manager.image.layers.isEmpty else { return }

        let layer = manager.image.layers[0]
        let filtered = filterManager.applyMonochrome(to: layer)
        manager.image.layers[0] = filtered

        displayImage = imageManager.toUIImage()
    }
}