// Example ViewModel Structure
class SkinAnalysisViewModel: ObservableObject {
    @Published var analysisResult: ScanResult?
    @Published var isAnalyzing: Bool = false
    @Published var progressData: [ProgressMetric] = []
    
    private let scanStore: ScanStore
    private let aiAnalyzer: MLAnalyzing
    
    init(scanStore: ScanStore = .shared, 
         aiAnalyzer: MLAnalyzing = GeminiAnalyzer()) {
        self.scanStore = scanStore
        self.aiAnalyzer = aiAnalyzer
    }
    
    @MainActor
    func analyzeSkin(image: UIImage) async {
        isAnalyzing = true
        defer { isAnalyzing = false }
        
        do {
            let result = try await aiAnalyzer.analyze(image: image)
            analysisResult = result
            await scanStore.addScan(result)
        } catch {
            handleError(error)
        }
    }
}

class ScanStore: ObservableObject {
    @Published var scans: [ScanResult] = []
    @Published var metrics: SkinMetrics = SkinMetrics()
    
    private let storage: SkinDataStorage
    
    init(storage: SkinDataStorage = RealmStorage()) {
        self.storage = storage
        loadScans()
    }
    
    func addScan(_ scan: ScanResult) async {
        await MainActor.run {
            scans.append(scan)
            updateMetrics()
        }
        try? await storage.save(scan)
    }
    
    private func updateMetrics() {
        metrics = SkinMetrics(from: scans)
    }
}

struct SkinCareTheme {
    // Colors
    static let primary = Color("SkinCarePrimary")     // #FF6B9D
    static let secondary = Color("SkinCareSecondary") // #4ECDC4
    static let accent = Color("SkinCareAccent")       // #FFE66D
    static let background = Color("Background")        // #F8F9FA
    static let surface = Color("Surface")             // #FFFFFF
    static let text = Color("TextPrimary")            // #2C3E50
    
    // Typography
    static let titleFont = Font.custom("SF Pro Display", size: 28).weight(.bold)
    static let headlineFont = Font.custom("SF Pro Display", size: 20).weight(.semibold)
    static let bodyFont = Font.custom("SF Pro Text", size: 16).weight(.regular)
    static let captionFont = Font.custom("SF Pro Text", size: 14).weight(.light)
    
    // Spacing
    static let padding: CGFloat = 16
    static let cornerRadius: CGFloat = 12
    static let shadowRadius: CGFloat = 8
}

struct GlassMorphCard: View {
    let content: AnyView
    
    var body: some View {
        content
            .padding(.padding)
            .background {
                RoundedRectangle(cornerRadius: .cornerRadius)
                    .fill(.ultraThinMaterial)
                    .shadow(color: .black.opacity(0.1), 
                           radius: .shadowRadius, x: 0, y: 4)
            }
            .overlay {
                RoundedRectangle(cornerRadius: .cornerRadius)
                    .stroke(.white.opacity(0.2), lineWidth: 1)
            }
    }
}

class GeminiAnalyzer: MLAnalyzing {
    private let apiKey: String
    private let session: URLSession
    
    init() {
        guard let apiKey = Bundle.main.infoDictionary?["GEMINI_API_KEY"] as? String else {
            fatalError("Gemini API Key not found")
        }
        self.apiKey = apiKey
        self.session = URLSession(configuration: .default)
    }
    
    func analyze(image: UIImage) async throws -> ScanResult {
        let base64Image = image.jpegData(compressionQuality: 0.8)?.base64EncodedString()
        
        let request = AnalysisRequest(
            image: base64Image,
            analysisType: .comprehensive,
            includeRecommendations: true
        )
        
        return try await performAnalysis(request: request)
    }
}

class CoreMLSkinAnalyzer: MLAnalyzing {
    private let visionModel: VNCoreMLModel
    private let classificationModel: VNCoreMLModel
    
    init() throws {
        let skinAnalysisModel = try SkinAnalysisModel(configuration: .init())
        let classificationMLModel = try SkinClassificationModel(configuration: .init())
        
        self.visionModel = try VNCoreMLModel(for: skinAnalysisModel.model)
        self.classificationModel = try VNCoreMLModel(for: classificationMLModel.model)
    }
    
    func analyze(image: UIImage) async throws -> ScanResult {
        return try await withCheckedThrowingContinuation { continuation in
            analyzeWithVision(image: image) { result in
                continuation.resume(with: result)
            }
        }
    }
}

// Memory optimization example
class ImageCache {
    private let cache = NSCache<NSString, UIImage>()
    
    init() {
        cache.countLimit = 50
        cache.totalCostLimit = 100 * 1024 * 1024 // 100MB
    }
    
    func store(_ image: UIImage, forKey key: String) {
        let cost = image.jpegData(compressionQuality: 0.8)?.count ?? 0
        cache.setObject(image, forKey: key as NSString, cost: cost)
    }
}

class SecureStorage {
    private let keychain = Keychain(service: "com.skincare.ai")
    
    func store(_ data: Data, for key: String) throws {
        try keychain
            .accessibility(.whenUnlockedThisDeviceOnly)
            .set(data, key: key)
    }
    
    func retrieve(for key: String) throws -> Data? {
        return try keychain.getData(key)
    }
}

// Example component structure
struct SkinAnalysisCard: View {
    // MARK: - Properties
    let scanResult: ScanResult
    @State private var isExpanded: Bool = false
    
    // MARK: - Body
    var body: some View {
        GlassMorphCard {
            VStack(alignment: .leading, spacing: 12) {
                headerSection
                if isExpanded {
                    detailSection
                }
            }
        }
        .animation(.spring(response: 0.6, dampingFraction: 0.8), 
                  value: isExpanded)
    }
    
    // MARK: - View Components
    private var headerSection: some View {
        HStack {
            VStack(alignment: .leading) {
                Text("Skin Analysis")
                    .font(.headlineFont)
                Text(scanResult.date.formatted())
                    .font(.captionFont)
                    .foregroundColor(.secondary)
            }
            Spacer()
            Button {
                withAnimation {
                    isExpanded.toggle()
                }
            } label: {
                Image(systemName: "chevron.down")
                    .rotationEffect(.degrees(isExpanded ? 180 : 0))
            }
        }
    }
}

class SkinAnalysisViewModelTests: XCTestCase {
    var viewModel: SkinAnalysisViewModel!
    var mockScanStore: MockScanStore!
    var mockAnalyzer: MockAnalyzer!
    
    override func setUp() {
        super.setUp()
        mockScanStore = MockScanStore()
        mockAnalyzer = MockAnalyzer()
        viewModel = SkinAnalysisViewModel(
            scanStore: mockScanStore,
            aiAnalyzer: mockAnalyzer
        )
    }
    
    func testSuccessfulAnalysis() async throws {
        // Given
        let testImage = UIImage(systemName: "photo")!
        mockAnalyzer.mockResult = ScanResult.sample
        
        // When
        await viewModel.analyzeSkin(image: testImage)
        
        // Then
        XCTAssertEqual(viewModel.analysisResult, ScanResult.sample)
        XCTAssertFalse(viewModel.isAnalyzing)
        XCTAssertEqual(mockScanStore.addScanCallCount, 1)
    }
}

// Configuration.plist structure
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>GEMINI_API_KEY</key>
    <string>$(GEMINI_API_KEY)</string>
    <key>ENVIRONMENT</key>
    <string>$(ENVIRONMENT)</string>
    <key>APP_VERSION</key>
    <string>$(MARKETING_VERSION)</string>
</dict>
</plist>