🎨 Core Image

import CoreImage
import UIKit

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

    // 1. 세피아 필터
    func applySepia(to image: UIImage, intensity: Double = 0.8) -> UIImage? {
        guard let ciImage = CIImage(image: image) else { return nil }

        // 필터 생성
        guard let filter = CIFilter(name: "CISepiaTone") else { return nil }

        // 입력 이미지 설정
        filter.setValue(ciImage, forKey: kCIInputImageKey)

        // 필터 파라미터 설정
        filter.setValue(intensity, forKey: kCIInputIntensityKey)

        // 결과 이미지 가져오기
        guard let outputImage = filter.outputImage else { return nil }

        // CIImage → CGImage → UIImage
        guard let cgImage = context.createCGImage(outputImage, from: outputImage.extent) else {
            return nil
        }

        return UIImage(cgImage: cgImage)
    }

    // 2. 블러 필터
    func applyBlur(to image: UIImage, radius: Double = 10.0) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIGaussianBlur") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)
        filter.setValue(radius, forKey: kCIInputRadiusKey)

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

        return UIImage(cgImage: cgImage)
    }

    // 3. 밝기/대비 조정
    func adjustBrightnessContrast(
        image: UIImage,
        brightness: Double = 0.0,
        contrast: Double = 1.0
    ) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIColorControls") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)
        filter.setValue(brightness, forKey: kCIInputBrightnessKey)
        filter.setValue(contrast, forKey: kCIInputContrastKey)

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

        return UIImage(cgImage: cgImage)
    }

    // 4. 비네팅 효과
    func applyVignette(to image: UIImage, intensity: Double = 1.0) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIVignetteEffect") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)
        filter.setValue(intensity, forKey: kCIInputIntensityKey)
        filter.setValue(2.0, forKey: "inputRadius")

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

        return UIImage(cgImage: cgImage)
    }
}

import CoreImage

extension ImageFilterManager {
    // 1. 흑백 필터
    func applyMonochrome(to image: UIImage) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIPhotoEffectNoir") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)

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

        return UIImage(cgImage: cgImage)
    }

    // 2. 비비드 필터 (채도 증가)
    func applyVivid(to image: UIImage) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIColorControls") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)
        filter.setValue(1.5, forKey: kCIInputSaturationKey)

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

        return UIImage(cgImage: cgImage)
    }

    // 3. 픽셀화
    func applyPixelate(to image: UIImage, scale: Double = 8.0) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIPixellate") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)
        filter.setValue(scale, forKey: kCIInputScaleKey)

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

        return UIImage(cgImage: cgImage)
    }

    // 4. 엣지 감지
    func applyEdgeDetection(to image: UIImage) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIEdges") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)
        filter.setValue(1.0, forKey: kCIInputIntensityKey)

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

        return UIImage(cgImage: cgImage)
    }

    // 5. 만화 효과
    func applyComicEffect(to image: UIImage) -> UIImage? {
        guard let ciImage = CIImage(image: image),
              let filter = CIFilter(name: "CIComicEffect") else { return nil }

        filter.setValue(ciImage, forKey: kCIInputImageKey)

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

        return UIImage(cgImage: cgImage)
    }
}

import CoreImage

extension ImageFilterManager {
    // 여러 필터를 순차적으로 적용
    func applyFilterChain(to image: UIImage) -> UIImage? {
        guard var ciImage = CIImage(image: image) else { return nil }

        // 1. 밝기 증가
        if let brightnessFilter = CIFilter(name: "CIColorControls") {
            brightnessFilter.setValue(ciImage, forKey: kCIInputImageKey)
            brightnessFilter.setValue(0.2, forKey: kCIInputBrightnessKey)
            if let output = brightnessFilter.outputImage {
                ciImage = output
            }
        }

        // 2. 채도 증가
        if let saturationFilter = CIFilter(name: "CIColorControls") {
            saturationFilter.setValue(ciImage, forKey: kCIInputImageKey)
            saturationFilter.setValue(1.3, forKey: kCIInputSaturationKey)
            if let output = saturationFilter.outputImage {
                ciImage = output
            }
        }

        // 3. 비네팅 추가
        if let vignetteFilter = CIFilter(name: "CIVignetteEffect") {
            vignetteFilter.setValue(ciImage, forKey: kCIInputImageKey)
            vignetteFilter.setValue(1.5, forKey: kCIInputIntensityKey)
            if let output = vignetteFilter.outputImage {
                ciImage = output
            }
        }

        // 최종 이미지 반환
        guard let cgImage = context.createCGImage(ciImage, from: ciImage.extent) else {
            return nil
        }

        return UIImage(cgImage: cgImage)
    }

    // 인스타그램 스타일 필터
    func applyInstagramStyle(to image: UIImage) -> UIImage? {
        guard var ciImage = CIImage(image: image) else { return nil }

        // 밝기 조정
        if let filter = CIFilter(name: "CIColorControls") {
            filter.setValue(ciImage, forKey: kCIInputImageKey)
            filter.setValue(0.1, forKey: kCIInputBrightnessKey)
            filter.setValue(1.1, forKey: kCIInputContrastKey)
            filter.setValue(1.2, forKey: kCIInputSaturationKey)
            if let output = filter.outputImage {
                ciImage = output
            }
        }

        // 온도 조정 (따뜻한 톤)
        if let filter = CIFilter(name: "CITemperatureAndTint") {
            filter.setValue(ciImage, forKey: kCIInputImageKey)
            filter.setValue(CIVector(x: 6500, y: 0), forKey: "inputNeutral")
            filter.setValue(CIVector(x: 6800, y: 100), forKey: "inputTargetNeutral")
            if let output = filter.outputImage {
                ciImage = output
            }
        }

        guard let cgImage = context.createCGImage(ciImage, from: ciImage.extent) else {
            return nil
        }

        return UIImage(cgImage: cgImage)
    }
}

import CoreImage

extension ImageFilterManager {
    // 얼굴 감지
    func detectFaces(in image: UIImage) -> [CIFeature] {
        guard let ciImage = CIImage(image: image) else { return [] }

        // 얼굴 감지기 생성
        let detector = CIDetector(
            ofType: CIDetectorTypeFace,
            context: context,
            options: [
                CIDetectorAccuracy: CIDetectorAccuracyHigh,
                CIDetectorSmile: true,
                CIDetectorEyeBlink: true
            ]
        )

        // 얼굴 감지
        let features = detector?.features(in: ciImage) ?? []

        // 얼굴 정보 출력
        for feature in features {
            if let faceFeature = feature as? CIFaceFeature {
                print("얼굴 위치: \(faceFeature.bounds)")

                if faceFeature.hasSmile {
                    print("웃고 있음")
                }

                if faceFeature.leftEyeClosed {
                    print("왼쪽 눈 감음")
                }

                if faceFeature.rightEyeClosed {
                    print("오른쪽 눈 감음")
                }
            }
        }

        return features
    }

    // 얼굴에 블러 처리
    func blurFaces(in image: UIImage) -> UIImage? {
        guard let ciImage = CIImage(image: image) else { return nil }

        let faces = detectFaces(in: image)
        var outputImage = ciImage

        for feature in faces {
            guard let faceFeature = feature as? CIFaceFeature else { continue }

            // 얼굴 영역 추출
            let faceBounds = faceFeature.bounds
            let faceImage = ciImage.cropped(to: faceBounds)

            // 블러 적용
            if let blurFilter = CIFilter(name: "CIGaussianBlur") {
                blurFilter.setValue(faceImage, forKey: kCIInputImageKey)
                blurFilter.setValue(20.0, forKey: kCIInputRadiusKey)

                if let blurredFace = blurFilter.outputImage {
                    // 블러된 얼굴을 원본에 합성
                    outputImage = blurredFace.composited(over: outputImage)
                }
            }
        }

        guard let cgImage = context.createCGImage(outputImage, from: ciImage.extent) else {
            return nil
        }

        return UIImage(cgImage: cgImage)
    }
}

import SwiftUI
import PhotosUI

struct FilterDemoView: View {
    @State private var selectedImage: UIImage?
    @State private var filteredImage: UIImage?
    @State private var selectedFilter: FilterType = .original
    @State private var isProcessing = false

    let filterManager = ImageFilterManager()

    enum FilterType: String, CaseIterable {
        case original = "원본"
        case sepia = "세피아"
        case monochrome = "흑백"
        case blur = "블러"
        case vivid = "비비드"
        case vignette = "비네팅"
    }

    var body: some View {
        VStack {
            // 이미지 표시
            if let displayImage = filteredImage ?? selectedImage {
                Image(uiImage: displayImage)
                    .resizable()
                    .scaledToFit()
                    .frame(maxHeight: 400)
            } else {
                ContentUnavailableView(
                    "이미지를 선택하세요",
                    systemImage: "photo"
                )
            }

            // 필터 선택
            ScrollView(.horizontal) {
                HStack(spacing: 15) {
                    ForEach(FilterType.allCases, id: \.self) { filter in
                        Button {
                            selectedFilter = filter
                            applyFilter(filter)
                        } label: {
                            Text(filter.rawValue)
                                .padding(8)
                                .background(
                                    selectedFilter == filter ? Color.blue : Color.gray.opacity(0.2)
                                )
                                .foregroundStyle(selectedFilter == filter ? .white : .primary)
                                .cornerRadius(8)
                        }
                    }
                }
                .padding()
            }

            // 사진 선택
            PhotosPicker(selection: .constant(nil),
                         matching: .images) {
                Label("사진 선택", systemImage: "photo.on.rectangle")
            }
            .buttonStyle(.borderedProminent)
            .padding()

            if isProcessing {
                ProgressView("필터 적용 중...")
            }
        }
    }

    func applyFilter(_ filter: FilterType) {
        guard let image = selectedImage else { return }

        isProcessing = true

        Task {
            let result: UIImage?

            switch filter {
            case .original:
                result = image
            case .sepia:
                result = filterManager.applySepia(to: image)
            case .monochrome:
                result = filterManager.applyMonochrome(to: image)
            case .blur:
                result = filterManager.applyBlur(to: image)
            case .vivid:
                result = filterManager.applyVivid(to: image)
            case .vignette:
                result = filterManager.applyVignette(to: image)
            }

            await MainActor.run {
                filteredImage = result
                isProcessing = false
            }
        }
    }
}