server.ts

import 'dotenv/config';
import express from 'express';
import http from 'http';
import https from 'https';
import { createServer as createViteServer } from 'vite';
import { db } from './server/db/database';
import { runMigrations } from './server/db/migrations';
import { mapCategory } from './server/utils/categories';
import { normalizeUnit, convertToSmallestUnit } from './server/utils/units';
import { getAIResponse, checkRateLimit } from './server/services/ai.service';
import { syncToBring } from './server/services/bring.service';
import { SCAN_PROMPT, SCAN_SCHEMA, MHD_PROMPT, MHD_SCHEMA } from './server/services/prompts';
import { Type } from '@google/genai';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import Parser from 'rss-parser';

const app = express();
const PORT = 3000;

// No CORS middleware: FoodAI is designed for self-hosted, trusted local networks only.
// If you need cross-origin access, add a reverse proxy with appropriate CORS headers.

app.use(express.json({ limit: '10mb' }));

// Larger body limit for image upload endpoints (base64 photos)
const largeBody = express.json({ limit: '50mb' });

// --- HTML escaping for XSS prevention ---
const escapeHtml = (s: string) => String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');

// --- LIKE metacharacter escaping for SQL injection prevention ---
const escapeLike = (s: string) => s.replace(/%/g, '\\%').replace(/_/g, '\\_');

// --- SSRF prevention: validate URLs before fetching ---
function isAllowedUrl(url: string): boolean {
  try {
    const u = new URL(url);
    if (!['http:', 'https:'].includes(u.protocol)) return false;
    // Block cloud metadata endpoints
    if (u.hostname === '169.254.169.254') return false;
    return true;
  } catch { return false; }
}

// --- Settings key allowlist ---
const ALLOWED_SETTINGS = ['ai_provider', 'ai_model', 'ai_api_key', 'ollama_url', 'bring_email', 'bring_password', 'advisor_model', 'language', 'image_provider', 'image_model', 'image_api_key'];

// --- Ingredient Matching (alias map + fuzzy matching) ---
const normalizeIngredient = (s: string) => s.toLowerCase().replace(/\(.*?\)/g, '').replace(/[,\.]/g, '').replace(/\s+/g, ' ').trim();

const germanStem = (s: string): string => {
  if (s.length <= 3) return s;
  for (const suffix of ['flöckchen', 'flocken', 'chen', 'lein', 'eln', 'ern', 'en', 'er', 'es', 'em', 'el', 'n', 'e', 's']) {
    if (s.length - suffix.length >= 3 && s.endsWith(suffix)) {
      return s.slice(0, -suffix.length);
    }
  }
  return s;
};

// Resolve directory for ESM compatibility
const serverDir = process.cwd();

// Load alias file once at startup
let ingredientAliasMap: Record<string, string[]> = {};
for (const tryPath of [
  path.join(serverDir, 'ingredient-aliases.json'),
  path.join(serverDir, 'src', 'data', 'ingredient-aliases.json'),
  path.join(process.cwd(), 'ingredient-aliases.json'),
  '/app/ingredient-aliases.json'
]) {
  try {
    ingredientAliasMap = JSON.parse(fs.readFileSync(tryPath, 'utf-8'));
    console.log(`Loaded ${Object.keys(ingredientAliasMap).length} ingredient aliases from ${tryPath}`);
    break;
  } catch {}
}
if (Object.keys(ingredientAliasMap).length === 0) {
  console.warn('WARNING: ingredient-aliases.json not found — ingredient matching will be degraded');
}

const ingredientAliasLookup: Record<string, string> = {};
const ingredientAliasGroups: Record<string, string[]> = {};
for (const [canonical, aliases] of Object.entries(ingredientAliasMap)) {
  const canonLower = canonical.toLowerCase();
  ingredientAliasGroups[canonLower] = aliases;
  for (const alias of aliases) {
    ingredientAliasLookup[alias] = canonLower;
  }
  ingredientAliasLookup[canonLower] = canonLower;
}

function getCanonicalNames(name: string): Set<string> {
  const n = normalizeIngredient(name);
  const results = new Set<string>();
  results.add(n);
  if (ingredientAliasLookup[n]) results.add(ingredientAliasLookup[n]);
  const words = n.split(' ');
  if (words.length > 1 && ingredientAliasLookup[words[0]]) results.add(ingredientAliasLookup[words[0]]);
  const stemmed = germanStem(n);
  if (stemmed !== n && ingredientAliasLookup[stemmed]) results.add(ingredientAliasLookup[stemmed]);
  const stemmedFirst = germanStem(words[0]);
  if (stemmedFirst !== words[0] && ingredientAliasLookup[stemmedFirst]) results.add(ingredientAliasLookup[stemmedFirst]);
  for (const [alias, canonical] of Object.entries(ingredientAliasLookup)) {
    if (alias.length >= 4 && n.includes(alias)) results.add(canonical);
  }
  return results;
}

function isIngredientInInventory(ingredientName: string, inventoryItems: { name: string; generic_name?: string | null }[]): boolean {
  const ingCanonicals = getCanonicalNames(ingredientName);
  const ingNorm = normalizeIngredient(ingredientName);
  return inventoryItems.some(item => {
    const itemCanonicals = getCanonicalNames(item.name);
    const genericCanonicals = item.generic_name ? getCanonicalNames(item.generic_name) : new Set<string>();
    const allItemCanonicals = new Set([...itemCanonicals, ...genericCanonicals]);
    for (const ic of ingCanonicals) { if (allItemCanonicals.has(ic)) return true; }
    const itemNorm = normalizeIngredient(item.name);
    const genericNorm = item.generic_name ? normalizeIngredient(item.generic_name) : '';
    if (ingNorm.length >= 4 && (itemNorm.includes(ingNorm) || genericNorm.includes(ingNorm))) return true;
    if (itemNorm.length >= 4 && ingNorm.includes(itemNorm)) return true;
    if (genericNorm.length >= 4 && ingNorm.includes(genericNorm)) return true;
    const ingStem = germanStem(ingNorm.split(' ')[0]);
    const itemStem = germanStem(itemNorm.split(' ')[0]);
    if (ingStem.length >= 3 && itemStem.length >= 3 && ingStem === itemStem) return true;
    for (const itemCanon of allItemCanonicals) {
      const group = ingredientAliasGroups[itemCanon];
      if (group) {
        for (const ic of ingCanonicals) {
          if (ic.length >= 4) {
            for (const alias of group) { if (alias.includes(ic)) return true; }
          }
        }
      }
    }
    return false;
  });
}

function matchRecipeIngredients(ingredients: { name: string; in_inventory?: boolean }[], inventoryItems: { name: string; generic_name?: string | null }[]): void {
  for (const ing of ingredients) { ing.in_inventory = isIngredientInInventory(ing.name, inventoryItems); }
}

runMigrations(db);

// --- API Routes ---

app.get('/api/settings/models', async (req, res) => {
  try {
    const provider = (db.prepare('SELECT value FROM settings WHERE key = ?').get('ai_provider') as any)?.value || 'gemini';
    const apiKey = (db.prepare('SELECT value FROM settings WHERE key = ?').get('ai_api_key') as any)?.value || process.env.GEMINI_API_KEY || '';
    const ollamaUrl = (db.prepare('SELECT value FROM settings WHERE key = ?').get('ollama_url') as any)?.value || 'http://localhost:11434';

    const models: Record<string, string[]> = {
      gemini: [], openai: [], anthropic: [], moonshot: [], deepseek: [], ollama: []
    };

    // Fetch live model lists from providers with API key
    if (apiKey) {
      try {
        if (provider === 'gemini') {
          const r = await fetch('https://generativelanguage.googleapis.com/v1beta/models', {
            headers: { 'x-goog-api-key': apiKey }
          });
          if (r.ok) {
            const data = await r.json();
            models.gemini = (data.models || [])
              .map((m: any) => m.name?.replace('models/', '') || '')
              .filter((id: string) => id && !id.includes('embedding') && !id.includes('aqa'))
              .sort();
          }
        } else if (provider === 'openai') {
          const r = await fetch('https://api.openai.com/v1/models', { headers: { 'Authorization': `Bearer ${apiKey}` } });
          if (r.ok) {
            const data = await r.json();
            models.openai = (data.data || [])
              .map((m: any) => m.id)
              .filter((id: string) => id.includes('gpt') || id.includes('o1') || id.includes('o3') || id.includes('chatgpt'))
              .sort();
          }
        } else if (provider === 'anthropic') {
          const r = await fetch('https://api.anthropic.com/v1/models', {
            headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' }
          });
          if (r.ok) {
            const data = await r.json();
            models.anthropic = (data.data || []).map((m: any) => m.id).sort();
          }
        } else if (provider === 'deepseek') {
          const r = await fetch('https://api.deepseek.com/v1/models', { headers: { 'Authorization': `Bearer ${apiKey}` } });
          if (r.ok) {
            const data = await r.json();
            models.deepseek = (data.data || []).map((m: any) => m.id).sort();
          }
        } else if (provider === 'moonshot') {
          const r = await fetch('https://api.moonshot.cn/v1/models', { headers: { 'Authorization': `Bearer ${apiKey}` } });
          if (r.ok) {
            const data = await r.json();
            models.moonshot = (data.data || []).map((m: any) => m.id).sort();
          }
        }
      } catch (e) {
        console.error(`Failed to fetch ${provider} models:`, e);
      }
    }

    // Ollama: always try (no API key needed)
    try {
      if (!isAllowedUrl(ollamaUrl)) throw new Error('Invalid Ollama URL');
      const r = await fetch(`${ollamaUrl}/api/tags`);
      if (r.ok) {
        const data = await r.json();
        models.ollama = (data.models || []).map((m: any) => m.name).sort();
      }
    } catch (e) { /* Ollama not running */ }

    res.json(models);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch models' });
  }
});

// Image model list with recommended markers
const RECOMMENDED_IMAGE_MODELS = new Set(['gpt-image-1.5', 'imagen-4.0-generate-001', 'sd3.5-large', 'gemini-2.5-flash-image']);

app.get('/api/settings/image-models', async (req, res) => {
  try {
    const provider = (db.prepare('SELECT value FROM settings WHERE key = ?').get('image_provider') as any)?.value || 'openai';
    const apiKey = (db.prepare('SELECT value FROM settings WHERE key = ?').get('image_api_key') as any)?.value;

    let models: { id: string; recommended: boolean }[] = [];

    if (apiKey) {
      try {
        if (provider === 'openai') {
          const r = await fetch('https://api.openai.com/v1/models', { headers: { 'Authorization': `Bearer ${apiKey}` } });
          if (r.ok) {
            const data = await r.json();
            models = (data.data || [])
              .map((m: any) => m.id)
              .filter((id: string) => id.includes('dall-e') || id.includes('gpt-image'))
              .sort()
              .map((id: string) => ({ id, recommended: RECOMMENDED_IMAGE_MODELS.has(id) }));
          }
        } else if (provider === 'gemini') {
          const r = await fetch('https://generativelanguage.googleapis.com/v1beta/models', {
            headers: { 'x-goog-api-key': apiKey }
          });
          if (r.ok) {
            const data = await r.json();
            models = (data.models || [])
              .map((m: any) => m.name?.replace('models/', '') || '')
              .filter((id: string) => id.includes('imagen') || id.includes('image'))
              .sort()
              .map((id: string) => ({ id, recommended: RECOMMENDED_IMAGE_MODELS.has(id) }));
          }
        } else if (provider === 'stability') {
          // Stability doesn't have a v2 model list — use known models
          models = [
            { id: 'sd3.5-large', recommended: true },
            { id: 'sd3.5-medium', recommended: false },
            { id: 'sd3.5-large-turbo', recommended: false },
          ];
        }
      } catch (e) {
        console.error(`Failed to fetch ${provider} image models:`, e);
      }
    }

    // Fallback to static list if API returned nothing
    if (models.length === 0) {
      if (provider === 'openai') models = [{ id: 'gpt-image-1.5', recommended: true }, { id: 'gpt-image-1', recommended: false }, { id: 'dall-e-3', recommended: false }];
      else if (provider === 'gemini') models = [{ id: 'imagen-4.0-generate-001', recommended: true }, { id: 'gemini-2.5-flash-image', recommended: true }, { id: 'gemini-3-pro-image-preview', recommended: false }];
      else if (provider === 'stability') models = [{ id: 'sd3.5-large', recommended: true }, { id: 'sd3.5-medium', recommended: false }];
    }

    res.json({ provider, models });
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch image models' });
  }
});

app.get("/api/inventory", (req, res) => {
  try {
    const items = db.prepare("SELECT * FROM items ORDER BY category ASC, expiry_date ASC").all();
    res.json(items);
  } catch (error) {
    console.error("Inventory Fetch Error:", error);
    res.status(500).json({ error: "Failed to fetch inventory" });
  }
});

app.get("/api/dashboard", (req, res) => {
  try {
    const today = new Date().toISOString().split("T")[0];
    const threeDaysLater = new Date();
    threeDaysLater.setDate(threeDaysLater.getDate() + 3);
    const threeDaysLaterStr = threeDaysLater.toISOString().split("T")[0];

    const expiringSoon = db.prepare("SELECT * FROM items WHERE expiry_date <= ? AND quantity > 0 AND category != 'Gewürze' ORDER BY expiry_date ASC").all(threeDaysLaterStr);
    const openedItems = db.prepare("SELECT * FROM items WHERE is_open = 1 AND quantity > 0 ORDER BY opened_at DESC").all();
    const todaysRecipes = db.prepare("SELECT * FROM planned_recipes WHERE date = ?").all(today).map((r: any) => ({
      ...r,
      ingredients: JSON.parse(r.ingredients),
      instructions: JSON.parse(r.instructions),
      cooked: r.cooked === 1
    }));

    const totalValueResult = db.prepare("SELECT SUM(price * quantity) as value FROM items WHERE price IS NOT NULL").get() as any;
    
    const lowStockCount = db.prepare(`
      SELECT COUNT(*) as count FROM (
        SELECT name, unit, SUM(quantity) as total, MAX(min_stock) as min 
        FROM items 
        GROUP BY name, unit
      ) WHERE min > 0 AND total < min
    `).get() as any;

    res.json({ 
      expiringSoon, 
      openedItems, 
      todaysRecipes, 
      totalValue: totalValueResult?.value || 0,
      lowStockCount: lowStockCount?.count || 0
    });
  } catch (error) {
    console.error("Dashboard Fetch Error:", error);
    res.status(500).json({ error: "Failed to fetch dashboard data" });
  }
});

app.post('/api/recipes/missing-ingredients', (req, res) => {
  const { ingredients, portions, base_portions } = req.body;
  if (!ingredients || !Array.isArray(ingredients)) return res.status(400).json({ error: 'Ingredients required' });
  
  try {
    const required: Record<string, { amount: number, unit: string, name: string }> = {};
    const ratio = (portions || 2) / (base_portions || 2);
    
    ingredients.forEach((ing: any) => {
      const smallest = convertToSmallestUnit(ing.amount * ratio, ing.unit);
      const key = `${ing.name.toLowerCase()}_${smallest.unit}`;
      if (!required[key]) {
        required[key] = { amount: 0, unit: smallest.unit, name: ing.name };
      }
      required[key].amount += smallest.amount;
    });

    const inventory = db.prepare('SELECT name, generic_name, quantity, unit, category FROM items WHERE quantity > 0').all() as any[];
    const missingIngredients: any[] = [];

    Object.values(required).forEach((reqIng: any) => {
      // Spices with any stock: always available regardless of unit
      const spiceMatch = inventory.find(inv => isIngredientInInventory(reqIng.name, [inv]));
      if (spiceMatch?.category === 'Gewürze' && spiceMatch.quantity > 0) return;

      // Use canonical alias matching (same as recipe ingredient checking)
      const matchingItems = inventory.filter(inv => {
        if (!isIngredientInInventory(reqIng.name, [inv])) return false;
        const invSmallest = convertToSmallestUnit(inv.quantity, inv.unit);
        return invSmallest.unit === reqIng.unit;
      });

      const totalInInventory = matchingItems.reduce((sum, inv) => {
        const invSmallest = convertToSmallestUnit(inv.quantity, inv.unit);
        return sum + invSmallest.amount;
      }, 0);

      if (totalInInventory < reqIng.amount) {
        let diff = reqIng.amount - totalInInventory;
        let displayAmount = diff;
        let displayUnit = reqIng.unit;

        if (displayUnit === 'g' && displayAmount >= 1000) { displayAmount /= 1000; displayUnit = 'kg'; }
        else if (displayUnit === 'ml' && displayAmount >= 1000) { displayAmount /= 1000; displayUnit = 'l'; }

        missingIngredients.push({
          name: reqIng.name,
          amountNeeded: Math.round(displayAmount * 100) / 100,
          unit: displayUnit
        });
      }
    });

    res.json({ missingIngredients });
  } catch (error) {
    console.error('Missing ingredients error:', error);
    res.status(500).json({ error: 'Failed to calculate missing ingredients' });
  }
});

app.get('/api/shopping-list', (req, res) => {
  try {
    const today = new Date().toISOString().split('T')[0];
    const upcomingRecipes = db.prepare('SELECT * FROM planned_recipes WHERE date >= ? AND cooked = 0').all(today);
    
    const required: Record<string, { amount: number, unit: string, name: string }> = {};

    upcomingRecipes.forEach((recipe: any) => {
      const ingredients = JSON.parse(recipe.ingredients);
      const ratio = recipe.portions / recipe.base_portions;
      ingredients.forEach((ing: any) => {
        const smallest = convertToSmallestUnit(ing.amount * ratio, ing.unit);
        const key = `${ing.name.toLowerCase()}_${smallest.unit}`;
        if (!required[key]) {
          required[key] = { amount: 0, unit: smallest.unit, name: ing.name };
        }
        required[key].amount += smallest.amount;
      });
    });

    const inventory = db.prepare('SELECT name, generic_name, quantity, unit, min_stock, category FROM items WHERE quantity > 0').all() as any[];

    // Add items that are below minimum stock
    const allKnownItems = db.prepare('SELECT name, generic_name, quantity, unit, min_stock, category FROM items').all() as any[];
    const lowStockItems: Record<string, { amount: number, unit: string, name: string }> = {};
    
    // Group by name and unit for min_stock check
    const stockLevels: Record<string, { total: number, min: number, unit: string }> = {};
    allKnownItems.forEach(item => {
      const key = `${item.name.toLowerCase()}_${normalizeUnit(item.unit)}`;
      if (!stockLevels[key]) {
        stockLevels[key] = { total: 0, min: item.min_stock || 0, unit: normalizeUnit(item.unit) };
      }
      const smallest = convertToSmallestUnit(item.quantity, item.unit);
      stockLevels[key].total += smallest.amount;
    });

    // Min-stock: for spices show as "1 Packung", for others show deficit amount
    Object.entries(stockLevels).forEach(([key, level]) => {
      if (level.min > 0 && level.total < level.min) {
        const name = key.split('_')[0];
        const item = allKnownItems.find(i => i.name.toLowerCase() === name);
        if (item?.category === 'Gewürze') {
          // Spices: add as "1 Packung"
          const spiceKey = `${name}_Stück`;
          if (!required[spiceKey]) {
            required[spiceKey] = { amount: 0, unit: 'Stück', name: name.charAt(0).toUpperCase() + name.slice(1) };
          }
          required[spiceKey].amount = 1;
        } else {
          const missing = level.min - level.total;
          if (!required[key]) {
            required[key] = { amount: 0, unit: level.unit, name: name.charAt(0).toUpperCase() + name.slice(1) };
          }
          required[key].amount += missing;
        }
      }
    });

    const missingIngredients: any[] = [];

    Object.values(required).forEach((reqIng: any) => {
      // Spices: if any matching item exists with quantity > 0, it's available (regardless of unit mismatch g vs %)
      const anyMatchInInventory = inventory.some(inv => isIngredientInInventory(reqIng.name, [inv]));
      if (anyMatchInInventory) {
        const matchedItem = inventory.find(inv => isIngredientInInventory(reqIng.name, [inv]));
        if (matchedItem?.category === 'Gewürze' && matchedItem.quantity > 0) {
          return; // Spice is in stock, skip
        }
      }

      // Standard matching with unit awareness
      const matchingItems = inventory.filter(inv => {
        if (!isIngredientInInventory(reqIng.name, [inv])) return false;
        const invSmallest = convertToSmallestUnit(inv.quantity, inv.unit);
        return invSmallest.unit === reqIng.unit;
      });

      const totalInInventory = matchingItems.reduce((sum, inv) => {
        const invSmallest = convertToSmallestUnit(inv.quantity, inv.unit);
        return sum + invSmallest.amount;
      }, 0);

      if (totalInInventory < reqIng.amount) {
        let diff = reqIng.amount - totalInInventory;
        let displayAmount = diff;
        let displayUnit = reqIng.unit;

        // Convert back to larger units for display if appropriate
        if (displayUnit === 'g' && displayAmount >= 1000) {
          displayAmount /= 1000;
          displayUnit = 'kg';
        } else if (displayUnit === 'ml' && displayAmount >= 1000) {
          displayAmount /= 1000;
          displayUnit = 'l';
        }

        missingIngredients.push({
          name: reqIng.name,
          amountNeeded: Math.round(displayAmount * 100) / 100,
          unit: displayUnit
        });
      }
    });

    res.json({ missingIngredients });
  } catch (error) {
    console.error('Shopping list error:', error);
    res.status(500).json({ error: 'Failed to generate shopping list' });
  }
});

app.get('/api/barcode/lookup/:barcode', async (req, res) => {
  const { barcode } = req.params;
  try {
    // 1. Check local database first
    const product = db.prepare('SELECT * FROM product_lookup WHERE barcode = ?').get(barcode) as any;
    if (product) {
      return res.json(product);
    }

    // 2. Fallback to OpenFoodFacts (Free, good for EAN/European products)
    console.log(`Barcode ${barcode} not in local DB, checking OpenFoodFacts...`);
    try {
      const offRes = await fetch(`https://world.openfoodfacts.org/api/v0/product/${barcode}.json`);
      if (offRes.ok) {
        const offData = await offRes.json() as any;
        if (offData.status === 1 && offData.product) {
          const p = offData.product;
          
          const rawCategory = p.categories_tags?.join(' ') || '';
          const mappedCategory = mapCategory(rawCategory, p.product_name || '');

          let parsedQuantity = 1;
          let parsedUnit = p.serving_quantity_unit || 'Stück';
          
          if (p.quantity) {
            const qMatch = p.quantity.match(/([\d.,]+)\s*([a-zA-Z%]+)/);
            if (qMatch) {
              parsedQuantity = parseFloat(qMatch[1].replace(',', '.'));
              parsedUnit = qMatch[2].toLowerCase();
              if (!['g', 'kg', 'ml', 'l', '%'].includes(parsedUnit)) {
                parsedUnit = 'Stück';
              }
            }
          }

          let genericName = p.generic_name || p.product_name || 'Unbekanntes Produkt';
          // Extended brand list based on user feedback
          genericName = genericName.replace(/^(Ja!|Gut & Günstig|K-Classic|Milbona|Alnatura|Barilla|Mutti|Oro di Parma|Rewe Beste Wahl|Edeka|Dr\. Oetker|Maggi|Knorr|Nestle|Kellogg's|Haribo|Lindt|Milka|Coca-Cola|Pepsi|Heinz|Kraft|Uncle Ben's|Mirácoli|Buitoni|Wagner|Iglo|Frosta|McCain|Coppenrath & Wiese|Langnese|Mövenpick|Landliebe|Weihenstephan|Müller|Danone|Zott|Ehrmann|Bauer|Andechser|Söbbeke|Rügenwalder Mühle|Herta|Meica|Wiesenhof|Gutfried|Rasting|Wilhelm Brandenburg|Kölln|Brüggen|Seitenbacher|Dr\. Karg|Wasa|Leibniz|Bahlsen|Griesson|De Beukelaer|Prinzen Rolle|Ritter Sport|Milka|Lindt|Ferrero|Kinder|Nutella|Hanuta|Duplo|Knoppers|Toffifee|Yogurette|Mon Chéri|Raffaello|Giotto|Rocher|Küchenmeister|Aurora|Diamant|Südzucker|Nordzucker|Bad Reichenhaller|Fuchs|Ostmann|Ubena|Kühne|Hengstenberg|Thomy|Homann|Nadler|Popp|Dahlhoff|Bautz'ner|Born|Werder|Hela|Kraft|Heinz|Bull's Eye|Knorr|Maggi|Erasco|Sonnen Bassermann|Buss|Stührk|Appel|Hawesta|Saupiquet|Thunfisch|Dose|Konserve)\s+/i, '').trim();

          const newProduct = {
            barcode,
            name: p.product_name || genericName,
            generic_name: genericName,
            category: mappedCategory,
            default_quantity: parsedQuantity,
            unit: parsedUnit,
            pieces_per_pack: 1
          };

          // If unit is 'g' but quantity is 1 and no weight info, default to Stück
          if (newProduct.unit === 'g' && newProduct.default_quantity === 1 && !p.quantity?.match(/1\s*g/i)) {
             newProduct.unit = 'Stück';
          }
          // Convert "Packung" to actual content unit
          if (newProduct.unit === 'Packung' || newProduct.unit === 'packung') {
             newProduct.unit = 'Stück';
          }

          // Try to extract pieces per pack from product name or quantity if possible
          // e.g. "15 Stück"
          const piecesMatch = p.quantity?.match(/(\d+)\s*(Stück|pcs|pieces)/i);
          if (piecesMatch) {
            newProduct.pieces_per_pack = parseInt(piecesMatch[1]);
          }

          db.prepare('INSERT OR IGNORE INTO product_lookup (barcode, name, generic_name, category, default_quantity, unit, pieces_per_pack) VALUES (?, ?, ?, ?, ?, ?, ?)')
            .run(newProduct.barcode, newProduct.name, newProduct.generic_name, newProduct.category, newProduct.default_quantity, newProduct.unit, newProduct.pieces_per_pack);
          
          return res.json(newProduct);
        }
      }
    } catch (e) {
      console.error('OpenFoodFacts error:', e);
    }

    // 3. Fallback to upcitemdb trial
    console.log(`Barcode ${barcode} not in OpenFoodFacts, checking upcitemdb...`);
    try {
      const upcRes = await fetch(`https://api.upcitemdb.com/prod/trial/lookup?upc=${barcode}`);
      if (upcRes.ok) {
        const upcData = await upcRes.json();
        if (upcData.items && upcData.items.length > 0) {
          const item = upcData.items[0];
          
          let genericName = item.title || 'Unbekanntes Produkt';
          // Clean up brand names (same list as above)
          genericName = genericName.replace(/^(Ja!|Gut & Günstig|K-Classic|Milbona|Alnatura|Barilla|Mutti|Oro di Parma|Rewe Beste Wahl|Edeka|Dr\. Oetker|Maggi|Knorr|Nestle|Kellogg's|Haribo|Lindt|Milka|Coca-Cola|Pepsi|Heinz|Kraft|Uncle Ben's|Mirácoli|Buitoni|Wagner|Iglo|Frosta|McCain|Coppenrath & Wiese|Langnese|Mövenpick|Landliebe|Weihenstephan|Müller|Danone|Zott|Ehrmann|Bauer|Andechser|Söbbeke|Rügenwalder Mühle|Herta|Meica|Wiesenhof|Gutfried|Rasting|Wilhelm Brandenburg|Kölln|Brüggen|Seitenbacher|Dr\. Karg|Wasa|Leibniz|Bahlsen|Griesson|De Beukelaer|Prinzen Rolle|Ritter Sport|Milka|Lindt|Ferrero|Kinder|Nutella|Hanuta|Duplo|Knoppers|Toffifee|Yogurette|Mon Chéri|Raffaello|Giotto|Rocher|Küchenmeister|Aurora|Diamant|Südzucker|Nordzucker|Bad Reichenhaller|Fuchs|Ostmann|Ubena|Kühne|Hengstenberg|Thomy|Homann|Nadler|Popp|Dahlhoff|Bautz'ner|Born|Werder|Hela|Kraft|Heinz|Bull's Eye|Knorr|Maggi|Erasco|Sonnen Bassermann|Buss|Stührk|Appel|Hawesta|Saupiquet|Thunfisch|Dose|Konserve)\s+/i, '').trim();

          const mappedCategory = mapCategory(item.category || '', item.title || '');
          
          // Try to parse quantity from title/description if not explicit
          let parsedQuantity = 1;
          let parsedUnit = 'Stück';
          
          const qMatch = item.title.match(/(\d+)\s*(g|kg|ml|l|oz|lb)/i);
          if (qMatch) {
             parsedQuantity = parseFloat(qMatch[1]);
             parsedUnit = qMatch[2].toLowerCase();
             if (parsedUnit === 'oz') { parsedQuantity = Math.round(parsedQuantity * 28.35); parsedUnit = 'g'; }
             if (parsedUnit === 'lb') { parsedQuantity = Math.round(parsedQuantity * 453.59); parsedUnit = 'g'; }
          }

          const newProduct = {
            barcode,
            name: genericName,
            generic_name: genericName,
            category: mappedCategory,
            default_quantity: parsedQuantity,
            unit: parsedUnit,
            pieces_per_pack: 1
          };
          
          db.prepare('INSERT OR IGNORE INTO product_lookup (barcode, name, generic_name, category, default_quantity, unit, pieces_per_pack) VALUES (?, ?, ?, ?, ?, ?, ?)')
            .run(newProduct.barcode, newProduct.name, newProduct.generic_name, newProduct.category, newProduct.default_quantity, newProduct.unit, newProduct.pieces_per_pack);

          return res.json(newProduct);
        }
      }
    } catch (e) {
      console.error('UPCItemDB error:', e);
    }

    res.status(404).json({ error: 'Product not found' });
  } catch (error) {
    console.error('Barcode lookup error:', error);
    res.status(500).json({ error: 'Database or API error' });
  }
});

app.post('/api/recipes/weekly', async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { preferences, portions } = req.body;
  try {
    const items = db.prepare('SELECT generic_name, name, quantity, unit, expiry_date, category FROM items').all();
    
    // Group items by generic_name and unit, but keep track of open status and expiry
    const groupedInventory: Record<string, { quantity: number, unit: string, details: string[], category: string }> = {};
    
    items.forEach((i: any) => {
      const key = `${i.generic_name || i.name}_${i.unit}`;
      if (!groupedInventory[key]) {
        groupedInventory[key] = { quantity: 0, unit: i.unit, details: [], category: i.category };
      }
      groupedInventory[key].quantity += i.quantity;
      
      let detail = `${i.quantity} ${i.unit}`;
      if (i.is_open) detail += ' (geöffnet)';
      if (i.expiry_date) detail += ` MHD: ${i.expiry_date}`;
      groupedInventory[key].details.push(detail);
    });

    const inventoryList = Object.entries(groupedInventory).map(([key, data]) => {
      const name = key.split('_')[0];
      // Summarize details if too many
      const detailsStr = data.details.length > 3 ? `${data.details.length} Packungen/Einheiten` : data.details.join(', ');
      return `- ${name}: ${data.quantity} ${data.unit} gesamt [${detailsStr}]`;
    }).join('\n');
    
    const prompt = `
      You are a professional meal planner. Create a 7-day meal plan (Monday to Sunday) for ${portions || 2} portions using the following ingredients from my inventory. 
      PRIORITIZE ingredients that are expiring soon (MHD) or are already opened (geöffnet).
      Include all available sauces and spices in your reasoning, and use them where appropriate.
      
      Inventory:
      ${inventoryList}
      
      User preferences: ${preferences || 'None'}
      
      Return a JSON object with a key "plan" which is an array of 7 objects. Each object must have:
      - day: "Montag", "Dienstag", etc.
      - title: Recipe title
      - description: Short description
      - ingredients: Array of objects { name, amount, unit, in_inventory (boolean) }
      - instructions: Array of strings (steps)
    `;

    const schema = {
      type: Type.OBJECT,
      properties: {
        plan: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              day: { type: Type.STRING },
              title: { type: Type.STRING },
              description: { type: Type.STRING },
              ingredients: {
                type: Type.ARRAY,
                items: {
                  type: Type.OBJECT,
                  properties: {
                    name: { type: Type.STRING },
                    amount: { type: Type.NUMBER },
                    unit: { type: Type.STRING },
                    in_inventory: { type: Type.BOOLEAN }
                  },
                  required: ["name", "amount", "unit", "in_inventory"]
                }
              },
              instructions: {
                type: Type.ARRAY,
                items: { type: Type.STRING }
              }
            },
            required: ["day", "title", "description", "ingredients", "instructions"]
          }
        }
      },
      required: ["plan"]
    };

    const result = await getAIResponse(prompt, undefined, schema);
    
    // Save to DB
    db.prepare('DELETE FROM weekly_plan').run();
    const insert = db.prepare('INSERT INTO weekly_plan (day_of_week, recipe_title, recipe_content) VALUES (?, ?, ?)');
    for (const day of result.plan) {
      insert.run(day.day, day.title, JSON.stringify(day));
    }

    res.json(result);
  } catch (error) {
    console.error('Weekly plan error:', error);
    res.status(500).json({ error: 'Failed to generate weekly plan' });
  }
});

app.get('/api/recipes/weekly', (req, res) => {
  try {
    const plan = db.prepare('SELECT * FROM weekly_plan ORDER BY id ASC').all();
    const result = plan.map((row: any) => JSON.parse(row.recipe_content));
    res.json({ plan: result });
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch weekly plan' });
  }
});

app.post('/api/inventory', (req, res) => {
  const { name, generic_name, quantity, unit, expiry_date, category, barcode, pieces_per_pack, location, price, min_stock } = req.body;
  const finalCategory = mapCategory(category || '', name);
  try {
    // Save to product_lookup for future barcode scans
    if (barcode) {
      db.prepare('INSERT OR IGNORE INTO product_lookup (barcode, name, generic_name, category, default_quantity, unit, pieces_per_pack, location, price, min_stock) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
        .run(barcode, name, generic_name || name, finalCategory, quantity, unit, pieces_per_pack || 1, location, price, min_stock);
    }

    // Sanitize expiry_date — AI sometimes returns "null" string
    const cleanExpiry = (expiry_date && expiry_date !== 'null' && expiry_date !== 'undefined') ? expiry_date : null;

    // Always create a new item — each physical package is its own row
    const stmt = db.prepare('INSERT INTO items (name, generic_name, quantity, unit, expiry_date, category, barcode, pieces_per_pack, package_size, is_open, location, price, min_stock) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)');
    const info = stmt.run(name, generic_name || name, quantity, unit, cleanExpiry, finalCategory, barcode, pieces_per_pack || 1, quantity, location || 'Vorratsschrank', price || 0, min_stock || 0);
    res.json({ id: info.lastInsertRowid, name, generic_name: generic_name || name, quantity, unit, expiry_date, category: finalCategory, barcode, package_size: quantity, location: location || 'Vorratsschrank', price, min_stock });
    // Trigger async sync
    syncToBring().catch(console.error);
  } catch (error) {
    console.error('Inventory add error:', error);
    res.status(500).json({ error: 'Failed to add item' });
  }
});

app.put('/api/inventory/:id', (req, res) => {
  const { id } = req.params;
  const { name, generic_name, quantity, unit, expiry_date, category, package_size, location, price, min_stock } = req.body;
  try {
    // If quantity exceeds package_size, update package_size too
    const existing = db.prepare('SELECT package_size FROM items WHERE id = ?').get(id) as any;
    let newPackageSize = package_size || existing?.package_size || quantity;
    if (quantity > newPackageSize) {
      newPackageSize = quantity;
    }

    const stmt = db.prepare('UPDATE items SET name = ?, generic_name = ?, quantity = ?, unit = ?, expiry_date = ?, category = ?, package_size = ?, location = ?, price = ?, min_stock = ? WHERE id = ?');
    stmt.run(name, generic_name || name, quantity, unit, expiry_date, category, newPackageSize, location, price, min_stock, id);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to update item' });
  }
});

app.delete('/api/inventory/:id', (req, res) => {
  const { id } = req.params;
  try {
    const stmt = db.prepare('DELETE FROM items WHERE id = ?');
    stmt.run(id);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete item' });
  }
});

app.post('/api/inventory/bulk-delete', (req, res) => {
  const { ids } = req.body;
  if (!Array.isArray(ids) || ids.length === 0) return res.status(400).json({ error: 'No IDs provided' });
  try {
    const stmt = db.prepare('DELETE FROM items WHERE id = ?');
    db.transaction(() => {
      for (const id of ids) {
        stmt.run(id);
      }
    })();
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to bulk delete items' });
  }
});

app.post('/api/inventory/bulk-update', (req, res) => {
  const { ids, updates } = req.body;
  if (!Array.isArray(ids) || ids.length === 0) return res.status(400).json({ error: 'No IDs provided' });
  try {
    const fields = Object.keys(updates).map(k => `${k} = ?`).join(', ');
    const values = Object.values(updates);
    const stmt = db.prepare(`UPDATE items SET ${fields} WHERE id = ?`);
    db.transaction(() => {
      for (const id of ids) {
        stmt.run(...values, id);
      }
    })();
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to bulk update items' });
  }
});

app.post('/api/inventory/:id/open', async (req, res) => {
  const { id } = req.params;
  try {
    const item = db.prepare('SELECT * FROM items WHERE id = ?').get(id) as any;
    if (!item) return res.status(404).json({ error: 'Item not found' });

    db.prepare('UPDATE items SET is_open = 1, opened_at = CURRENT_TIMESTAMP WHERE id = ?').run(id);

    // Skip expiry logic for spices (they don't go bad)
    if (item.category !== 'Gewürze') {
      const prompt = `The user opened: "${item.name}" (Category: ${item.category}, Unit: ${item.unit}, Current MHD: ${item.expiry_date || 'none'}).
After opening, how many days until this goes bad? Guidelines:
- Fresh dairy (milk, cream, yogurt): 3-5 days
- Canned goods (tomatoes, beans, corn): 2-3 days in fridge
- Cold cuts, sausages: 3-5 days
- Sauces (ketchup, mustard, mayo): 30-90 days
- Jams, honey, vinegar: 60-180 days
- Dry goods (flour, rice, pasta): no change
Return JSON: needs_new_expiry (boolean), days_until_spoiled (number or null)`;

      const schema = {
        type: Type.OBJECT,
        properties: {
          needs_new_expiry: { type: Type.BOOLEAN },
          days_until_spoiled: { type: Type.NUMBER }
        },
        required: ["needs_new_expiry"]
      };

      try {
        const aiResult = await getAIResponse(prompt, undefined, schema, true);
        if (aiResult.needs_new_expiry && aiResult.days_until_spoiled) {
          const newExpiry = new Date();
          newExpiry.setDate(newExpiry.getDate() + aiResult.days_until_spoiled);
          const expiryDate = newExpiry.toISOString().split('T')[0];
          // Only update if new expiry is sooner than existing
          if (!item.expiry_date || expiryDate < item.expiry_date) {
            db.prepare('UPDATE items SET expiry_date = ? WHERE id = ?').run(expiryDate, id);
          }
        }
      } catch (e: any) {
        console.error('AI expiry check failed (non-critical):', e.message);
      }
    }

    const updatedItem = db.prepare('SELECT * FROM items WHERE id = ?').get(id);
    res.json(updatedItem);
  } catch (error) {
    console.error('Open item error:', error);
    res.status(500).json({ error: 'Failed to open item' });
  }
});

app.post('/api/ha/inventory/update', (req, res) => {
  const { id, barcode, name, action, value } = req.body;
  // action: 'set' (e.g. value=75 for 75%), 'deduct' (e.g. value=15 for 15g)
  try {
    let item;
    if (id) {
      item = db.prepare('SELECT * FROM items WHERE id = ?').get(id) as any;
    } else if (barcode) {
      item = db.prepare('SELECT * FROM items WHERE barcode = ?').get(barcode) as any;
    } else if (name) {
      const allItems = db.prepare('SELECT * FROM items').all() as any[];
      item = allItems.find((inv: any) => isIngredientInInventory(name, [inv]));
    }

    if (!item) return res.status(404).json({ error: 'Item not found' });

    let newQuantity = item.quantity;
    if (action === 'set') {
      newQuantity = value;
    } else if (action === 'deduct') {
      newQuantity = Math.max(0, item.quantity - value);
    }

    db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQuantity, item.id);
    res.json({ success: true, item: { ...item, quantity: newQuantity } });
  } catch (error) {
    console.error('HA update error:', error);
    res.status(500).json({ error: 'HA update failed' });
  }
});

app.post('/api/scan/mhd', largeBody, async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { imageBase64 } = req.body;
  if (!imageBase64) return res.status(400).json({ error: 'No image provided' });

  try {
    const prompt = 'Extract the expiry date (MHD - Mindesthaltbarkeitsdatum) from this image. Return a JSON object with key "expiry_date" (format YYYY-MM-DD) or null if not found. Only return a date if you are very sure.';
    
    const schema = {
      type: Type.OBJECT,
      properties: {
        expiry_date: { type: Type.STRING, description: "YYYY-MM-DD format or null" }
      },
      required: ["expiry_date"]
    };

    const result = await getAIResponse(prompt, imageBase64, schema);
    res.json(result);
  } catch (error) {
    console.error('MHD AI Scan error:', error);
    res.status(500).json({ error: 'Failed to analyze MHD' });
  }
});

app.post('/api/scan', largeBody, async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { imageBase64 } = req.body;
  if (!imageBase64) return res.status(400).json({ error: 'No image provided' });

  try {
    const prompt = 'Analyze this image of a food product, barcode, or label. 1. Identify the product name. IMPORTANT: Remove brand names (e.g., "Iglo", "Barilla", "Gut & Günstig") but KEEP the variant/type (e.g., "Rahmspinat", "Lasagne", "Dunkler Saucenbinder", "Hähnchenschnitzel"). Example: "Iglo Rahmspinat Blubb" -> "Rahmspinat". "Knorr Saucenbinder Dunkel" -> "Dunkler Saucenbinder". 2. Determine a generic_name for grouping (e.g., "Rahmspinat (TK)"). IMPORTANT: For spices, seasonings, and spice mixes, the generic_name MUST be the specific spice/mix name (e.g., "Curry gemahlen", "Magic Dust", "Burger Gewürz"). NEVER use generic terms like "Gewürzmischung", "Spice Mix", or "Seasoning" as generic_name. 3. If a barcode is visible, try to decode it. 4. Estimate the CONTENT quantity and unit — always use the actual content unit, never "Packung". A 2L bottle = quantity:2000 unit:"ml". A 500g pack of pasta = quantity:500 unit:"g". A pack of 10 eggs = quantity:10 unit:"Stück". For spices/oils where exact weight is hard to track, use quantity:100 unit:"%". 5. Identify an expiry date if visible (YYYY-MM-DD). ONLY return a date if you are VERY sure. If unsure or not visible, return null. 6. Estimate the price in EUR if visible or common. 7. Suggest a storage location (e.g., Fridge, Freezer, Pantry). Return a JSON object with keys: name (string), generic_name (string), quantity (number), unit (string), category (string), expiry_date (string or null), price (number or null), location (string). The category MUST be one of: "Obst & Gemüse", "Kühlregal", "Tiefkühl", "Vorratsschrank", "Getränke", "Backwaren", "Fleisch & Fisch", "Snacks & Süßigkeiten", "Gewürze", "Saucen", "Haushalt & Drogerie", "Sonstiges". The unit MUST be one of: "Stück", "g", "kg", "ml", "l", "%".';

    const schema = {
      type: Type.OBJECT,
      properties: {
        name: { type: Type.STRING },
        generic_name: { type: Type.STRING },
        quantity: { type: Type.NUMBER },
        unit: { type: Type.STRING, enum: ["Stück", "g", "kg", "ml", "l", "%"] },
        category: { type: Type.STRING, enum: ["Obst & Gemüse", "Kühlregal", "Tiefkühl", "Vorratsschrank", "Getränke", "Backwaren", "Fleisch & Fisch", "Snacks & Süßigkeiten", "Gewürze", "Saucen", "Haushalt & Drogerie", "Sonstiges"] },
        expiry_date: { type: Type.STRING, description: "YYYY-MM-DD format or null" },
        price: { type: Type.NUMBER },
        location: { type: Type.STRING }
      },
      required: ["name", "generic_name", "quantity", "unit", "category"]
    };
    const result = await getAIResponse(prompt, imageBase64, schema);
    res.json(result);
  } catch (error) {
    console.error('Scan error:', error);
    res.status(500).json({ error: 'Failed to analyze image' });
  }
});

app.post('/api/cook/analyze-photo', largeBody, async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { imageBase64 } = req.body;
  if (!imageBase64) return res.status(400).json({ error: 'No image provided' });

  try {
    const items = db.prepare('SELECT id, generic_name, name, quantity, unit, category FROM items WHERE quantity > 0').all();
    const inventoryList = items.map((i: any) => `ID: ${i.id} | ${i.generic_name || i.name} (${i.quantity} ${i.unit})`).join('\n');
    
    const prompt = `
      Analyze this image of food ingredients that the user is about to cook.
      Match the visible ingredients with the following inventory list:
      ${inventoryList}
      
      For each matched ingredient, estimate how much the user is likely to use for a typical meal (or based on what's visible).
      If it's a full package of pasta, maybe they use 250g or 500g. If it's a can of tomatoes, maybe 100% (the whole can).
      If it's a single piece of vegetable (like an onion), maybe 1 Stück.
      
      Return a JSON object with a key "ingredients" containing an array of objects:
      - id: The ID from the inventory list
      - name: The name of the ingredient
      - unit: The unit from the inventory list
      - estimated_deduction: A number representing the estimated amount to deduct
      - reasoning: A short explanation of why this amount (e.g., "Standard portion for 2 people" or "Whole can visible")
    `;
    
    const schema = {
      type: Type.OBJECT,
      properties: {
        ingredients: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              id: { type: Type.INTEGER },
              name: { type: Type.STRING },
              unit: { type: Type.STRING },
              estimated_deduction: { type: Type.NUMBER },
              reasoning: { type: Type.STRING }
            },
            required: ["id", "name", "unit", "estimated_deduction", "reasoning"]
          }
        }
      },
      required: ["ingredients"]
    };

    const result = await getAIResponse(prompt, imageBase64, schema);
    res.json(result);
  } catch (error) {
    console.error('Analyze cook photo error:', error);
    res.status(500).json({ error: 'Failed to analyze photo' });
  }
});

app.post('/api/cook/ask-amounts', async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { ingredients, portions } = req.body;
  try {
    const prompt = `
      I am cooking a meal with the following ingredients:
      ${ingredients.map((i: any) => `- ${i.name} (Available: ${i.available} ${i.unit})`).join('\n')}
      
      How much of each ingredient should I use for ${portions || 2} portions to make a balanced meal?
      Return a JSON object with a key "advice" containing a short text advice, and "amounts" containing an array of objects with "id" and "suggested_amount".
    `;
    
    const schema = {
      type: Type.OBJECT,
      properties: {
        advice: { type: Type.STRING },
        amounts: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              id: { type: Type.INTEGER },
              suggested_amount: { type: Type.NUMBER }
            },
            required: ["id", "suggested_amount"]
          }
        }
      },
      required: ["advice", "amounts"]
    };

    const result = await getAIResponse(prompt, undefined, schema, true);
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get advice' });
  }
});

app.post('/api/cook/check-opened', async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { deductions, recipeId } = req.body;

  try {
    let itemsToCheck: any[] = [];
    
    if (recipeId) {
      // Calculate deductions for recipe
      const recipe = db.prepare('SELECT * FROM planned_recipes WHERE id = ?').get(recipeId) as any;
      if (!recipe) return res.status(404).json({ error: 'Recipe not found' });
      
      const ingredients = JSON.parse(recipe.ingredients);
      const ratio = recipe.portions / recipe.base_portions;
      
      for (const ing of ingredients) {
        let deductAmount = 0;
        if (ing.unit !== '%') {
          deductAmount = ing.amount * ratio;
        } else {
          deductAmount = 5 * recipe.portions;
        }
        
        let remainingToDeduct = deductAmount;
        // Use canonical alias matching
        const allInv = db.prepare('SELECT * FROM items ORDER BY is_open DESC, expiry_date ASC').all() as any[];
        const rows = allInv.filter(inv => isIngredientInInventory(ing.name, [inv]));

        // Spice: deduct percentage (exact if package_size known, else 0.5%/1%)
        const spiceItem = rows.find((r: any) => r.category === 'Gewürze' && r.unit === '%' && r.quantity > 0);
        if (spiceItem && !rows.some(r => convertToSmallestUnit(r.quantity, r.unit).unit === convertToSmallestUnit(remainingToDeduct, ing.unit).unit)) {
          const pctDeduct = calcSpiceDeduction(spiceItem, deductAmount, ing.unit);
          const newQty = Math.max(0, spiceItem.quantity - pctDeduct);
          db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, spiceItem.id);
          remainingToDeduct = 0;
        }

        for (const item of rows) {
          if (remainingToDeduct <= 0) break;
          
          let take = 0;
          if (item.is_open) {
            take = Math.min(item.quantity, remainingToDeduct);
          } else {
             const pkgSize = item.package_size || item.quantity;
             if (remainingToDeduct >= item.quantity) {
               take = item.quantity;
             } else {
               // Partial open
               let packagesToOpen = Math.ceil(remainingToDeduct / pkgSize);
               let totalOpenedAmount = packagesToOpen * pkgSize;
               
               if (totalOpenedAmount > item.quantity) {
                 totalOpenedAmount = item.quantity;
               }
               // We are interested if we are opening a package and NOT using it fully
               // If we open a package (totalOpenedAmount) and use remainingToDeduct
               // The leftover is totalOpenedAmount - remainingToDeduct
               
               if (totalOpenedAmount > remainingToDeduct) {
                 itemsToCheck.push({ id: item.id, name: item.name, category: item.category });
               }
               take = remainingToDeduct; // effectively we use this much
             }
          }
          remainingToDeduct -= take;
        }
      }
    } else if (deductions) {
      // Direct deductions (Free Cook)
      for (const d of deductions) {
        const item = db.prepare('SELECT * FROM items WHERE id = ?').get(d.id) as any;
        if (item && !item.is_open) {
           const pkgSize = item.package_size || item.quantity;
           // Logic: If we deduct less than the full quantity (or full package multiple), it's an open event
           // But wait, free cook usually deducts specific amounts.
           // If amount < quantity, it's a partial use.
           
           // Simplified check: If new quantity > 0 and we are deducting from a closed item
           // But we need to handle the "package" logic if applicable.
           // If unit is pieces/pack, and we deduct 0.5, it's partial.
           
           // Let's stick to the logic: If we are left with a positive quantity on a previously closed item.
           if (item.quantity > d.amount) {
              // Check if we are just taking full packages
              if (pkgSize && d.amount % pkgSize === 0) {
                // Taking full packages, no open
              } else {
                itemsToCheck.push({ id: item.id, name: item.name, category: item.category });
              }
           }
        }
      }
    }

    // Filter out spices (don't expire)
    const filteredItems = itemsToCheck.filter((i: any) => i.category !== 'Gewürze');

    if (filteredItems.length === 0) {
      return res.json({ updates: [] });
    }

    const prompt = `The user opened these food items:
${filteredItems.map((i: any) => `ID: ${i.id}, Name: "${i.name}", Category: ${i.category}, MHD: ${i.expiry_date || 'none'}`).join('\n')}

After opening, how many days until each goes bad? Guidelines:
- Fresh dairy (milk, cream, yogurt): 3-5 days
- Canned goods (tomatoes, beans, corn): 2-3 days in fridge
- Cold cuts, sausages: 3-5 days
- Sauces (ketchup, mustard, mayo): 30-90 days
- Jams, honey, vinegar: 60-180 days
- Dry goods (flour, rice, pasta): no change
Return JSON with "updates" array: [{id, needs_new_expiry (boolean), days_until_spoiled (number or null)}]`;
    
    const schema = {
      type: Type.OBJECT,
      properties: {
        updates: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              id: { type: Type.INTEGER },
              needs_new_expiry: { type: Type.BOOLEAN },
              days_until_spoiled: { type: Type.NUMBER }
            },
            required: ["id", "needs_new_expiry"]
          }
        }
      },
      required: ["updates"]
    };

    const aiResult = await getAIResponse(prompt, undefined, schema, true);
    
    const updatesWithNames = aiResult?.updates?.map((u: any) => {
      const item = itemsToCheck.find(i => i.id === u.id);
      return { ...u, name: item?.name || 'Unbekannt' };
    }) || [];

    res.json({ updates: updatesWithNames });

  } catch (error) {
    console.error('Check opened error:', error);
    res.status(500).json({ error: 'Failed to check opened items' });
  }
});

app.post('/api/cook/deduct', async (req, res) => {
  const { deductions, openedUpdates } = req.body; // openedUpdates: [{ id, days }]
  try {
    db.transaction(() => {
      for (const d of deductions) {
        const item = db.prepare('SELECT * FROM items WHERE id = ?').get(d.id) as any;
        if (item) {
          if (item.is_open) {
            const newQuantity = Math.max(0, item.quantity - d.amount);
            db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQuantity, d.id);
          } else {
            const pkgSize = item.package_size || item.quantity;
            if (d.amount >= item.quantity) {
              db.prepare('UPDATE items SET quantity = 0 WHERE id = ?').run(item.id);
            } else {
              let packagesToOpen = Math.ceil(d.amount / pkgSize);
              let totalOpenedAmount = packagesToOpen * pkgSize;
              let leftoverOpened = totalOpenedAmount - d.amount;
              
              if (totalOpenedAmount > item.quantity) {
                totalOpenedAmount = item.quantity;
                leftoverOpened = totalOpenedAmount - d.amount;
              }
              
              db.prepare('UPDATE items SET quantity = quantity - ? WHERE id = ?').run(totalOpenedAmount, item.id);
              
              if (leftoverOpened > 0) {
                // Check if we have an update for this item
                const update = openedUpdates?.find((u: any) => u.id === item.id);
                let expiryDate = item.expiry_date;
                if (update) {
                  const newExpiry = new Date();
                  newExpiry.setDate(newExpiry.getDate() + update.days);
                  expiryDate = newExpiry.toISOString().split('T')[0];
                }
                
                db.prepare(`INSERT INTO items (name, generic_name, quantity, unit, expiry_date, category, barcode, pieces_per_pack, package_size, is_open, opened_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, CURRENT_TIMESTAMP)`).run(item.name, item.generic_name, leftoverOpened, item.unit, expiryDate, item.category, item.barcode, item.pieces_per_pack, pkgSize);
              }
            }
          }
        }
      }
      db.prepare('DELETE FROM items WHERE quantity <= 0').run();
    })();

    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to deduct items' });
  }
});

app.post('/api/recipes/generate', async (req, res) => {
  if (!checkRateLimit(req.ip || 'unknown')) return res.status(429).json({ error: 'Rate limit exceeded. Try again in a minute.' });
  const { preferences, portions, allowExtra = false, maxExtraItems = 0 } = req.body;
  try {
    const items = db.prepare('SELECT generic_name, name, quantity, unit, expiry_date, category FROM items').all();
    
    // Group items by generic_name and unit, but keep track of open status and expiry
    const groupedInventory: Record<string, { quantity: number, unit: string, details: string[], category: string }> = {};
    
    items.forEach((i: any) => {
      const key = `${i.generic_name || i.name}_${i.unit}`;
      if (!groupedInventory[key]) {
        groupedInventory[key] = { quantity: 0, unit: i.unit, details: [], category: i.category };
      }
      groupedInventory[key].quantity += i.quantity;
      
      let detail = `${i.quantity} ${i.unit}`;
      if (i.is_open) detail += ' (geöffnet)';
      if (i.expiry_date) detail += ` MHD: ${i.expiry_date}`;
      groupedInventory[key].details.push(detail);
    });

    const inventoryList = Object.entries(groupedInventory).map(([key, data]) => {
      const name = key.split('_')[0];
      const detailsStr = data.details.join(', ');
      return `- ${name}: ${data.quantity} ${data.unit} gesamt [${detailsStr}]`;
    }).join('\n');
    
    const extraInstruction = allowExtra && maxExtraItems > 0
      ? `You MAY include up to ${maxExtraItems} additional ingredients NOT in the inventory if they significantly improve the recipe. Mark these with in_inventory: false.`
      : `Use ONLY ingredients from the inventory. Do NOT add ingredients that are not listed. All ingredients must have in_inventory: true.`;

    const prompt = `
      You are a professional chef. Create a recipe for ${portions || 2} portions using the following ingredients from my inventory:
      ${inventoryList}

      User preferences/Season: ${preferences || 'None'}
      PREFER ingredients that are expiring soon (MHD) or already opened, but do NOT force them into the recipe if they don't fit.
      Expired items (MHD in the past) should be treated as optional — only use them if the recipe genuinely benefits.
      Include available sauces and spices where they naturally fit.
      ${extraInstruction}

      Return a JSON object with:
      - title: Recipe title (German)
      - description: Short description (German)
      - ingredients: Array of objects { name, amount, unit, in_inventory (boolean) }
      - instructions: Array of strings (steps, in German)
    `;

    const schema = {
      type: Type.OBJECT,
      properties: {
        title: { type: Type.STRING },
        description: { type: Type.STRING },
        ingredients: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              name: { type: Type.STRING },
              amount: { type: Type.NUMBER },
              unit: { type: Type.STRING },
              in_inventory: { type: Type.BOOLEAN }
            },
            required: ["name", "amount", "unit", "in_inventory"]
          }
        },
        instructions: {
          type: Type.ARRAY,
          items: { type: Type.STRING }
        }
      },
      required: ["title", "description", "ingredients", "instructions"]
    };

    const result = await getAIResponse(prompt, undefined, schema);
    res.json(result);
  } catch (error) {
    console.error('Recipe error:', error);
    res.status(500).json({ error: 'Failed to generate recipe' });
  }
});

app.get('/api/calendar', (req, res) => {
  try {
    const recipes = db.prepare('SELECT * FROM planned_recipes ORDER BY date ASC').all();
    res.json(recipes.map((r: any) => ({
      ...r,
      ingredients: JSON.parse(r.ingredients),
      instructions: JSON.parse(r.instructions),
      cooked: r.cooked === 1
    })));
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch calendar' });
  }
});

app.post('/api/calendar', (req, res) => {
  const { date, title, description, ingredients, instructions, portions, base_portions } = req.body;
  try {
    const stmt = db.prepare('INSERT INTO planned_recipes (date, title, description, ingredients, instructions, portions, base_portions) VALUES (?, ?, ?, ?, ?, ?, ?)');
    const result = stmt.run(date, title, description, JSON.stringify(ingredients), JSON.stringify(instructions), portions, base_portions || portions);
    const recipeId = result.lastInsertRowid;
    res.json({ success: true, id: recipeId });
    // Async: generate image + Bring sync
    generateRecipeImage(title, description).then(url => {
      if (url) db.prepare('UPDATE planned_recipes SET image_url = ? WHERE id = ?').run(url, recipeId);
    }).catch(e => console.error('Auto image gen failed:', e.message));
    syncToBring().catch(console.error);
  } catch (error) {
    res.status(500).json({ error: 'Failed to add to calendar' });
  }
});

app.post('/api/calendar/week', (req, res) => {
  const { startDate, recipes, portions } = req.body;
  try {
    const stmt = db.prepare('INSERT INTO planned_recipes (date, title, description, ingredients, instructions, portions, base_portions) VALUES (?, ?, ?, ?, ?, ?, ?)');
    db.transaction(() => {
      // In the new schema, r.date is explicitly provided by the AI prompt
      recipes.forEach((r: any, index: number) => {
        // Fallback for old requests without specific dates
        const recipeDate = r.date || (startDate ? new Date(new Date(startDate).getTime() + index * 24 * 60 * 60 * 1000).toISOString().split('T')[0] : new Date().toISOString().split('T')[0]);
        const recipePortions = r.portions || portions || 2;
        stmt.run(recipeDate, r.title, r.description, JSON.stringify(r.ingredients), JSON.stringify(r.instructions), recipePortions, recipePortions);
      });
    })();
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to add week to calendar' });
  }
});

app.put('/api/calendar/:id/cook', async (req, res) => {
  const { id } = req.params;
  const { openedUpdates } = req.body; // [{ id, days }]

  try {
    const recipe = db.prepare('SELECT * FROM planned_recipes WHERE id = ?').get(id) as any;
    if (!recipe) return res.status(404).json({ error: 'Recipe not found' });

    const ingredients = JSON.parse(recipe.ingredients);
    const ratio = recipe.portions / recipe.base_portions;
    const deducted: any[] = [];
    const missing: string[] = [];

    db.transaction(() => {
      for (const ing of ingredients) {
        let reqAmt = ing.amount * ratio;
        if (ing.unit === '%') reqAmt = 5 * recipe.portions;
        
        const smallestReq = convertToSmallestUnit(reqAmt, ing.unit);
        let remainingToDeduct = smallestReq.amount;
        
        // Use canonical alias matching (same as recipe ingredient checking)
        const allInvItems = db.prepare('SELECT * FROM items WHERE quantity > 0 ORDER BY is_open DESC, expiry_date ASC').all() as any[];
        const rows = allInvItems.filter(inv => isIngredientInInventory(ing.name, [inv]));

        const matchingRows = rows.filter(row => {
          const invSmallest = convertToSmallestUnit(row.quantity, row.unit);
          return invSmallest.unit === smallestReq.unit;
        });

        // Spice special handling: deduct percentage (exact if package_size known)
        if (matchingRows.length === 0) {
          const spiceItem = rows.find((r: any) => r.category === 'Gewürze' && r.unit === '%' && r.quantity > 0);
          if (spiceItem) {
            const pctDeduct = calcSpiceDeduction(spiceItem, reqAmt, ing.unit);
            const newQty = Math.max(0, spiceItem.quantity - pctDeduct);
            db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, spiceItem.id);
            deducted.push({ ...spiceItem, quantity_deducted_smallest: pctDeduct });
            remainingToDeduct = 0;
          }
        }

        if (matchingRows.length > 0) {
          for (const item of matchingRows) {
            if (remainingToDeduct <= 0) break;
            
            const itemSmallest = convertToSmallestUnit(item.quantity, item.unit);
            const pkgSizeSmallest = convertToSmallestUnit(item.package_size || item.quantity, item.unit);

            if (item.is_open) {
              const take = Math.min(itemSmallest.amount, remainingToDeduct);
              remainingToDeduct -= take;
              // Convert back to original unit for DB update
              const newQty = (itemSmallest.amount - take) / (itemSmallest.amount / item.quantity);
              db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, item.id);
              deducted.push({ ...item, quantity_deducted_smallest: take });
            } else {
              if (remainingToDeduct >= itemSmallest.amount) {
                remainingToDeduct -= itemSmallest.amount;
                db.prepare('UPDATE items SET quantity = 0 WHERE id = ?').run(item.id);
                deducted.push({ ...item, quantity_deducted_smallest: itemSmallest.amount });
              } else {
                let packagesToOpen = Math.ceil(remainingToDeduct / pkgSizeSmallest.amount);
                let totalOpenedSmallest = packagesToOpen * pkgSizeSmallest.amount;
                let leftoverSmallest = totalOpenedSmallest - remainingToDeduct;
                
                if (totalOpenedSmallest > itemSmallest.amount) {
                  totalOpenedSmallest = itemSmallest.amount;
                  leftoverSmallest = totalOpenedSmallest - remainingToDeduct;
                }
                
                const newQty = (itemSmallest.amount - totalOpenedSmallest) / (itemSmallest.amount / item.quantity);
                db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, item.id);
                deducted.push({ ...item, quantity_deducted_smallest: remainingToDeduct });
                
                if (leftoverSmallest > 0) {
                  const update = openedUpdates?.find((u: any) => u.id === item.id);
                  let expiryDate = item.expiry_date;
                  if (update) {
                    const newExpiry = new Date();
                    newExpiry.setDate(newExpiry.getDate() + update.days);
                    expiryDate = newExpiry.toISOString().split('T')[0];
                  }

                  const leftoverQty = leftoverSmallest / (pkgSizeSmallest.amount / (item.package_size || item.quantity));
                  db.prepare(`INSERT INTO items (name, generic_name, quantity, unit, expiry_date, category, barcode, pieces_per_pack, package_size, is_open, opened_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, CURRENT_TIMESTAMP)`).run(item.name, item.generic_name, leftoverQty, item.unit, expiryDate, item.category, item.barcode, item.pieces_per_pack, item.package_size || item.quantity);
                }
                remainingToDeduct = 0;
              }
            }
          }
          if (remainingToDeduct > 0) {
            let displayMissing = remainingToDeduct;
            let displayUnit = smallestReq.unit;
            if (displayUnit === 'g' && displayMissing >= 1000) { displayMissing /= 1000; displayUnit = 'kg'; }
            if (displayUnit === 'ml' && displayMissing >= 1000) { displayMissing /= 1000; displayUnit = 'l'; }
            missing.push(`${ing.name} (Fehlt: ${Math.round(displayMissing * 100) / 100} ${displayUnit})`);
          }
        } else {
          missing.push(ing.name);
        }
      }
      db.prepare('DELETE FROM items WHERE quantity <= 0').run();
      db.prepare('UPDATE planned_recipes SET cooked = 1 WHERE id = ?').run(id);
    })();

    res.json({ success: true, deducted, missing });
    // Trigger async sync
    syncToBring().catch(console.error);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Failed to mark as cooked' });
  }
});

app.delete('/api/calendar/:id', (req, res) => {
  const { id } = req.params;
  try {
    db.prepare('DELETE FROM planned_recipes WHERE id = ?').run(id);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete recipe' });
  }
});

app.put('/api/calendar/:id/date', (req, res) => {
  const { id } = req.params;
  const { date } = req.body;
  if (!date) return res.status(400).json({ error: 'Date is required' });
  try {
    db.prepare('UPDATE planned_recipes SET date = ? WHERE id = ?').run(date, id);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to update date' });
  }
});

app.put('/api/calendar/:id/portions', (req, res) => {
  const { id } = req.params;
  const { portions } = req.body;
  try {
    db.prepare('UPDATE planned_recipes SET portions = ? WHERE id = ?').run(portions, id);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to update portions' });
  }
});

// --- Favorite Recipes ---
// --- Recipe Import from URL ---
app.post('/api/recipes/import', async (req, res) => {
  const { url } = req.body;
  if (!url) return res.status(400).json({ error: 'No URL provided' });

  try {
    // Fetch the webpage
    const response = await fetch(url, {
      headers: { 'User-Agent': 'Mozilla/5.0 (compatible; FoodAI/1.0)' }
    });
    if (!response.ok) throw new Error('Failed to fetch URL: ' + response.status);

    const html = await response.text();

    // Extract text content (strip HTML tags, limit size for AI)
    const textContent = html
      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
      .replace(/<[^>]+>/g, ' ')
      .replace(/\s+/g, ' ')
      .trim()
      .slice(0, 8000);

    // Also try to extract JSON-LD recipe schema
    const jsonLdMatch = html.match(/<script type="application\/ld\+json">([\s\S]*?)<\/script>/gi);
    let schemaRecipe = '';
    if (jsonLdMatch) {
      for (const match of jsonLdMatch) {
        const jsonStr = match.replace(/<script[^>]*>/, '').replace(/<\/script>/, '');
        try {
          const parsed = JSON.parse(jsonStr);
          const recipe = Array.isArray(parsed) ? parsed.find((p: any) => p['@type'] === 'Recipe') : (parsed['@type'] === 'Recipe' ? parsed : null);
          if (recipe) {
            schemaRecipe = JSON.stringify(recipe).slice(0, 4000);
            break;
          }
        } catch {}
      }
    }

    const lang = (db.prepare("SELECT value FROM settings WHERE key = 'language'").get() as any)?.value || 'de';
    const langName = lang === 'de' ? 'German' : lang === 'es' ? 'Spanish' : 'English';

    const prompt = `Extract a recipe from this webpage content. ${schemaRecipe ? 'JSON-LD Schema found: ' + schemaRecipe : ''}\n\nPage text: ${textContent}\n\nReturn a JSON object with:\n- title: Recipe title (in ${langName})\n- description: Short description (in ${langName})\n- ingredients: Array of { name (${langName}, clean name without parentheses like "(n)" or "(s)"), amount (number, MUST be > 0. For vague amounts like "etwas", "nach Geschmack", "n.B." use 1. For "eine Prise" use 1.), unit (string — use "Stück", "g", "kg", "ml", "l", "EL", "TL", "Prise", "Bund"), in_inventory: false }\n- instructions: Array of step strings (in ${langName})\n\nIMPORTANT: Every ingredient MUST have amount > 0 and a clean name. Never return amount 0.\n\nIf the page is not a recipe, return { "error": "No recipe found" }.`;

    const schema = {
      type: Type.OBJECT,
      properties: {
        title: { type: Type.STRING },
        description: { type: Type.STRING },
        error: { type: Type.STRING },
        ingredients: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              name: { type: Type.STRING },
              amount: { type: Type.NUMBER },
              unit: { type: Type.STRING },
              in_inventory: { type: Type.BOOLEAN }
            },
            required: ["name", "amount", "unit", "in_inventory"]
          }
        },
        instructions: { type: Type.ARRAY, items: { type: Type.STRING } }
      },
      required: ["title"]
    };

    const result = await getAIResponse(prompt, undefined, schema);

    if (result.error) {
      return res.status(400).json({ error: result.error });
    }

    // Check which ingredients are in inventory using reusable matching
    const items = db.prepare('SELECT name, generic_name, quantity, unit FROM items WHERE quantity > 0').all() as any[];
    if (result.ingredients) {
      matchRecipeIngredients(result.ingredients, items);
    }

    res.json(result);
  } catch (error: any) {
    console.error('Recipe import error:', error);
    res.status(500).json({ error: 'Failed to import recipe: ' + (error.message || 'Unknown error') });
  }
});

// --- Voice API for HA integration ---
app.get('/api/voice/expiring', (req, res) => {
  try {
    const today = new Date().toISOString().split('T')[0];
    const threeDays = new Date();
    threeDays.setDate(threeDays.getDate() + 3);
    const threeDaysStr = threeDays.toISOString().split('T')[0];

    const items = db.prepare('SELECT name, expiry_date, quantity, unit FROM items WHERE expiry_date <= ? AND expiry_date >= ? AND quantity > 0 ORDER BY expiry_date ASC').all(threeDaysStr, today) as any[];
    const expired = db.prepare('SELECT name, expiry_date FROM items WHERE expiry_date < ? AND quantity > 0 ORDER BY expiry_date ASC').all(today) as any[];

    const lang = (req.query.lang as string) || 'de';
    let text = '';

    if (lang === 'de') {
      if (expired.length > 0) {
        text += 'Bereits abgelaufen: ' + expired.map((i: any) => i.name).join(', ') + '. ';
      }
      if (items.length > 0) {
        text += 'Bald ablaufend: ' + items.map((i: any) => {
          const days = Math.ceil((new Date(i.expiry_date).getTime() - new Date().getTime()) / 86400000);
          return i.name + (days <= 0 ? ' (heute)' : days === 1 ? ' (morgen)' : ` (in ${days} Tagen)`);
        }).join(', ') + '.';
      }
      if (!text) text = 'Alles in Ordnung, nichts läuft bald ab.';
    } else {
      if (expired.length > 0) {
        text += 'Already expired: ' + expired.map((i: any) => i.name).join(', ') + '. ';
      }
      if (items.length > 0) {
        text += 'Expiring soon: ' + items.map((i: any) => {
          const days = Math.ceil((new Date(i.expiry_date).getTime() - new Date().getTime()) / 86400000);
          return i.name + (days <= 0 ? ' (today)' : days === 1 ? ' (tomorrow)' : ` (in ${days} days)`);
        }).join(', ') + '.';
      }
      if (!text) text = 'All good, nothing expiring soon.';
    }

    res.json({ text, expired_count: expired.length, expiring_count: items.length });
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch expiring items' });
  }
});

app.get('/api/voice/inventory-summary', (req, res) => {
  try {
    const totalItems = (db.prepare('SELECT COUNT(*) as cnt FROM items WHERE quantity > 0').get() as any)?.cnt || 0;
    const openItems = (db.prepare('SELECT COUNT(*) as cnt FROM items WHERE is_open = 1 AND quantity > 0').get() as any)?.cnt || 0;
    const totalValue = (db.prepare('SELECT SUM(price * quantity) as value FROM items WHERE price IS NOT NULL').get() as any)?.value || 0;
    const categories = db.prepare('SELECT category, COUNT(*) as cnt FROM items WHERE quantity > 0 GROUP BY category ORDER BY cnt DESC').all() as any[];

    const lang = (req.query.lang as string) || 'de';
    let text = '';
    if (lang === 'de') {
      text = `Du hast ${totalItems} Packungen im Vorrat, davon ${openItems} geöffnet. Gesamtwert: ${totalValue.toFixed(2)} Euro. `;
      text += 'Kategorien: ' + categories.map((c: any) => `${c.category} (${c.cnt})`).join(', ') + '.';
    } else {
      text = `You have ${totalItems} packages in stock, ${openItems} opened. Total value: ${totalValue.toFixed(2)} EUR. `;
      text += 'Categories: ' + categories.map((c: any) => `${c.category} (${c.cnt})`).join(', ') + '.';
    }

    res.json({ text, total_items: totalItems, open_items: openItems, total_value: totalValue });
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch inventory summary' });
  }
});

app.get('/api/recipes/favorites', (req, res) => {
  try {
    const favorites = db.prepare('SELECT * FROM favorite_recipes ORDER BY created_at DESC').all();
    res.json(favorites.map((f: any) => ({
      ...f,
      ingredients: JSON.parse(f.ingredients),
      instructions: JSON.parse(f.instructions)
    })));
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch favorites' });
  }
});

app.post('/api/recipes/favorites', (req, res) => {
  const { title, description, ingredients, instructions, portions } = req.body;
  try {
    const stmt = db.prepare('INSERT INTO favorite_recipes (title, description, ingredients, instructions, portions) VALUES (?, ?, ?, ?, ?)');
    const info = stmt.run(title, description, JSON.stringify(ingredients), JSON.stringify(instructions), portions || 2);
    res.json({ id: info.lastInsertRowid });
  } catch (error) {
    res.status(500).json({ error: 'Failed to save favorite' });
  }
});

app.delete('/api/recipes/favorites/:id', (req, res) => {
  try {
    db.prepare('DELETE FROM favorite_recipes WHERE id = ?').run(req.params.id);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete favorite' });
  }
});

// --- Spice Deduction Helper ---
function calcSpiceDeduction(item: any, amount: number, unit: string): number {
  const vagueUnits = ['prise', 'tl', 'el', 'bund'];
  const isVague = vagueUnits.includes(unit.toLowerCase());
  if (isVague) {
    return (unit.toLowerCase() === 'prise' || unit.toLowerCase() === 'tl') ? 0.5 : 1;
  }
  // Exact: calculate % based on package_size (e.g. 3g from 35g jar = 8.6%)
  if (item.package_size && item.package_size > 0 && (unit === 'g' || unit === 'ml')) {
    return Math.round((amount / item.package_size) * 100 * 10) / 10; // 1 decimal
  }
  // Fallback
  return amount < 5 ? 0.5 : 1;
}

// --- Image Generation ---
async function generateRecipeImage(title: string, description?: string): Promise<string | null> {
  const provider = (db.prepare('SELECT value FROM settings WHERE key = ?').get('image_provider') as any)?.value || 'openai';
  const model = (db.prepare('SELECT value FROM settings WHERE key = ?').get('image_model') as any)?.value;
  const apiKey = (db.prepare('SELECT value FROM settings WHERE key = ?').get('image_api_key') as any)?.value;

  if (!apiKey) return null;

  const prompt = `Professional food photography of "${title}". ${description || ''}. Beautifully plated on a dark slate board, shot from a 45-degree angle. Warm natural side lighting with soft shadows, shallow depth of field, f/2.8 aperture, 85mm lens. Editorial food styling with fresh garnishes and natural textures visible. Warm color palette, appetizing presentation, photorealistic detail. Shot on a high-end DSLR camera, commercial food photography quality. No text, no watermarks, no logos.`;
  const negativePrompt = 'plastic, fake, illustration, cartoon, painting, CGI, blurry, watermark, text, logo, oversaturated, unrealistic colors, stock photo border';

  console.log(`Image generation: Provider=${provider}, Model=${model || 'default'}`);

  if (provider === 'openai') {
    const OpenAI = (await import('openai')).default;
    const client = new OpenAI({ apiKey });
    const effectiveModel = model || 'gpt-image-1.5';
    if (effectiveModel.startsWith('gpt-image')) {
      const response = await client.images.generate({
        model: effectiveModel,
        prompt, n: 1, size: '1024x1024', quality: 'medium'
      });
      return response.data[0]?.url || (response.data[0] as any)?.b64_json ? `data:image/png;base64,${(response.data[0] as any).b64_json}` : null;
    } else {
      const response = await client.images.generate({
        model: effectiveModel,
        prompt, n: 1, size: '1024x1024', quality: 'standard'
      });
      return response.data[0]?.url || null;
    }
  }

  if (provider === 'gemini') {
    const { GoogleGenAI } = await import('@google/genai');
    const genAI = new GoogleGenAI({ apiKey });
    const effectiveModel = model || 'imagen-4.0-generate-001';

    // Imagen models use generateImages, Gemini models use generateContent
    if (effectiveModel.startsWith('imagen')) {
      const response = await genAI.models.generateImages({
        model: effectiveModel,
        prompt,
        config: { numberOfImages: 1 }
      });
      const images = (response as any).generatedImages || [];
      if (images.length > 0 && images[0].image?.imageBytes) {
        return `data:image/png;base64,${images[0].image.imageBytes}`;
      }
      return null;
    } else {
      // Gemini native image generation (e.g. gemini-2.5-flash-image)
      const response = await genAI.models.generateContent({
        model: effectiveModel,
        contents: prompt,
        config: { responseModalities: ['IMAGE', 'TEXT'] }
      });
      const parts = response.candidates?.[0]?.content?.parts || [];
      const imagePart = parts.find((p: any) => p.inlineData?.mimeType?.startsWith('image/'));
      if (imagePart?.inlineData) {
        return `data:${imagePart.inlineData.mimeType};base64,${imagePart.inlineData.data}`;
      }
      return null;
    }
  }

  if (provider === 'stability') {
    const fd = new FormData();
    fd.append('prompt', prompt);
    fd.append('negative_prompt', negativePrompt);
    fd.append('model', model || 'sd3.5-large');
    fd.append('output_format', 'png');
    const response = await fetch('https://api.stability.ai/v2beta/stable-image/generate/sd3', {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${apiKey}`, 'Accept': 'application/json' },
      body: fd
    });
    const data = await response.json();
    if (data.image) return `data:image/png;base64,${data.image}`;
    return null;
  }

  return null;
}

app.post('/api/recipes/generate-image', async (req, res) => {
  const { title, description, recipeId, table } = req.body;
  if (!title) return res.status(400).json({ error: 'Title required' });

  const ip = req.ip || 'unknown';
  if (!checkRateLimit(ip, 5)) return res.status(429).json({ error: 'Rate limit exceeded' });

  try {
    const imageUrl = await generateRecipeImage(title, description);
    if (!imageUrl) return res.status(500).json({ error: 'No image generated — check image API key in settings' });

    if (recipeId && table) {
      const tbl = table === 'favorites' ? 'favorite_recipes' : 'planned_recipes';
      db.prepare(`UPDATE ${tbl} SET image_url = ? WHERE id = ?`).run(imageUrl, recipeId);
    }

    res.json({ image_url: imageUrl });
  } catch (error: any) {
    console.error('Image generation error:', error.message);
    res.status(500).json({ error: error.message || 'Image generation failed' });
  }
});

app.post('/api/recipes/cook', (req, res) => {
  const { usedIngredients } = req.body;
  const deducted: any[] = [];
  const missing: string[] = [];

  try {
    const allItems = db.prepare('SELECT * FROM items WHERE quantity > 0').all() as any[];

    db.transaction(() => {
      for (const ing of usedIngredients) {
        // Use canonical alias matching (same as recipe ingredient checking)
        const item = allItems.find(inv => isIngredientInInventory(ing.name, [inv]));
        if (item) {
          // Spice special case: deduct percentage (exact if package_size known)
          if (item.category === 'Gewürze' && item.unit === '%') {
            const pctDeduct = calcSpiceDeduction(item, ing.amount, ing.unit || 'g');
            const newQty = Math.max(0, item.quantity - pctDeduct);
            db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, item.id);
            item.quantity = newQty;
            deducted.push({ ...item, quantity_deducted: pctDeduct });
          } else {
            // Convert both to smallest unit for correct comparison (e.g. 1kg vs 1000g)
            const reqSmall = convertToSmallestUnit(ing.amount, ing.unit || item.unit);
            const invSmall = convertToSmallestUnit(item.quantity, item.unit);

            if (reqSmall.unit === invSmall.unit) {
              // Units compatible — deduct with conversion
              if (invSmall.amount >= reqSmall.amount) {
                const remaining = invSmall.amount - reqSmall.amount;
                // Convert back to original unit
                const newQty = (remaining / invSmall.amount) * item.quantity;
                db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, item.id);
                item.quantity = newQty;
                deducted.push({ ...item, quantity_deducted: ing.amount });
              } else {
                db.prepare('UPDATE items SET quantity = 0 WHERE id = ?').run(item.id);
                deducted.push({ ...item, quantity_deducted: item.quantity });
                const missingSmall = reqSmall.amount - invSmall.amount;
                missing.push(`${ing.name} (Fehlt: ${Math.round(missingSmall * 100) / 100} ${reqSmall.unit})`.trim());
                item.quantity = 0;
              }
            } else {
              // Units incompatible (shouldn't happen often) — try raw deduction as fallback
              if (item.quantity >= ing.amount) {
                const newQty = item.quantity - ing.amount;
                db.prepare('UPDATE items SET quantity = ? WHERE id = ?').run(newQty, item.id);
                item.quantity = newQty;
                deducted.push({ ...item, quantity_deducted: ing.amount });
              } else {
                db.prepare('UPDATE items SET quantity = 0 WHERE id = ?').run(item.id);
                deducted.push({ ...item, quantity_deducted: item.quantity });
                missing.push(`${ing.name} (Fehlt: ${ing.amount - item.quantity} ${ing.unit || item.unit || ''})`.trim());
                item.quantity = 0;
              }
            }
          }
        } else {
          missing.push(ing.name);
        }
      }
      db.prepare('DELETE FROM items WHERE quantity <= 0').run();
    })();
    res.json({ success: true, deducted, missing });
  } catch (error) {
    res.status(500).json({ error: 'Failed to deduct inventory' });
  }
});

app.get('/api/settings', (req, res) => {
  try {
    const settings = db.prepare('SELECT * FROM settings').all();
    const result = settings.reduce((acc: any, row: any) => {
      acc[row.key] = row.value;
      return acc;
    }, {});

    const defaults = {
      ai_provider: 'gemini',
      ai_model: 'gemini-3-flash-preview',
      ollama_url: 'http://localhost:11434'
    };

    const merged = { ...defaults, ...result };

    // Mask sensitive values — never return partial values
    const sensitiveKeys = ['ai_api_key', 'bring_password', 'image_api_key'];
    for (const key of sensitiveKeys) {
      if (merged[key]) {
        merged[key + '_set'] = true;
        merged[key] = '••••••••';
      }
    }

    res.json(merged);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch settings' });
  }
});

app.post('/api/settings/bulk', (req, res) => {
  const { settings } = req.body;
  if (!settings) return res.status(400).json({ error: 'No settings provided' });
  try {
    const insert = db.prepare('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)');
    const SENSITIVE_KEYS = ['ai_api_key', 'bring_password', 'image_api_key'];
    const transaction = db.transaction((data) => {
      for (const [key, value] of Object.entries(data)) {
        if (value !== undefined && value !== null) {
          if (!ALLOWED_SETTINGS.includes(key)) continue;
          // Skip masked values — don't overwrite real secrets with ••••••••
          if (SENSITIVE_KEYS.includes(key) && String(value).includes('••••')) continue;
          insert.run(key, String(value));
        }
      }
    });
    transaction(settings);
    res.json({ success: true });
  } catch (error) {
    console.error('Settings save error:', error);
    res.status(500).json({ error: 'Failed to save settings' });
  }
});

app.post('/api/settings', (req, res) => {
  const { key, value } = req.body;
  if (!ALLOWED_SETTINGS.includes(key)) {
    return res.status(400).json({ error: `Invalid setting key: ${key}` });
  }
  try {
    db.prepare('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)').run(key, value);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to save settings' });
  }
});


app.post('/api/bring/add', async (req, res) => {
  try {
    // We just trigger the full sync now since it handles diffs automatically
    await syncToBring();
    res.json({ success: true, message: 'Bring! list synced successfully' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to sync with Bring list' });
  }
});
// --- Food Inspiration RSS Feed ---
const rssParser = new Parser({
  customFields: {
    item: [
      ['media:content', 'media:content', { keepArray: true }],
      ['media:thumbnail', 'media:thumbnail'],
      ['enclosure', 'enclosure'],
    ]
  }
});

let feedCache: { items: any[]; fetchedAt: number; lang: string } | null = null;
const FEED_CACHE_TTL = 3600000; // 1 hour

function extractImage(item: any): string | null {
  if (item.enclosure?.url) return item.enclosure.url;
  if (item['media:content']?.[0]?.$?.url) return item['media:content'][0].$.url;
  if (item['media:thumbnail']?.$?.url) return item['media:thumbnail'].$.url;
  const match = (item['content:encoded'] || item.content || '').match(/<img[^>]+src="([^"]+)"/);
  if (match) return match[1];
  return null;
}

app.get('/api/feed/inspiration', async (req, res) => {
  try {
    const lang = (req.query.lang as string) || 'de';
    const now = Date.now();

    if (feedCache && feedCache.lang === lang && (now - feedCache.fetchedAt) < FEED_CACHE_TTL) {
      return res.json(feedCache.items);
    }

    // Try multiple RSS feeds for more items
    const feedUrls = lang === 'de'
      ? ['https://www.gutekueche.de/feed/tagesrezept', 'https://www.gutekueche.de/feed/wochenrezepte']
      : ['https://www.bbcgoodfood.com/feed'];

    let items: any[] = [];
    for (const feedUrl of feedUrls) {
      try {
        const feed = await rssParser.parseURL(feedUrl);
        const newItems = feed.items.slice(0, 6).map(item => ({
          title: item.title || '',
          link: item.link || '',
          image: extractImage(item),
          pubDate: item.pubDate || '',
          snippet: (item.contentSnippet || '').slice(0, 150),
        }));
        items.push(...newItems);
      } catch (e) {
        console.error('RSS fetch error:', e);
      }
      if (items.length >= 6) break;
    }

    // Deduplicate by title
    items = items.filter((item, idx, arr) => arr.findIndex(i => i.title === item.title) === idx);

    // Fill up to 3 with TheMealDB if needed
    while (items.length < 3) {
      try {
        const r = await fetch('https://www.themealdb.com/api/json/v1/1/random.php');
        const data = await r.json();
        const meal = data.meals?.[0];
        if (meal && !items.some(i => i.title === meal.strMeal)) {
          items.push({
            title: meal.strMeal,
            link: 'https://www.themealdb.com/meal/' + meal.idMeal,
            image: meal.strMealThumb,
            pubDate: new Date().toISOString(),
            snippet: meal.strCategory + ' · ' + meal.strArea,
          });
        }
      } catch { break; }
    }

    items = items.slice(0, 6);

    feedCache = { items, fetchedAt: now, lang };
    res.json(items);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch feed' });
  }
});

async function startServer() {
  if (process.env.NODE_ENV !== 'production') {
    const vite = await createViteServer({
      server: { middlewareMode: true },
      appType: 'spa',
    });
    app.use(vite.middlewares);
  } else {
    app.use(express.static('dist'));
  }

  // Mirror display route — standalone dark page, no React/Navbar
  app.get('/mirror/today', (req, res) => {
    res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
    res.setHeader('Service-Worker-Allowed', 'none');
    try {
      const today = new Date().toISOString().split('T')[0];
      const recipes = db.prepare('SELECT * FROM planned_recipes WHERE date = ? AND cooked = 0 ORDER BY id ASC').all(today) as any[];

      let recipeHtml = '';
      if (recipes.length === 0) {
        recipeHtml = '<div class="empty"><div class="icon">🍽️</div><p>Kein Rezept für heute geplant</p></div>';
      } else {
        for (const r of recipes) {
          const ingredients = JSON.parse(r.ingredients);
          const instructions = JSON.parse(r.instructions);
          recipeHtml += `
            <div class="recipe">
              <h1>${escapeHtml(r.title)}</h1>
              <p class="desc">${escapeHtml(r.description || '')}</p>
              <div class="meta">${escapeHtml(String(r.portions))} Portionen</div>
              <div class="columns">
                <div class="col col-ingredients">
                  <h2>Zutaten</h2>
                  <ul>${ingredients.map((i: any) => `<li><span class="amount">${escapeHtml(String(i.amount))} ${escapeHtml(i.unit)}</span> ${escapeHtml(i.name)} ${i.in_inventory ? '<span class="ok">&#x2713;</span>' : '<span class="missing">&#x2717;</span>'}</li>`).join('')}</ul>
                </div>
                <div class="col col-instructions">
                  <h2>Zubereitung</h2>
                  <ol>${instructions.map((s: string) => `<li>${escapeHtml(s)}</li>`).join('')}</ol>
                </div>
                ${r.image_url ? `<div class="col col-image"><h2>Gericht</h2><div class="image-wrap"><img src="${escapeHtml(r.image_url)}" alt="${escapeHtml(r.title)}" /></div></div>` : ''}
              </div>
            </div>`;
        }
      }

      res.send(`<!DOCTYPE html>
<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>Rezept des Tages</title>
<style>
  * { margin: 0; padding: 0; box-sizing: border-box; }
  body { background: #000; color: #fff; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; padding: 40px 60px; }
  .empty { text-align: center; padding: 200px 0; }
  .empty .icon { font-size: 80px; margin-bottom: 20px; }
  .empty p { font-size: 1.8em; color: #666; }
  .recipe { margin-bottom: 40px; }
  h1 { font-size: 2.8em; font-weight: 700; margin-bottom: 8px; text-shadow: 0 2px 12px rgba(255,255,255,0.1); }
  .desc { font-size: 1.2em; color: #aaa; margin-bottom: 16px; }
  .meta { font-size: 1em; color: #d1d5db; font-weight: 600; margin-bottom: 30px; padding: 8px 20px; background: rgba(255,255,255,0.06); border-radius: 12px; display: inline-block; border: 1px solid rgba(255,255,255,0.1); letter-spacing: 0.5px; }
  .columns { display: flex; gap: 40px; }
  .col-ingredients { flex: 0 0 25%; }
  .col-instructions { flex: 1; }
  .col-image { flex: 0 0 28%; }
  .image-wrap { border-radius: 16px; overflow: hidden; border: 1px solid #222; }
  .image-wrap img { width: 100%; height: auto; display: block; }
  h2 { font-size: 1em; text-transform: uppercase; letter-spacing: 3px; color: #888; margin-bottom: 20px; padding-bottom: 8px; border-bottom: 1px solid #333; }
  ul, ol { list-style: none; }
  ul li { padding: 8px 0; border-bottom: 1px solid #1a1a1a; font-size: 1.1em; display: flex; align-items: center; gap: 8px; }
  ol li { padding: 12px 0; border-bottom: 1px solid #1a1a1a; font-size: 1.05em; counter-increment: step; display: flex; gap: 12px; }
  ol li::before { content: counter(step); flex-shrink: 0; width: 28px; height: 28px; background: #1a1a1a; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-size: 0.8em; font-weight: 700; color: #666; }
  ol { counter-reset: step; }
  .amount { color: #e5e7eb; font-weight: 700; min-width: 80px; }
  .ok { color: #10b981; }
  .missing { color: #ef4444; }
</style></head><body>${recipeHtml}</body></html>`);
    } catch (error) {
      res.status(500).send('Error loading recipe');
    }
  });

  if (process.env.NODE_ENV !== 'production') {
    // already handled above
  } else {
    // SPA fallback: all non-API/mirror routes serve index.html
    app.get('*', (req, res, next) => {
      if (req.path.startsWith('/api/') || req.path.startsWith('/mirror/')) return next();
      res.sendFile(path.join(process.cwd(), 'dist', 'index.html'));
    });
  }

  // HTTPS with self-signed cert for camera access on mobile
  const certDir = process.env.DB_DIR || process.cwd();
  const keyPath = path.join(certDir, 'server.key');
  const certPath = path.join(certDir, 'server.cert');

  if (!fs.existsSync(keyPath) || !fs.existsSync(certPath)) {
    console.log('Generating self-signed certificate...');
    const { execFileSync } = await import('child_process');
    execFileSync('openssl', [
      'req', '-x509', '-newkey', 'rsa:2048',
      '-keyout', keyPath, '-out', certPath,
      '-days', '3650', '-nodes', '-subj', '/CN=foodai'
    ], { stdio: 'pipe' });
  }

  const sslOptions = {
    key: fs.readFileSync(keyPath),
    cert: fs.readFileSync(certPath),
  };

  https.createServer(sslOptions, app).listen(PORT, '0.0.0.0', () => {
    console.log(`Server running on https://0.0.0.0:${PORT}`);
  });

  // HTTP on port 3001 for local iframe embedding (MagicMirror)
  const HTTP_PORT = parseInt(process.env.HTTP_PORT || '3001');
  http.createServer(app).listen(HTTP_PORT, '127.0.0.1', () => {
    console.log(`HTTP server on http://127.0.0.1:${HTTP_PORT} (for local iframe embedding)`);
  });
}

startServer();