Technical Design: Household Planner

+-------------+       +---------------------+       +-----------------+
|   Recipe    |<----->| RecipeIngredient   |------>| Inventory Item  |
+-------------+  1:N  | (junction)         |  N:1  | (via matching)  |
      |               +---------------------+       +-----------------+
      |
      | 1:N
      v
+-------------+       +---------------------+
|  MealSlot   |<----->| ConsumptionLog     |
+-------------+  1:N  +---------------------+
      |                       |
      |                       v
      |               +---------------------+
      |               | HouseholdRatio      |
      |               | (learned patterns)  |
      |               +---------------------+
      v
+-------------+
|  DietGoal   |  (influences MealSlot suggestions)
+-------------+

// Migration v5 -> v6
val MIGRATION_5_6 = object : Migration(5, 6) {
    override fun migrate(database: SupportSQLiteDatabase) {
        // Recipes table
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS recipes (
                id TEXT PRIMARY KEY NOT NULL,
                name TEXT NOT NULL,
                description TEXT,
                imageUri TEXT,
                category TEXT NOT NULL,
                cuisine TEXT,
                tags TEXT,
                prepTimeMinutes INTEGER,
                cookTimeMinutes INTEGER,
                servings INTEGER NOT NULL DEFAULT 1,
                difficulty TEXT,
                isFavorite INTEGER NOT NULL DEFAULT 0,
                useCount INTEGER NOT NULL DEFAULT 0,
                lastUsedAt INTEGER,
                createdAt INTEGER NOT NULL,
                updatedAt INTEGER NOT NULL
            )
        """)

        // Recipe ingredients junction table
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS recipe_ingredients (
                recipeId TEXT NOT NULL,
                ingredientKey TEXT NOT NULL,
                displayName TEXT NOT NULL,
                quantity REAL NOT NULL,
                unit TEXT NOT NULL,
                isOptional INTEGER NOT NULL DEFAULT 0,
                substitutes TEXT,
                notes TEXT,
                PRIMARY KEY(recipeId, ingredientKey),
                FOREIGN KEY(recipeId) REFERENCES recipes(id) ON DELETE CASCADE
            )
        """)
        database.execSQL("CREATE INDEX idx_recipe_ingredients_recipe ON recipe_ingredients(recipeId)")

        // Meal slots table
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS meal_slots (
                id TEXT PRIMARY KEY NOT NULL,
                date INTEGER NOT NULL,
                mealType TEXT NOT NULL,
                recipeId TEXT,
                customMealName TEXT,
                servings INTEGER NOT NULL DEFAULT 1,
                status TEXT NOT NULL DEFAULT 'PLANNED',
                preparedAt INTEGER,
                notes TEXT,
                FOREIGN KEY(recipeId) REFERENCES recipes(id) ON DELETE SET NULL
            )
        """)
        database.execSQL("CREATE INDEX idx_meal_slots_recipe ON meal_slots(recipeId)")
        database.execSQL("CREATE INDEX idx_meal_slots_date ON meal_slots(date)")

        // Consumption logs
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS consumption_logs (
                id TEXT PRIMARY KEY NOT NULL,
                mealSlotId TEXT NOT NULL,
                ingredientKey TEXT NOT NULL,
                recipeQuantity REAL NOT NULL,
                recipeUnit TEXT NOT NULL,
                actualQuantity REAL,
                actualUnit TEXT,
                consumedItemIds TEXT,
                consumedAt INTEGER NOT NULL,
                FOREIGN KEY(mealSlotId) REFERENCES meal_slots(id) ON DELETE CASCADE
            )
        """)
        database.execSQL("CREATE INDEX idx_consumption_logs_meal ON consumption_logs(mealSlotId)")
        database.execSQL("CREATE INDEX idx_consumption_logs_ingredient ON consumption_logs(ingredientKey)")

        // Household consumption ratios
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS household_consumption_ratios (
                ingredientKey TEXT NOT NULL,
                recipeId TEXT,
                ratioMultiplier REAL NOT NULL DEFAULT 1.0,
                confidence REAL NOT NULL DEFAULT 0.0,
                sampleCount INTEGER NOT NULL DEFAULT 0,
                lastUpdatedAt INTEGER NOT NULL,
                PRIMARY KEY(ingredientKey, recipeId)
            )
        """)

        // Diet goals
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS diet_goals (
                id TEXT PRIMARY KEY NOT NULL,
                goalType TEXT NOT NULL,
                targetValue REAL,
                targetUnit TEXT,
                preferredCategories TEXT,
                excludedIngredients TEXT,
                preferredCuisines TEXT,
                frequencyType TEXT,
                frequencyTarget INTEGER,
                isActive INTEGER NOT NULL DEFAULT 1,
                createdAt INTEGER NOT NULL
            )
        """)
    }
}

object IngredientMatcher {

    /**
     * Finds inventory items that match a recipe ingredient.
     *
     * Matching strategy (in order of priority):
     * 1. Exact canonical name match
     * 2. Template-based match (if ingredient maps to a template)
     * 3. Fuzzy name matching with category filter
     */
    fun findMatches(
        ingredientKey: String,
        inventory: List<GroceryItem>,
        templates: List<ItemTemplate>
    ): MatchResult {

        // Normalize the ingredient key
        val normalized = normalize(ingredientKey)

        // 1. Try exact match on item names
        val exactMatches = inventory.filter {
            normalize(it.name).contains(normalized) ||
            normalized.contains(normalize(it.name))
        }

        if (exactMatches.isNotEmpty()) {
            return MatchResult.Found(
                matches = exactMatches,
                confidence = 0.95f
            )
        }

        // 2. Try template-based matching
        val template = templates.find {
            normalize(it.canonicalName) == normalized
        }

        if (template != null) {
            val templateMatches = inventory.filter {
                normalize(it.name).contains(normalize(template.canonicalName))
            }
            if (templateMatches.isNotEmpty()) {
                return MatchResult.Found(
                    matches = templateMatches,
                    confidence = 0.85f
                )
            }
        }

        // 3. Fuzzy matching with Levenshtein distance
        val fuzzyMatches = inventory
            .map { item -> item to levenshteinSimilarity(normalized, normalize(item.name)) }
            .filter { (_, similarity) -> similarity > 0.6f }
            .sortedByDescending { (_, similarity) -> similarity }
            .map { (item, _) -> item }

        return if (fuzzyMatches.isNotEmpty()) {
            MatchResult.Fuzzy(
                matches = fuzzyMatches,
                confidence = 0.6f
            )
        } else {
            MatchResult.NotFound(ingredientKey)
        }
    }

    private fun normalize(text: String): String {
        return text
            .lowercase()
            .trim()
            .replace(Regex("[^a-z0-9\\s]"), "")
            .replace(Regex("\\s+"), " ")
    }

    sealed class MatchResult {
        data class Found(
            val matches: List<GroceryItem>,
            val confidence: Float
        ) : MatchResult()

        data class Fuzzy(
            val matches: List<GroceryItem>,
            val confidence: Float
        ) : MatchResult()

        data class NotFound(val ingredientKey: String) : MatchResult()
    }
}

@Entity(tableName = "ingredient_aliases")
data class IngredientAliasEntity(
    @PrimaryKey
    val alias: String,                 // "curd", "dahi"
    val canonicalKey: String           // "yogurt"
)

// Pre-seeded aliases
val STARTER_ALIASES = listOf(
    "curd" to "yogurt",
    "dahi" to "yogurt",
    "atta" to "flour",
    "maida" to "refined_flour",
    "besan" to "gram_flour",
    "dal" to "lentils",
    "paneer" to "cottage_cheese",
    "ghee" to "clarified_butter"
)

+------------------------------------------+
|  ← Recipes                    [+] [🔍]   |
+------------------------------------------+
|                                          |
|  [All] [Breakfast] [Lunch] [Dinner] [+]  |
|                                          |
|  --- Favorites ---                       |
|                                          |
|  +------------------------------------+  |
|  | 🍝 Tomato Pasta              ⭐   |  |
|  | Italian • 30 min • 4 servings     |  |
|  | Last made: 3 days ago             |  |
|  +------------------------------------+  |
|                                          |
|  +------------------------------------+  |
|  | 🍛 Dal Tadka                 ⭐   |  |
|  | Indian • 25 min • 4 servings      |  |
|  | Last made: 1 week ago             |  |
|  +------------------------------------+  |
|                                          |
|  --- All Recipes (12) ---                |
|                                          |
|  +------------------------------------+  |
|  | 🥗 Greek Salad                    |  |
|  | Mediterranean • 15 min • 2 srv    |  |
|  +------------------------------------+  |
|                                          |
|  ... (more recipes)                      |
|                                          |
+------------------------------------------+

+------------------------------------------+
|  ← Tomato Pasta                [⭐] [✏️] |
+------------------------------------------+
|                                          |
|  +------------------------------------+  |
|  |                                    |  |
|  |        [Recipe Photo]              |  |
|  |                                    |  |
|  +------------------------------------+  |
|                                          |
|  Italian • Dinner • Easy                 |
|  ⏱️ 10 min prep • 20 min cook           |
|  🍽️ 4 servings                          |
|                                          |
|  --- Ingredients ---                     |
|                                          |
|  • Pasta 400g                       [✓]  |
|  • Tomatoes 500g                    [!]  |
|  • Garlic 4 cloves                  [✓]  |
|  • Olive Oil 2 tbsp                 [✓]  |
|  • Basil leaves (optional)          [?]  |
|                                          |
|  ✓ = In stock  ! = Low/Missing  ? = N/A  |
|                                          |
|  --- Description ---                     |
|                                          |
|  Classic Italian pasta with fresh        |
|  tomato sauce and aromatic basil.        |
|                                          |
|  [Add to Menu]        [Mark as Made]     |
|                                          |
+------------------------------------------+

@HiltViewModel
class RecipeViewModel @Inject constructor(
    private val recipeRepository: RecipeRepository,
    private val ingredientMatcher: IngredientMatcher,
    private val itemRepository: ItemRepository
) : ViewModel() {

    private val _recipes = MutableStateFlow<List<Recipe>>(emptyList())
    val recipes: StateFlow<List<Recipe>> = _recipes.asStateFlow()

    private val _selectedRecipe = MutableStateFlow<RecipeWithIngredients?>(null)
    val selectedRecipe: StateFlow<RecipeWithIngredients?> = _selectedRecipe.asStateFlow()

    private val _ingredientStatus = MutableStateFlow<Map<String, IngredientStatus>>(emptyMap())
    val ingredientStatus: StateFlow<Map<String, IngredientStatus>> = _ingredientStatus.asStateFlow()

    fun loadRecipes(category: RecipeCategory? = null) {
        viewModelScope.launch {
            recipeRepository.getRecipes(category)
                .collect { _recipes.value = it }
        }
    }

    fun selectRecipe(recipeId: String) {
        viewModelScope.launch {
            val recipe = recipeRepository.getRecipeWithIngredients(recipeId)
            _selectedRecipe.value = recipe

            // Check ingredient availability
            val inventory = itemRepository.getAllGroceryItems().first()
            val statuses = recipe.ingredients.associate { ingredient ->
                ingredient.ingredientKey to checkIngredientStatus(ingredient, inventory)
            }
            _ingredientStatus.value = statuses
        }
    }

    private fun checkIngredientStatus(
        ingredient: RecipeIngredient,
        inventory: List<GroceryItem>
    ): IngredientStatus {
        val match = ingredientMatcher.findMatches(
            ingredient.ingredientKey,
            inventory,
            emptyList() // templates
        )

        return when (match) {
            is MatchResult.Found -> {
                val totalQty = match.matches.sumOf { it.quantity }
                if (totalQty >= ingredient.quantity) {
                    IngredientStatus.InStock(totalQty, ingredient.unit)
                } else {
                    IngredientStatus.Low(totalQty, ingredient.quantity, ingredient.unit)
                }
            }
            is MatchResult.Fuzzy -> IngredientStatus.MaybeInStock(match.matches)
            is MatchResult.NotFound -> {
                if (ingredient.isOptional) IngredientStatus.Optional
                else IngredientStatus.Missing
            }
        }
    }

    fun createRecipe(
        name: String,
        category: RecipeCategory,
        ingredients: List<RecipeIngredient>,
        prepTime: Int?,
        cookTime: Int?,
        servings: Int,
        description: String?
    ) {
        viewModelScope.launch {
            recipeRepository.createRecipe(
                Recipe(
                    id = UUID.randomUUID().toString(),
                    name = name,
                    category = category,
                    ingredients = ingredients,
                    prepTimeMinutes = prepTime,
                    cookTimeMinutes = cookTime,
                    servings = servings,
                    description = description,
                    createdAt = Date(),
                    updatedAt = Date()
                )
            )
        }
    }

    sealed class IngredientStatus {
        data class InStock(val available: Double, val unit: String) : IngredientStatus()
        data class Low(val available: Double, val required: Double, val unit: String) : IngredientStatus()
        data class MaybeInStock(val possibleMatches: List<GroceryItem>) : IngredientStatus()
        object Missing : IngredientStatus()
        object Optional : IngredientStatus()
    }
}

+------------------------------------------+
|  ← Menu Planner              [< Week >]  |
+------------------------------------------+
|  Jan 20 - Jan 26, 2026                   |
+------------------------------------------+
|                                          |
|  MON 20                                  |
|  +--------+ +--------+ +--------+        |
|  |Breakfast| |  Lunch | | Dinner |       |
|  |         | |        | |        |       |
|  | Oatmeal | | (empty)| | Pasta  |       |
|  |   ✓     | |  [+]   | |   !    |       |
|  +--------+ +--------+ +--------+        |
|                                          |
|  TUE 21                                  |
|  +--------+ +--------+ +--------+        |
|  |Breakfast| |  Lunch | | Dinner |       |
|  |         | |        | |        |       |
|  |  Toast  | | Salad  | | Curry  |       |
|  |   ✓     | |   ✓    | |   ✓    |       |
|  +--------+ +--------+ +--------+        |
|                                          |
|  ... (remaining days)                    |
|                                          |
+------------------------------------------+
|  Stock Health: 85% ready                 |
|  [View Shopping List]                    |
+------------------------------------------+

Legend:
✓ = All ingredients in stock
! = Some ingredients low/missing
(empty) = No meal planned

+------------------------------------------+
|  Monday Lunch                        [X] |
+------------------------------------------+
|                                          |
|  --- Quick Picks ---                     |
|  (Based on history & ingredients)        |
|                                          |
|  [Greek Salad ✓] [Sandwich ✓]            |
|  [Fried Rice !]                          |
|                                          |
|  --- Or Choose Recipe ---                |
|                                          |
|  🔍 [Search recipes____________]         |
|                                          |
|  [Breakfast] [Lunch] [Dinner] [All]      |
|                                          |
|  • Greek Salad (15 min)             [+]  |
|  • Pasta Salad (20 min)             [+]  |
|  • Veggie Wrap (10 min)             [+]  |
|                                          |
|  --- Or Custom ---                       |
|                                          |
|  [Type meal name...] (no recipe)         |
|                                          |
|  Servings: [2]                           |
|                                          |
|  [Cancel]                     [Confirm]  |
+------------------------------------------+

@HiltViewModel
class MenuViewModel @Inject constructor(
    private val mealSlotRepository: MealSlotRepository,
    private val recipeRepository: RecipeRepository,
    private val stockHealthChecker: StockHealthChecker,
    private val menuSuggestionEngine: MenuSuggestionEngine
) : ViewModel() {

    private val _currentWeekStart = MutableStateFlow(getStartOfWeek(Date()))
    val currentWeekStart: StateFlow<Date> = _currentWeekStart.asStateFlow()

    private val _weekMenu = MutableStateFlow<WeekMenu>(WeekMenu.empty())
    val weekMenu: StateFlow<WeekMenu> = _weekMenu.asStateFlow()

    private val _stockHealth = MutableStateFlow<StockHealth>(StockHealth.empty())
    val stockHealth: StateFlow<StockHealth> = _stockHealth.asStateFlow()

    private val _suggestions = MutableStateFlow<List<RecipeSuggestion>>(emptyList())
    val suggestions: StateFlow<List<RecipeSuggestion>> = _suggestions.asStateFlow()

    init {
        loadCurrentWeek()
    }

    fun loadCurrentWeek() {
        viewModelScope.launch {
            val weekStart = currentWeekStart.value
            val weekEnd = addDays(weekStart, 6)

            mealSlotRepository.getMealSlotsForRange(weekStart, weekEnd)
                .combine(recipeRepository.getAllRecipes()) { slots, recipes ->
                    buildWeekMenu(slots, recipes)
                }
                .collect { menu ->
                    _weekMenu.value = menu
                    updateStockHealth(menu)
                }
        }
    }

    fun navigateWeek(direction: Int) {
        _currentWeekStart.value = addDays(_currentWeekStart.value, direction * 7)
        loadCurrentWeek()
    }

    fun assignRecipeToSlot(date: Date, mealType: MealType, recipeId: String, servings: Int) {
        viewModelScope.launch {
            mealSlotRepository.assignRecipe(
                date = date,
                mealType = mealType,
                recipeId = recipeId,
                servings = servings
            )
        }
    }

    fun assignCustomMeal(date: Date, mealType: MealType, mealName: String) {
        viewModelScope.launch {
            mealSlotRepository.assignCustomMeal(
                date = date,
                mealType = mealType,
                customName = mealName
            )
        }
    }

    fun clearSlot(slotId: String) {
        viewModelScope.launch {
            mealSlotRepository.clearSlot(slotId)
        }
    }

    fun loadSuggestionsForSlot(date: Date, mealType: MealType) {
        viewModelScope.launch {
            val suggestions = menuSuggestionEngine.getSuggestions(
                date = date,
                mealType = mealType,
                existingMenu = weekMenu.value
            )
            _suggestions.value = suggestions
        }
    }

    private suspend fun updateStockHealth(menu: WeekMenu) {
        val health = stockHealthChecker.checkMenu(menu)
        _stockHealth.value = health
    }
}

data class WeekMenu(
    val weekStart: Date,
    val days: List<DayMenu>
) {
    companion object {
        fun empty() = WeekMenu(Date(), emptyList())
    }
}

data class DayMenu(
    val date: Date,
    val breakfast: MealSlot?,
    val lunch: MealSlot?,
    val dinner: MealSlot?,
    val snacks: List<MealSlot>
)

data class StockHealth(
    val percentageReady: Float,
    val missingIngredients: List<MissingIngredient>,
    val lowIngredients: List<LowIngredient>
) {
    companion object {
        fun empty() = StockHealth(0f, emptyList(), emptyList())
    }
}

data class MissingIngredient(
    val ingredientKey: String,
    val displayName: String,
    val requiredQuantity: Double,
    val unit: String,
    val forRecipes: List<String>
)

class StockHealthChecker @Inject constructor(
    private val itemRepository: ItemRepository,
    private val ingredientMatcher: IngredientMatcher,
    private val consumptionRatioRepository: ConsumptionRatioRepository
) {

    suspend fun checkMenu(menu: WeekMenu): StockHealth {
        // 1. Aggregate all required ingredients across the week
        val requiredIngredients = mutableMapOf<String, IngredientRequirement>()

        menu.days.forEach { day ->
            listOfNotNull(day.breakfast, day.lunch, day.dinner)
                .plus(day.snacks)
                .forEach { slot ->
                    slot.recipe?.ingredients?.forEach { ingredient ->
                        val key = ingredient.ingredientKey
                        val existing = requiredIngredients[key]

                        // Apply household consumption ratio
                        val ratio = consumptionRatioRepository
                            .getRatio(key, slot.recipe?.id)
                            ?.ratioMultiplier ?: 1.0

                        val adjustedQuantity = ingredient.quantity * slot.servings * ratio

                        requiredIngredients[key] = IngredientRequirement(
                            ingredientKey = key,
                            displayName = ingredient.displayName,
                            totalQuantity = (existing?.totalQuantity ?: 0.0) + adjustedQuantity,
                            unit = ingredient.unit,
                            forRecipes = (existing?.forRecipes ?: emptyList()) +
                                         (slot.recipe?.name ?: "Unknown")
                        )
                    }
                }
        }

        // 2. Check inventory for each ingredient
        val inventory = itemRepository.getAllGroceryItems().first()
        val missing = mutableListOf<MissingIngredient>()
        val low = mutableListOf<LowIngredient>()
        var mealsReady = 0
        var totalMeals = 0

        menu.days.forEach { day ->
            listOfNotNull(day.breakfast, day.lunch, day.dinner).forEach { slot ->
                if (slot.recipe != null) {
                    totalMeals++
                    val allInStock = slot.recipe.ingredients.all { ingredient ->
                        val match = ingredientMatcher.findMatches(
                            ingredient.ingredientKey,
                            inventory,
                            emptyList()
                        )
                        match is MatchResult.Found &&
                            match.matches.sumOf { it.quantity } >= ingredient.quantity
                    }
                    if (allInStock) mealsReady++
                }
            }
        }

        requiredIngredients.values.forEach { required ->
            val match = ingredientMatcher.findMatches(
                required.ingredientKey,
                inventory,
                emptyList()
            )

            when (match) {
                is MatchResult.Found -> {
                    val available = match.matches.sumOf { it.quantity }
                    if (available < required.totalQuantity) {
                        low.add(LowIngredient(
                            ingredientKey = required.ingredientKey,
                            displayName = required.displayName,
                            available = available,
                            required = required.totalQuantity,
                            unit = required.unit
                        ))
                    }
                }
                else -> {
                    missing.add(MissingIngredient(
                        ingredientKey = required.ingredientKey,
                        displayName = required.displayName,
                        requiredQuantity = required.totalQuantity,
                        unit = required.unit,
                        forRecipes = required.forRecipes
                    ))
                }
            }
        }

        return StockHealth(
            percentageReady = if (totalMeals > 0) mealsReady.toFloat() / totalMeals else 1f,
            missingIngredients = missing,
            lowIngredients = low
        )
    }
}

User marks meal as "Prepared"
         │
         ▼
   Recipe ingredients listed
         │
         ▼
   Auto-match to inventory items
         │
         ▼
   User can adjust quantities
   (optional, for learning)
         │
         ▼
   Deduct from inventory
         │
         ▼
   Log consumption with ratio
         │
         ▼
   Update household ratio
   (if user provided actual qty)

class ConsumptionTracker @Inject constructor(
    private val itemRepository: ItemRepository,
    private val ingredientMatcher: IngredientMatcher,
    private val consumptionLogRepository: ConsumptionLogRepository,
    private val ratioRepository: ConsumptionRatioRepository
) {

    /**
     * Process a meal slot being marked as prepared.
     * Deducts ingredients from inventory and logs consumption.
     */
    suspend fun processMealPrepared(
        mealSlot: MealSlot,
        actualQuantities: Map<String, Double>? = null  // User-provided overrides
    ): ConsumptionResult {
        val recipe = mealSlot.recipe ?: return ConsumptionResult.NoRecipe
        val inventory = itemRepository.getAllGroceryItems().first()
        val consumptionLogs = mutableListOf<ConsumptionLog>()
        val errors = mutableListOf<String>()

        recipe.ingredients.forEach { ingredient ->
            // Calculate expected quantity (with household ratio)
            val ratio = ratioRepository.getRatio(ingredient.ingredientKey, recipe.id)
            val expectedQty = ingredient.quantity * mealSlot.servings * (ratio?.ratioMultiplier ?: 1.0)

            // Use actual quantity if provided, otherwise use expected
            val actualQty = actualQuantities?.get(ingredient.ingredientKey) ?: expectedQty

            // Find matching inventory items
            val matches = ingredientMatcher.findMatches(
                ingredient.ingredientKey,
                inventory,
                emptyList()
            )

            when (matches) {
                is MatchResult.Found, is MatchResult.Fuzzy -> {
                    val items = when (matches) {
                        is MatchResult.Found -> matches.matches
                        is MatchResult.Fuzzy -> matches.matches
                        else -> emptyList()
                    }

                    // Deduct from inventory (FIFO by expiry date)
                    val (consumedItems, remaining) = deductFromInventory(
                        items.sortedBy { it.expiryDate },
                        actualQty,
                        ingredient.unit
                    )

                    // Log consumption
                    consumptionLogs.add(ConsumptionLog(
                        id = UUID.randomUUID().toString(),
                        mealSlotId = mealSlot.id,
                        ingredientKey = ingredient.ingredientKey,
                        recipeQuantity = expectedQty,
                        recipeUnit = ingredient.unit,
                        actualQuantity = actualQty,
                        actualUnit = ingredient.unit,
                        consumedItemIds = consumedItems.map { it.id },
                        consumedAt = Date()
                    ))

                    // Update household ratio if user provided actual quantity
                    if (actualQuantities?.containsKey(ingredient.ingredientKey) == true) {
                        updateHouseholdRatio(
                            ingredientKey = ingredient.ingredientKey,
                            recipeId = recipe.id,
                            recipeQty = ingredient.quantity * mealSlot.servings,
                            actualQty = actualQty
                        )
                    }
                }
                is MatchResult.NotFound -> {
                    if (!ingredient.isOptional) {
                        errors.add("Could not find ${ingredient.displayName} in inventory")
                    }
                }
            }
        }

        // Persist logs
        consumptionLogRepository.insertAll(consumptionLogs)

        return if (errors.isEmpty()) {
            ConsumptionResult.Success(consumptionLogs)
        } else {
            ConsumptionResult.PartialSuccess(consumptionLogs, errors)
        }
    }

    private suspend fun deductFromInventory(
        items: List<GroceryItem>,
        quantityNeeded: Double,
        unit: String
    ): Pair<List<GroceryItem>, Double> {
        var remaining = quantityNeeded
        val consumed = mutableListOf<GroceryItem>()

        for (item in items) {
            if (remaining <= 0) break

            // TODO: Unit conversion if needed
            val available = item.quantity
            val toDeduct = minOf(available, remaining)

            if (toDeduct >= available) {
                // Item fully consumed - delete it
                itemRepository.deleteItem(item.id)
                consumed.add(item)
            } else {
                // Partial consumption - update quantity
                itemRepository.updateItemQuantity(item.id, available - toDeduct)
                consumed.add(item.copy(quantity = toDeduct))
            }

            remaining -= toDeduct
        }

        return consumed to remaining
    }

    private suspend fun updateHouseholdRatio(
        ingredientKey: String,
        recipeId: String,
        recipeQty: Double,
        actualQty: Double
    ) {
        val newRatio = actualQty / recipeQty
        val existing = ratioRepository.getRatio(ingredientKey, recipeId)

        if (existing != null) {
            // Weighted average with existing ratio
            val newSampleCount = existing.sampleCount + 1
            val weightedRatio = (existing.ratioMultiplier * existing.sampleCount + newRatio) / newSampleCount
            val newConfidence = minOf(1.0f, 0.3f + (newSampleCount * 0.1f))

            ratioRepository.update(existing.copy(
                ratioMultiplier = weightedRatio,
                sampleCount = newSampleCount,
                confidence = newConfidence,
                lastUpdatedAt = Date().time
            ))
        } else {
            ratioRepository.insert(HouseholdConsumptionRatio(
                ingredientKey = ingredientKey,
                recipeId = recipeId,
                ratioMultiplier = newRatio,
                confidence = 0.3f,
                sampleCount = 1,
                lastUpdatedAt = Date().time
            ))
        }
    }

    sealed class ConsumptionResult {
        object NoRecipe : ConsumptionResult()
        data class Success(val logs: List<ConsumptionLog>) : ConsumptionResult()
        data class PartialSuccess(
            val logs: List<ConsumptionLog>,
            val errors: List<String>
        ) : ConsumptionResult()
    }
}

class ShoppingListGenerator @Inject constructor(
    private val stockHealthChecker: StockHealthChecker,
    private val ratioRepository: ConsumptionRatioRepository
) {

    /**
     * Generate a shopping list based on planned menu and current inventory.
     */
    suspend fun generateList(menu: WeekMenu): ShoppingList {
        val health = stockHealthChecker.checkMenu(menu)

        val items = mutableListOf<ShoppingListItem>()

        // Add missing items
        health.missingIngredients.forEach { missing ->
            items.add(ShoppingListItem(
                ingredientKey = missing.ingredientKey,
                displayName = missing.displayName,
                quantity = missing.requiredQuantity,
                unit = missing.unit,
                reason = ShoppingReason.MISSING,
                neededFor = missing.forRecipes
            ))
        }

        // Add low items (need the difference)
        health.lowIngredients.forEach { low ->
            items.add(ShoppingListItem(
                ingredientKey = low.ingredientKey,
                displayName = low.displayName,
                quantity = low.required - low.available,
                unit = low.unit,
                reason = ShoppingReason.LOW,
                neededFor = emptyList()
            ))
        }

        return ShoppingList(
            generatedAt = Date(),
            forWeekStart = menu.weekStart,
            items = items.sortedBy { it.displayName }
        )
    }
}

data class ShoppingList(
    val generatedAt: Date,
    val forWeekStart: Date,
    val items: List<ShoppingListItem>
)

data class ShoppingListItem(
    val ingredientKey: String,
    val displayName: String,
    val quantity: Double,
    val unit: String,
    val reason: ShoppingReason,
    val neededFor: List<String>,
    var isPurchased: Boolean = false
)

enum class ShoppingReason {
    MISSING,
    LOW,
    EXPIRING_SOON  // Future: proactive replacement
}

+------------------------------------------+
|  ← Shopping List            [Share] [✓]  |
+------------------------------------------+
|  For week of Jan 20 - 26                 |
+------------------------------------------+
|                                          |
|  --- Need to Buy (8 items) ---           |
|                                          |
|  [ ] Tomatoes 2 kg                       |
|      For: Pasta, Curry                   |
|                                          |
|  [ ] Onions 1 kg                         |
|      For: Curry, Fried Rice              |
|                                          |
|  [ ] Chicken 500 g                       |
|      For: Curry                          |
|                                          |
|  [ ] Pasta 400 g                         |
|      For: Tomato Pasta                   |
|                                          |
|  ... (more items)                        |
|                                          |
|  --- Already Purchased (2) ---           |
|                                          |
|  [✓] Milk 2 L                            |
|  [✓] Bread 1 pack                        |
|                                          |
+------------------------------------------+
|  [Auto-Add to Cart (BigBasket)]          |
+------------------------------------------+

class MenuSuggestionEngine @Inject constructor(
    private val recipeRepository: RecipeRepository,
    private val mealSlotRepository: MealSlotRepository,
    private val itemRepository: ItemRepository,
    private val dietGoalRepository: DietGoalRepository,
    private val ingredientMatcher: IngredientMatcher
) {

    /**
     * Generate recipe suggestions for a meal slot.
     *
     * Scoring factors:
     * 1. Ingredient availability (higher = more ingredients in stock)
     * 2. Historical frequency (higher = less recently used, for variety)
     * 3. User favorites (bonus points)
     * 4. Diet goal compliance (filter/boost)
     * 5. Time of day appropriateness (breakfast vs dinner)
     */
    suspend fun getSuggestions(
        date: Date,
        mealType: MealType,
        existingMenu: WeekMenu,
        limit: Int = 5
    ): List<RecipeSuggestion> {
        val allRecipes = recipeRepository.getAllWithIngredients().first()
        val inventory = itemRepository.getAllGroceryItems().first()
        val dietGoals = dietGoalRepository.getActiveGoals().first()
        val recentHistory = mealSlotRepository.getHistory(days = 30).first()

        // Get recipes already in this week's menu (for variety)
        val usedThisWeek = existingMenu.days.flatMap { day ->
            listOfNotNull(day.breakfast?.recipe, day.lunch?.recipe, day.dinner?.recipe)
        }.map { it.id }.toSet()

        return allRecipes
            .filter { recipe ->
                // Filter by meal type appropriateness
                isMealTypeAppropriate(recipe.category, mealType)
            }
            .filter { recipe ->
                // Filter by diet goals
                passesDietGoals(recipe, dietGoals)
            }
            .map { recipe ->
                val score = calculateScore(
                    recipe = recipe,
                    inventory = inventory,
                    recentHistory = recentHistory,
                    usedThisWeek = usedThisWeek,
                    dietGoals = dietGoals
                )
                RecipeSuggestion(recipe, score)
            }
            .sortedByDescending { it.score }
            .take(limit)
    }

    /**
     * Auto-generate a full week menu.
     * Uses constraint satisfaction to maximize variety and ingredient usage.
     */
    suspend fun generateWeekMenu(
        weekStart: Date,
        constraints: MenuConstraints = MenuConstraints()
    ): GeneratedMenu {
        val allRecipes = recipeRepository.getAllWithIngredients().first()
        val inventory = itemRepository.getAllGroceryItems().first()
        val dietGoals = dietGoalRepository.getActiveGoals().first()

        val assignments = mutableListOf<MealAssignment>()
        val usedRecipes = mutableSetOf<String>()
        val usedCuisines = mutableMapOf<String, Int>()
        val usedMainIngredients = mutableMapOf<String, Int>()

        // Generate for each day
        for (dayOffset in 0..6) {
            val date = addDays(weekStart, dayOffset)

            for (mealType in listOf(MealType.BREAKFAST, MealType.LUNCH, MealType.DINNER)) {
                val candidates = allRecipes
                    .filter { isMealTypeAppropriate(it.category, mealType) }
                    .filter { passesDietGoals(it, dietGoals) }
                    .filter { constraints.allowRepeats || it.id !in usedRecipes }
                    .map { recipe ->
                        val varietyScore = calculateVarietyScore(
                            recipe,
                            usedCuisines,
                            usedMainIngredients
                        )
                        val availabilityScore = calculateAvailabilityScore(recipe, inventory)
                        val totalScore = availabilityScore * 0.6 + varietyScore * 0.4

                        recipe to totalScore
                    }
                    .sortedByDescending { it.second }

                val selected = candidates.firstOrNull()?.first

                if (selected != null) {
                    assignments.add(MealAssignment(date, mealType, selected))
                    usedRecipes.add(selected.id)
                    selected.cuisine?.let {
                        usedCuisines[it] = (usedCuisines[it] ?: 0) + 1
                    }
                    selected.ingredients.firstOrNull()?.let {
                        usedMainIngredients[it.ingredientKey] =
                            (usedMainIngredients[it.ingredientKey] ?: 0) + 1
                    }
                }
            }
        }

        return GeneratedMenu(
            weekStart = weekStart,
            assignments = assignments,
            coveragePercent = (assignments.size.toFloat() / 21) * 100
        )
    }

    private fun calculateScore(
        recipe: RecipeWithIngredients,
        inventory: List<GroceryItem>,
        recentHistory: List<MealSlot>,
        usedThisWeek: Set<String>,
        dietGoals: List<DietGoal>
    ): Float {
        var score = 0f

        // Availability score (0-40 points)
        val availableIngredients = recipe.ingredients.count { ingredient ->
            val match = ingredientMatcher.findMatches(
                ingredient.ingredientKey, inventory, emptyList()
            )
            match is MatchResult.Found
        }
        score += (availableIngredients.toFloat() / recipe.ingredients.size) * 40

        // Recency score - less recent = higher (0-25 points)
        val daysSinceLastUse = recentHistory
            .filter { it.recipe?.id == recipe.id }
            .maxOfOrNull { daysBetween(it.date, Date()) }
            ?: 30

        score += minOf(25f, daysSinceLastUse.toFloat() * 0.8f)

        // Not used this week bonus (10 points)
        if (recipe.id !in usedThisWeek) {
            score += 10
        }

        // Favorite bonus (15 points)
        if (recipe.isFavorite) {
            score += 15
        }

        // Use count bonus (frequently made recipes) (0-10 points)
        score += minOf(10f, recipe.useCount.toFloat() * 0.5f)

        return score
    }

    private fun isMealTypeAppropriate(category: RecipeCategory, mealType: MealType): Boolean {
        return when (mealType) {
            MealType.BREAKFAST -> category in listOf(
                RecipeCategory.BREAKFAST, RecipeCategory.BEVERAGE, RecipeCategory.SNACK
            )
            MealType.LUNCH -> category in listOf(
                RecipeCategory.LUNCH, RecipeCategory.DINNER // Lunch can use dinner recipes
            )
            MealType.DINNER -> category == RecipeCategory.DINNER
            MealType.SNACK -> category in listOf(
                RecipeCategory.SNACK, RecipeCategory.DESSERT, RecipeCategory.BEVERAGE
            )
        }
    }

    private fun passesDietGoals(recipe: RecipeWithIngredients, goals: List<DietGoal>): Boolean {
        return goals.all { goal ->
            when (goal.goalType) {
                DietGoalType.VEGETARIAN ->
                    recipe.tags?.contains("vegetarian") == true ||
                    !recipe.ingredients.any { it.ingredientKey in MEAT_INGREDIENTS }

                DietGoalType.VEGAN ->
                    recipe.tags?.contains("vegan") == true

                DietGoalType.NO_DAIRY ->
                    !recipe.ingredients.any { it.ingredientKey in DAIRY_INGREDIENTS }

                DietGoalType.CUSTOM_EXCLUSION ->
                    goal.excludedIngredients?.let { excluded ->
                        !recipe.ingredients.any { it.ingredientKey in excluded }
                    } ?: true

                else -> true
            }
        }
    }

    companion object {
        val MEAT_INGREDIENTS = setOf("chicken", "fish", "mutton", "pork", "beef", "eggs")
        val DAIRY_INGREDIENTS = setOf("milk", "cheese", "butter", "cream", "yogurt", "paneer")
    }
}

data class RecipeSuggestion(
    val recipe: RecipeWithIngredients,
    val score: Float,
    val ingredientAvailability: Float = 0f
)

data class GeneratedMenu(
    val weekStart: Date,
    val assignments: List<MealAssignment>,
    val coveragePercent: Float
)

data class MealAssignment(
    val date: Date,
    val mealType: MealType,
    val recipe: RecipeWithIngredients
)

data class MenuConstraints(
    val allowRepeats: Boolean = false,
    val maxCuisineRepeat: Int = 2,
    val preferIngredientReuse: Boolean = true
)

+------------------------------------------+
|  ← Diet Goals                       [+]  |
+------------------------------------------+
|                                          |
|  --- Active Goals ---                    |
|                                          |
|  +------------------------------------+  |
|  | 🥗 Vegetarian                      |  |
|  |    3 days per week                 |  |
|  |    Progress: 2/3 this week     [✏️]|  |
|  +------------------------------------+  |
|                                          |
|  +------------------------------------+  |
|  | 🌾 Low Carb                        |  |
|  |    Max 100g carbs per day          |  |
|  |    Avg: 85g this week          [✏️]|  |
|  +------------------------------------+  |
|                                          |
|  +------------------------------------+  |
|  | 🍽️ Cuisine Variety                |  |
|  |    Different cuisine each day      |  |
|  |    Score: 5/7 days             [✏️]|  |
|  +------------------------------------+  |
|                                          |
|  --- Add New Goal ---                    |
|                                          |
|  [Dietary Restrictions]                  |
|  [Nutritional Targets]                   |
|  [Variety Goals]                         |
|  [Custom Rules]                          |
|                                          |
+------------------------------------------+

class DietGoalTracker @Inject constructor(
    private val dietGoalRepository: DietGoalRepository,
    private val mealSlotRepository: MealSlotRepository,
    private val recipeRepository: RecipeRepository
) {

    suspend fun getGoalProgress(
        goal: DietGoal,
        weekStart: Date
    ): GoalProgress {
        val weekEnd = addDays(weekStart, 6)
        val meals = mealSlotRepository.getCompletedMealsForRange(weekStart, weekEnd).first()

        return when (goal.goalType) {
            DietGoalType.VEGETARIAN -> {
                val vegetarianMeals = meals.count { meal ->
                    meal.recipe?.tags?.contains("vegetarian") == true
                }
                GoalProgress.Frequency(
                    current = vegetarianMeals,
                    target = goal.frequencyTarget ?: 0,
                    unit = "meals"
                )
            }

            DietGoalType.CUISINE_VARIETY -> {
                val uniqueCuisines = meals
                    .mapNotNull { it.recipe?.cuisine }
                    .distinct()
                    .size
                GoalProgress.Count(
                    current = uniqueCuisines,
                    description = "different cuisines this week"
                )
            }

            DietGoalType.CUSTOM_INCLUSION -> {
                val targetIngredients = goal.preferredCategories ?: emptyList()
                val usedIngredients = meals.flatMap { meal ->
                    meal.recipe?.ingredients?.map { it.ingredientKey } ?: emptyList()
                }.toSet()
                val matched = targetIngredients.count { it in usedIngredients }
                GoalProgress.Frequency(
                    current = matched,
                    target = targetIngredients.size,
                    unit = "ingredients included"
                )
            }

            else -> GoalProgress.Unknown
        }
    }
}

sealed class GoalProgress {
    data class Frequency(
        val current: Int,
        val target: Int,
        val unit: String
    ) : GoalProgress() {
        val percentage: Float get() = if (target > 0) current.toFloat() / target else 0f
    }

    data class Count(
        val current: Int,
        val description: String
    ) : GoalProgress()

    object Unknown : GoalProgress()
}