Button("All available filters"){
                      print(CIFilter.filterNames(inCategory: nil))
     }

import SwiftUI
import CoreImage

struct ContentView: View {
    var body: some View {
        Button("All available filters"){
            print(CIFilter.filterNames(inCategory: nil))
        }
    }
}

import SwiftUI
import CoreImage
import CoreImage.CIFilterBuiltins

struct ContentView: View {
    @State private var originalImage = UIImage(named: "cat") // Replace with your image name
    @State private var filteredImage: UIImage?
    
    var body: some View {
        VStack {
            if let filteredImage = filteredImage {
                Image(uiImage: filteredImage)
                    .resizable()
                    .scaledToFit()
            } else if let originalImage = originalImage {
                Image(uiImage: originalImage)
                    .resizable()
                    .scaledToFit()
            }

            Button("Apply Sepia Filter") {
                if let originalImage = originalImage {
                    self.filteredImage = applySepiaFilter(to: originalImage)
                }
            }
            .padding()
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
        }
    }
    
    // Function to apply a sepia filter using Core Image
    func applySepiaFilter(to image: UIImage) -> UIImage? {
        let context = CIContext() // Core Image context
        let filter = CIFilter.sepiaTone() // Sepia filter
        filter.intensity = 0.8 // Adjust intensity (0.0 to 1.0)

        guard let ciImage = CIImage(image: image) else { return nil }
        filter.inputImage = ciImage

        // Get the filtered image
        guard let outputImage = filter.outputImage,
              let cgImage = context.createCGImage(outputImage, from: outputImage.extent) else {
            return nil
        }

        return UIImage(cgImage: cgImage)
    }
}

import SwiftUI
import PhotosUI
import CoreImage
import CoreImage.CIFilterBuiltins

struct ContentView: View {
    @State private var selectedItem: PhotosPickerItem?
    @State private var editedImage: UIImage?
    @State private var originalImage: UIImage?  // Store original image
    
    @State private var contrast: Float = 1.0
    @State private var brightness: Float = 0.0
    @State private var saturation: Float = 1.0
    
    let filterTypes: [(String, CIFilter)] = [
        ("Original", CIFilter.colorControls()),  // Use the stored original image
        ("Sepia", CIFilter.sepiaTone()),
        ("Mono", CIFilter.photoEffectMono()),
        ("Noir", CIFilter.photoEffectNoir()),
        ("Bloom", CIFilter.bloom()),
        ("Blur", CIFilter.gaussianBlur())
    ]
    
    var body: some View {
        ScrollView{
            
            HStack(spacing: 30){
                PhotosPicker("Select Image", selection: $selectedItem, matching: .images)
                    .padding()
                if let image = editedImage{
                    Button {
                        UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil)
                    } label: {
                        Label("Save", systemImage: "photo")
                    }
                }
            }
            
            if let image = editedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
                    .frame(height: 250)
                    .border(Color.gray, width: 1)
                
                
                ScrollView(.horizontal, showsIndicators: false) {
                    LazyHStack{
                        ForEach(filterTypes, id: \.0) { filterName, filter in
                            VStack {
                                if let filtered = applyFilter(filter, to: image, isOriginal: filterName == "Original") {
                                    Image(uiImage: filtered)
                                        .resizable()
                                        .scaledToFill()
                                        .frame(width: 80, height: 80)
                                        .clipped()
                                        .border(Color.gray, width: 1)
                                        .onTapGesture {
                                            self.editedImage = filtered
                                        }
                                }
                                Text(filterName).font(.caption)
                            }
                        }
                    }
                }.padding()
                
                VStack {
                    SliderControl(title: "Contrast", value: $contrast, range: 0.5...2.0, onChange: applyAdjustments)
                    SliderControl(title: "Brightness", value: $brightness, range: -1.0...1.0, onChange: applyAdjustments)
                    SliderControl(title: "Saturation", value: $saturation, range: 0.0...2.0, onChange: applyAdjustments)
                }
                .padding()
            }
        }
        .onChange(of: selectedItem) { oldItem, newItem in
            Task {
                if let data = try? await newItem?.loadTransferable(type: Data.self),
                   let image = UIImage(data: data) {
                    self.editedImage = image
                    self.originalImage = image  // Save the original image
                }
            }
            
        }
    }
    func applyFilter(_ filter: CIFilter, to image: UIImage?, isOriginal: Bool = false) -> UIImage? {
        guard let image = image else { return nil }
        let ciImage = CIImage(image: isOriginal ? originalImage ?? image : image)
        let context = CIContext()
        filter.setValue(ciImage, forKey: kCIInputImageKey)
        
        if let outputImage = filter.outputImage,
           let cgImage = context.createCGImage(outputImage, from: outputImage.extent) {
            return UIImage(cgImage: cgImage)
        }
        return nil
    }
    
    func applyAdjustments() {
        if let image = editedImage, let ciImage = CIImage(image: image) {
            let filter = CIFilter.colorControls()
            filter.inputImage = ciImage
            filter.contrast = contrast
            filter.brightness = brightness
            filter.saturation = saturation
            let context = CIContext()
            if let outputImage = filter.outputImage,
               let cgImage = context.createCGImage(outputImage, from: outputImage.extent) {
                self.editedImage = UIImage(cgImage: cgImage)
            }
        }
    }
}


struct SliderControl: View {
    let title: String
    @Binding var value: Float
    let range: ClosedRange<Float>
    let onChange: () -> Void
    
    var body: some View {
        VStack {
            Text("\(title): \(String(format: "%.2f", value))").font(.caption)
            Slider(value: $value, in: range, onEditingChanged: { _ in onChange() })
        }
    }
}