// Example ViewModel Structure
class DataLoader: ObservableObject {
    @Published var appData: AppData?
    @Published var plants: [Plant] = []
    @Published var categories: [PlantCategory] = []
    @Published var userProfile: UserProfile?
    @Published var errorMessage: String?
    
    init() {
        loadData()
        loadUserPreferences()
        loadMyJungleExtendedData()
    }
    
    func toggleJungle(plant: Plant) {
        guard var profile = userProfile else { return }
        // Add/remove plant from user's collection
    }
    
    func waterPlant(plantId: String) {
        // Update watering history and schedule
    }
}

class DataLoader: ObservableObject {
    // MARK: - Published Properties
    @Published var plants: [Plant] = []
    @Published var userProfile: UserProfile?
    
    // MARK: - Data Persistence
    private func saveMyJungleData() {
        guard let profile = userProfile else { return }
        if let encoded = try? JSONEncoder().encode(profile.myJungle) {
            UserDefaults.standard.set(encoded, forKey: "myJungleExtendedData")
        }
    }
    
    func loadMyJungleExtendedData() {
        // Load extended data from UserDefaults
        // Merge with JSON data
    }
}

struct PlantTheme {
    // Colors
    static let primary = Color.green
    static let secondary = Color(hex: "4ECDC4")
    static let accent = Color(hex: "E8F5E9")
    static let background = Color(hex: "F2F7F2")
    static let surface = Color.white
    static let danger = Color.red
    static let warning = Color.orange
    static let success = Color.green
    
    // Typography
    static let largeTitle = Font.largeTitle.weight(.bold)
    static let title = Font.title.weight(.bold)
    static let headline = Font.headline.weight(.semibold)
    static let body = Font.body.weight(.regular)
    static let caption = Font.caption.weight(.light)
    
    // Spacing
    static let padding: CGFloat = 16
    static let cornerRadius: CGFloat = 12
    static let shadowRadius: CGFloat = 8
}

struct EnhancedPlantCard: View {
    let plant: Plant
    @EnvironmentObject var dataLoader: DataLoader
    @State private var showCareSheet = false
    
    var wateringStatus: (text: String, color: Color, icon: String) {
        guard let myPlant = myPlant else {
            return ("Unknown", .gray, "drop.fill")
        }
        
        if let daysUntil = dataLoader.daysUntilWatering(myPlant: myPlant) {
            if daysUntil < 0 {
                return ("Overdue!", .red, "exclamationmark.triangle.fill")
            } else if daysUntil == 0 {
                return ("Water today", .orange, "drop.fill")
            } else if daysUntil <= 2 {
                return ("In \(daysUntil)d", .blue, "drop.fill")
            } else {
                return ("\(daysUntil) days", .green, "checkmark.circle.fill")
            }
        } else {
            return ("Not set", .gray, "drop.fill")
        }
    }
}

// UserDefaults for User Preferences
UserDefaults.standard.set(username, forKey: "username")
UserDefaults.standard.set(city, forKey: "city")
UserDefaults.standard.set(true, forKey: "hasCompletedOnboarding")

// Codable for Complex Data
if let encoded = try? JSONEncoder().encode(profile.myJungle) {
    UserDefaults.standard.set(encoded, forKey: "myJungleExtendedData")
}

// Bundle for Static Data
guard let url = Bundle.main.url(forResource: "jason", withExtension: "json") else {
    return
}
let data = try Data(contentsOf: url)
let appData = try JSONDecoder().decode(AppData.self, from: data)

// MARK: - Core Models
struct Plant: Codable, Identifiable {
    let id: String
    let commonName: String
    let botanicalName: String
    let categoryId: String
    let origin: Origin
    let images: PlantImages
    let description: String
    let careGuide: CareGuide
    let toxicity: Toxicity
    let propagation: Propagation?
    let skincarePotential: SkincarePotential?
}

struct MyPlant: Codable, Identifiable {
    var id: String { plantId }
    let plantId: String
    var nickname: String
    var dateAcquired: String
    var lastWatered: String
    var wateringHistory: [String]?
    var nextWateringDate: String?
    var healthScore: Int?
    var notes: String?
    var locationInHome: String?
    var customWateringFrequencyDays: Int?
}

struct UserProfile: Codable {
    let userId: String
    var username: String
    var locationSettings: LocationSettings
    var preferences: Preferences
    var favorites: [String]
    var myJungle: [MyPlant]
}

func waterPlant(plantId: String) {
    guard var profile = userProfile,
          let plantIndex = profile.myJungle.firstIndex(where: { $0.plantId == plantId }),
          let plant = plants.first(where: { $0.id == plantId }) else { return }
    
    let now = Date()
    let dateString = ISO8601DateFormatter().string(from: now)
    
    // Update watering history
    var history = profile.myJungle[plantIndex].wateringHistory ?? []
    history.append(dateString)
    profile.myJungle[plantIndex].wateringHistory = history
    
    // Calculate next watering date
    let frequencyDays = profile.myJungle[plantIndex].customWateringFrequencyDays 
                        ?? getWateringFrequency(for: plant)
    let nextDate = Calendar.current.date(byAdding: .day, value: frequencyDays, to: now)!
    profile.myJungle[plantIndex].nextWateringDate = ISO8601DateFormatter().string(from: nextDate)
    
    saveMyJungleData()
}

private func getWateringFrequency(for plant: Plant) -> Int {
    let waterReq = plant.careGuide.water.lowercased()
    
    if waterReq.contains("daily") { return 1 }
    else if waterReq.contains("twice a week") { return 3 }
    else if waterReq.contains("week") { return 7 }
    else if waterReq.contains("every 2 weeks") { return 14 }
    else if waterReq.contains("month") { return 30 }
    else { return 7 } // Default to weekly
}

// Efficient filtering with computed property
var myPlants: [Plant] {
    guard let profile = dataLoader.userProfile else { return [] }
    let myPlantIds = profile.myJungle.map { $0.plantId }
    var plants = dataLoader.plants.filter { myPlantIds.contains($0.id) }
    
    // Apply filters
    if !searchText.isEmpty {
        plants = plants.filter { /* search logic */ }
    }
    
    // Apply sorting once
    return plants.sorted { /* sort logic */ }
}

// Avoid unnecessary re-renders
struct PlantCard: View {
    let plant: Plant // Not @State unless it changes
    
    var body: some View {
        // UI code
    }
}

// User data stored locally
// No sensitive information transmitted
// Passwords not required
// Optional cloud sync with user consent

class SecureStorage {
    // For sensitive settings (if needed in future)
    static func saveSecure(_ value: String, key: String) {
        let data = Data(value.utf8)
        UserDefaults.standard.set(data, forKey: key)
    }
}

// MARK: - Use clear section markers
// MARK: - Properties

// Use descriptive variable names
var wateringFrequencyInDays: Int
var lastWateredDate: Date

// Document complex logic
/// Calculates the next watering date based on plant type and pot size
/// - Parameters:
///   - plant: The plant to calculate for
///   - lastWatered: The last watering date
/// - Returns: The recommended next watering date
func calculateNextWateringDate(plant: Plant, lastWatered: Date) -> Date {
    // Implementation
}

// Use SwiftUI best practices
struct MyView: View {
    // Properties first
    let title: String
    @State private var isExpanded = false
    
    // Body
    var body: some View {
        // UI code
    }
    
    // Computed properties
    private var subtitle: String {
        // Logic
    }
    
    // View builders
    @ViewBuilder
    private var headerView: some View {
        // UI code
    }
}

// DataLoader Public API
class DataLoader: ObservableObject {
    // Properties
    @Published var plants: [Plant]
    @Published var userProfile: UserProfile?
    
    // Plant Management
    func toggleJungle(plant: Plant)
    func removePlants(plantIds: [String])
    
    // Watering
    func waterPlant(plantId: String)
    func waterAllPlants()
    func needsWatering(myPlant: MyPlant) -> Bool
    func daysUntilWatering(myPlant: MyPlant) -> Int?
    
    // Health & Care
    func updatePlantHealth(plantId: String, healthScore: Int)
    func updatePlantNotes(plantId: String, notes: String)
    func updatePlantLocation(plantId: String, location: String)
    func updatePlantNickname(plantId: String, nickname: String)
}

// Test data loading performance
func testDataLoadingPerformance() {
    measure {
        let loader = DataLoader()
        // Should complete in < 500ms
    }
}

// Test filtering performance
func testFilteringPerformance() {
    let loader = DataLoader()
    measure {
        let filtered = loader.plants.filter { $0.categoryId == "cat_aroid" }
        // Should complete in < 100ms
    }
}

// Info.plist essential keys
<key>CFBundleDisplayName</key>
<string>HousePlants</string>
<key>CFBundleVersion</key>
<string>2.2.0</string>
<key>NSCameraUsageDescription</key>
<string>We need camera access for AR plant placement and light measurement</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>We use your location to provide local plant recommendations</string>