🔍 Visual Intelligence

import SwiftUI
import AVFoundation

// Visual Intelligence 서비스 관리자
@Observable
class VisualIntelligenceManager {
    var isAuthorized = false
    var isAnalyzing = false
    var currentResult: AnalysisResult?

    // 카메라 권한 요청
    func requestAuthorization() async -> Bool {
        let status = await AVCaptureDevice.requestAccess(for: .video)
        await MainActor.run {
            isAuthorized = status
        }
        return status
    }

    // Visual Intelligence 지원 확인
    func isSupported() -> Bool {
        // iOS 18+ 및 Camera Control 지원 기기
        if #available(iOS 18.0, *) {
            return true
        }
        return false
    }
}

// 분석 결과 타입
struct AnalysisResult: Identifiable {
    let id = UUID()
    let type: AnalysisType
    let data: Any
    let timestamp = Date()
}

enum AnalysisType {
    case objectDetection
    case textExtraction
    case placeRecognition
    case productSearch
    case barcodeScanning
}

import SwiftUI
import Vision

struct ObjectDetectionView: View {
    @State private var manager = VisualIntelligenceManager()
    @State private var detectedObjects: [DetectedObject] = []
    @State private var showCamera = false

    var body: some View {
        VStack(spacing: 20) {
            // 카메라 프리뷰
            ZStack {
                Rectangle()
                    .fill(Color.black)
                    .aspectRatio(3/4, contentMode: .fit)
                    .cornerRadius(12)

                if manager.isAnalyzing {
                    ProgressView("분석 중...")
                        .tint(.white)
                }

                // 감지된 객체 오버레이
                ForEach(detectedObjects) { obj in
                    Rectangle()
                        .stroke(Color.green, lineWidth: 2)
                        .frame(width: obj.bounds.width, height: obj.bounds.height)
                        .position(x: obj.bounds.midX, y: obj.bounds.midY)
                        .overlay(alignment: .topLeading) {
                            Text(obj.label)
                                .font(.caption)
                                .padding(4)
                                .background(Color.green)
                                .foregroundStyle(.white)
                                .cornerRadius(4)
                                .offset(x: obj.bounds.minX, y: obj.bounds.minY)
                        }
                }
            }

            // 감지된 객체 리스트
            VStack(alignment: .leading, spacing: 12) {
                Text("감지된 객체")
                    .font(.headline)

                if detectedObjects.isEmpty {
                    Text("카메라 버튼을 길게 눌러 스캔을 시작하세요")
                        .font(.subheadline)
                        .foregroundStyle(.secondary)
                } else {
                    ForEach(detectedObjects) { obj in
                        HStack {
                            Image(systemName: obj.icon)
                                .foregroundStyle(.blue)
                            VStack(alignment: .leading) {
                                Text(obj.label)
                                    .font(.subheadline)
                                Text("\(Int(obj.confidence * 100))% 신뢰도")
                                    .font(.caption)
                                    .foregroundStyle(.secondary)
                            }
                            Spacer()
                            Button("검색") {
                                searchObject(obj)
                            }
                            .buttonStyle(.bordered)
                        }
                        .padding()
                        .background(Color.gray.opacity(0.1))
                        .cornerRadius(8)
                    }
                }
            }
            .padding()
        }
        .task {
            await manager.requestAuthorization()
        }
    }

    func searchObject(_ object: DetectedObject) {
        print("🔍 검색: \(object.label)")
    }
}

// 감지된 객체 모델
struct DetectedObject: Identifiable {
    let id = UUID()
    let label: String
    let confidence: Double
    let bounds: CGRect

    var icon: String {
        // 객체 타입에 따라 아이콘 반환
        switch label.lowercased() {
        case let l where l.contains("person"): return "person.fill"
        case let l where l.contains("car"): return "car.fill"
        case let l where l.contains("dog"): return "pawprint.fill"
        case let l where l.contains("cat"): return "cat.fill"
        default: return "cube.fill"
        }
    }
}

import SwiftUI
import Vision

@Observable
class TextExtractionManager {
    var extractedText: [RecognizedText] = []
    var isProcessing = false

    // 텍스트 추출 (Live Text)
    func extractText(from image: UIImage) async {
        await MainActor.run { isProcessing = true }

        guard let cgImage = image.cgImage else { return }

        let request = VNRecognizeTextRequest { request, error in
            guard error == nil,
                  let observations = request.results as? [VNRecognizedTextObservation]
            else { return }

            let recognizedTexts = observations.compactMap { observation in
                guard let topCandidate = observation.topCandidates(1).first else {
                    return nil
                }

                return RecognizedText(
                    text: topCandidate.string,
                    confidence: topCandidate.confidence,
                    bounds: observation.boundingBox
                )
            }

            Task { @MainActor in
                self.extractedText = recognizedTexts
                self.isProcessing = false
            }
        }

        // 정확도 설정
        request.recognitionLevel = .accurate
        request.usesLanguageCorrection = true

        let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
        try? handler.perform([request])
    }
}

struct RecognizedText: Identifiable {
    let id = UUID()
    let text: String
    let confidence: Float
    let bounds: CGRect
}

struct TextExtractionView: View {
    @State private var manager = TextExtractionManager()
    @State private var selectedImage: UIImage?
    @State private var showImagePicker = false

    var body: some View {
        ScrollView {
            VStack(spacing: 20) {
                // 이미지 선택
                if let selectedImage {
                    Image(uiImage: selectedImage)
                        .resizable()
                        .scaledToFit()
                        .cornerRadius(12)
                } else {
                    Button {
                        showImagePicker = true
                    } label: {
                        VStack {
                            Image(systemName: "photo.badge.plus")
                                .font(.system(size: 50))
                            Text("이미지 선택")
                        }
                        .frame(height: 200)
                        .frame(maxWidth: .infinity)
                        .background(Color.gray.opacity(0.1))
                        .cornerRadius(12)
                    }
                }

                // 추출된 텍스트
                if manager.isProcessing {
                    ProgressView("텍스트 추출 중...")
                        .padding()
                } else if !manager.extractedText.isEmpty {
                    VStack(alignment: .leading, spacing: 12) {
                        Text("추출된 텍스트")
                            .font(.headline)

                        ForEach(manager.extractedText) { item in
                            HStack {
                                Text(item.text)
                                    .textSelection(.enabled)

                                Spacer()

                                Menu {
                                    Button {
                                        copyText(item.text)
                                    } label: {
                                        Label("복사", systemImage: "doc.on.doc")
                                    }

                                    Button {
                                        translateText(item.text)
                                    } label: {
                                        Label("번역", systemImage: "translate")
                                    }

                                    Button {
                                        searchText(item.text)
                                    } label: {
                                        Label("검색", systemImage: "magnifyingglass")
                                    }
                                } label: {
                                    Image(systemName: "ellipsis.circle")
                                }
                            }
                            .padding()
                            .background(Color.gray.opacity(0.1))
                            .cornerRadius(8)
                        }
                    }
                }
            }
            .padding()
        }
        .onChange(of: selectedImage) { _, newImage in
            if let newImage {
                Task {
                    await manager.extractText(from: newImage)
                }
            }
        }
    }

    func copyText(_ text: String) {
        UIPasteboard.general.string = text
    }

    func translateText(_ text: String) {
        print("🌐 번역: \(text)")
    }

    func searchText(_ text: String) {
        print("🔍 검색: \(text)")
    }
}

import SwiftUI
import CoreLocation
import MapKit

struct RecognizedPlace: Identifiable {
    let id = UUID()
    let name: String
    let category: String
    let address: String
    let coordinate: CLLocationCoordinate2D
    let rating: Double?
    let photoURL: URL?
}

@Observable
class PlaceRecognitionManager {
    var recognizedPlace: RecognizedPlace?
    var isRecognizing = false

    // 장소 인식
    func recognizePlace(from image: UIImage, location: CLLocation?) async {
        isRecognizing = true

        // 실제로는 Vision + Maps API 사용
        try? await Task.sleep(for: .seconds(1))

        // 예시 데이터
        recognizedPlace = RecognizedPlace(
            name: "애플 파크",
            category: "랜드마크",
            address: "One Apple Park Way, Cupertino, CA",
            coordinate: CLLocationCoordinate2D(latitude: 37.3349, longitude: -122.0090),
            rating: 4.8,
            photoURL: nil
        )

        isRecognizing = false
    }
}

struct PlaceRecognitionView: View {
    @State private var manager = PlaceRecognitionManager()
    @State private var cameraPosition: MapCameraPosition = .automatic

    var body: some View {
        VStack(spacing: 20) {
            // 카메라 뷰 (실제로는 AVCaptureSession)
            Rectangle()
                .fill(Color.black)
                .aspectRatio(3/4, contentMode: .fit)
                .cornerRadius(12)
                .overlay {
                    if manager.isRecognizing {
                        ProgressView("장소 인식 중...")
                            .tint(.white)
                    }
                }

            // 인식된 장소 정보
            if let place = manager.recognizedPlace {
                VStack(alignment: .leading, spacing: 16) {
                    // 장소 정보
                    VStack(alignment: .leading, spacing: 8) {
                        HStack {
                            Text(place.name)
                                .font(.title2)
                                .fontWeight(.bold)

                            Spacer()

                            if let rating = place.rating {
                                HStack(spacing: 4) {
                                    Image(systemName: "star.fill")
                                        .foregroundStyle(.yellow)
                                    Text("\(rating, specifier: "%.1f")")
                                        .fontWeight(.semibold)
                                }
                            }
                        }

                        Text(place.category)
                            .font(.subheadline)
                            .foregroundStyle(.secondary)

                        Label(place.address, systemImage: "mappin.circle")
                            .font(.footnote)
                    }
                    .padding()
                    .background(Color.gray.opacity(0.1))
                    .cornerRadius(12)

                    // 지도
                    Map(position: $cameraPosition) {
                        Marker(place.name, coordinate: place.coordinate)
                    }
                    .frame(height: 200)
                    .cornerRadius(12)

                    // 액션 버튼
                    HStack(spacing: 12) {
                        Button {
                            openInMaps(place)
                        } label: {
                            Label("지도에서 보기", systemImage: "map")
                                .frame(maxWidth: .infinity)
                        }
                        .buttonStyle(.borderedProminent)

                        Button {
                            sharePlace(place)
                        } label: {
                            Label("공유", systemImage: "square.and.arrow.up")
                                .frame(maxWidth: .infinity)
                        }
                        .buttonStyle(.bordered)
                    }
                }
                .padding(.horizontal)
            }

            Spacer()
        }
        .padding(.vertical)
    }

    func openInMaps(_ place: RecognizedPlace) {
        let mapItem = MKMapItem(
            placemark: MKPlacemark(coordinate: place.coordinate)
        )
        mapItem.name = place.name
        mapItem.openInMaps()
    }

    func sharePlace(_ place: RecognizedPlace) {
        print("📤 \(place.name) 공유")
    }
}

import SwiftUI

struct Product: Identifiable {
    let id = UUID()
    let name: String
    let price: Decimal
    let brand: String
    let imageURL: URL?
    let productURL: URL
    let similarity: Double // 유사도 0-1
}

@Observable
class ProductSearchManager {
    var searchResults: [Product] = []
    var isSearching = false

    // 시각적 유사 제품 검색
    func searchSimilarProducts(from image: UIImage) async {
        isSearching = true

        // 실제로는 Vision + 쇼핑 API 연동
        try? await Task.sleep(for: .seconds(1.5))

        // 예시 결과
        searchResults = [
            Product(
                name: "나이키 에어 맥스",
                price: 189000,
                brand: "Nike",
                imageURL: nil,
                productURL: URL(string: "https://nike.com")!,
                similarity: 0.95
            ),
            Product(
                name: "아디다스 울트라부스트",
                price: 219000,
                brand: "Adidas",
                imageURL: nil,
                productURL: URL(string: "https://adidas.com")!,
                similarity: 0.87
            )
        ]

        isSearching = false
    }
}

struct ProductSearchView: View {
    @State private var manager = ProductSearchManager()
    @State private var selectedImage: UIImage?

    var body: some View {
        ScrollView {
            VStack(spacing: 20) {
                // 스캔한 제품 이미지
                if let selectedImage {
                    Image(uiImage: selectedImage)
                        .resizable()
                        .scaledToFit()
                        .frame(height: 200)
                        .cornerRadius(12)
                }

                // 검색 중
                if manager.isSearching {
                    VStack(spacing: 12) {
                        ProgressView()
                        Text("유사 제품 검색 중...")
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                    }
                    .padding()
                }

                // 검색 결과
                if !manager.searchResults.isEmpty {
                    VStack(alignment: .leading, spacing: 16) {
                        Text("유사 제품 \(manager.searchResults.count)개")
                            .font(.headline)

                        ForEach(manager.searchResults) { product in
                            ProductRow(product: product)
                        }
                    }
                }
            }
            .padding()
        }
    }
}

struct ProductRow: View {
    let product: Product

    var body: some View {
        HStack(spacing: 12) {
            // 제품 이미지
            RoundedRectangle(cornerRadius: 8)
                .fill(Color.gray.opacity(0.2))
                .frame(width: 80, height: 80)
                .overlay {
                    Image(systemName: "shoeprint.fill")
                        .font(.title)
                        .foregroundStyle(.secondary)
                }

            // 제품 정보
            VStack(alignment: .leading, spacing: 4) {
                Text(product.brand)
                    .font(.caption)
                    .foregroundStyle(.secondary)

                Text(product.name)
                    .font(.subheadline)
                    .fontWeight(.medium)

                Text("\(product.price as NSDecimalNumber)원")
                    .font(.subheadline)
                    .fontWeight(.bold)

                // 유사도
                HStack(spacing: 4) {
                    Image(systemName: "checkmark.circle.fill")
                        .font(.caption)
                        .foregroundStyle(.green)
                    Text("\(Int(product.similarity * 100))% 일치")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }

            Spacer()

            // 바로가기
            Button {
                UIApplication.shared.open(product.productURL)
            } label: {
                Image(systemName: "arrow.right.circle.fill")
                    .font(.title2)
                    .foregroundStyle(.blue)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.05))
        .cornerRadius(12)
    }
}

import SwiftUI

// Camera Control 제스처 핸들링
@Observable
class CameraControlManager {
    var isPressed = false
    var pressStartTime: Date?

    // 길게 누르기 감지
    func handleLongPress() {
        isPressed = true
        pressStartTime = Date()

        // Visual Intelligence 활성화
        activateVisualIntelligence()
    }

    // 버튼 놓기
    func handleRelease() {
        guard let startTime = pressStartTime else { return }

        let duration = Date().timeIntervalSince(startTime)

        if duration > 0.5 {
            // 긴 누르기: 화면 캡처 및 분석
            captureAndAnalyze()
        }

        isPressed = false
        pressStartTime = nil
    }

    func activateVisualIntelligence() {
        print("📸 Visual Intelligence 활성화")
    }

    func captureAndAnalyze() {
        print("🔍 화면 캡처 및 분석 시작")
    }
}

struct CameraControlDemoView: View {
    @State private var manager = CameraControlManager()

    var body: some View {
        VStack {
            Text("Camera Control 버튼을 길게 누르세요")
                .font(.headline)
                .padding()

            // 시뮬레이션용 버튼
            Button {
                manager.handleLongPress()

                Task {
                    try? await Task.sleep(for: .seconds(1))
                    manager.handleRelease()
                }
            } label: {
                Circle()
                    .fill(manager.isPressed ? Color.blue : Color.gray)
                    .frame(width: 80, height: 80)
                    .overlay {
                        Image(systemName: "camera.fill")
                            .font(.title)
                            .foregroundStyle(.white)
                    }
            }
        }
    }
}