Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,1224 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import logging
+from pathlib import Path
+import requests
+from typing import Optional, Dict, List, Tuple, Any
+import json
+from io import BytesIO
+from PIL import Image
+import time
+import os
+import sqlite3
+import hashlib
+
+# ════════════════════════════════════════════════════════════════════════════
+# OPTIONAL DEPENDENCIES WITH FALLBACK
+# ════════════════════════════════════════════════════════════════════════════
+
+# Image Recognition
+try:
+    import tensorflow as tf
+    import cv2
+    IMAGE_RECOGNITION_AVAILABLE = True
+except ImportError:
+    IMAGE_RECOGNITION_AVAILABLE = False
+
+# Voice I/O
+try:
+    import speech_recognition as sr
+    from gtts import gTTS
+    VOICE_AVAILABLE = True
+except ImportError:
+    VOICE_AVAILABLE = False
+
+# ML Models
+try:
+    from sklearn.ensemble import RandomForestRegressor
+    from sklearn.preprocessing import StandardScaler
+    import joblib
+    ML_AVAILABLE = True
+except ImportError:
+    ML_AVAILABLE = False
+
+# Data Export
+try:
+    from reportlab.lib.pagesizes import letter
+    from reportlab.pdfgen import canvas
+    EXPORT_AVAILABLE = True
+except ImportError:
+    EXPORT_AVAILABLE = False
+
+# Data Visualization
+try:
+    import plotly.graph_objects as go
+    import plotly.express as px
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    PLOTLY_AVAILABLE = False
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ════════════════════════════════════════════════════════════════════════════
+# LANGUAGE TRANSLATION DICTIONARY
+# ════════════════════════════════════════════════════════════════════════════
+
+TRANSLATIONS = {
+    "Hindi": {
+        "title": "🌾 किसान साथी v4.0",
+        "subtitle": "🎤 आवाज के माध्यम से बात करें - आसान और सरल!",
+        "settings": "⚙️ सेटिंग्स",
+        "location": "📍 आपका स्थान",
+        "language": "🌐 भाषा",
+        "alerts": "🔔 अलर्ट",
+        "all_conditions_normal": "✅ सभी स्थितियां सामान्य हैं!",
+        "frost_risk": "❄️ ठंड का खतरा! नाजुक फसलों को बचाएं",
+        "high_temp": "🔥 अधिक तापमान! सिंचाई बढ़ाएं",
+        "high_humidity": "🦠 अधिक नमी! कवक रोगों के लिए सावधान रहें",
+        "voice_assistant": "🗣️ आवाज सहायक",
+        "weather": "🌤️ मौसम",
+        "market": "💰 बाजार",
+        "crops": "🌱 फसलें",
+        "pests": "🐛 कीट",
+        "irrigation": "💧 सिंचाई",
+        "analytics": "📊 विश्लेषण",
+        "disease": "📸 रोग",
+        "other": "🎤 अन्य",
+        "soil": "🧪 मिट्टी",
+        "yield": "📈 फसल",
+        "profile": "👤 प्रोफाइल",
+        "speak_with_voice": "### 🎤 आवाज से बात करें",
+        "what_you_want": "#### क्या आप जानना चाहते हैं?",
+        "rainfall_info": "बारिश की जानकारी",
+        "pest_problem": "कीट की समस्या",
+        "market_prices": "बाजार भाव",
+        "speak_question": "🎙️ अपनी आवाज से पूछें",
+        "microphone_on": "🎙️ माइक्रोफोन चालू करें",
+        "hear_answer": "🔊 जवाब सुनें",
+        "listening": "🎙️ सुनिए... बोलिए!",
+        "you_said": "आपने कहा:",
+        "weather_unavailable": "मौसम डेटा उपलब्ध नहीं है",
+        "upload_photo_disease": "📸 पत्ती की फोटो अपलोड करने के लिए 'रोग' टैब पर जाएं",
+        "go_disease_tab": "कृपया रोग टैब पर जाकर पत्ती की तस्वीर अपलोड करें",
+        "browser_no_mic": "आपके ब्राउज़र में माइ���्रोफोन सपोर्ट नहीं है",
+        "weather_info": "### 🌤️ मौसम की जानकारी",
+        "refresh_weather": "🔄 मौसम अपडेट करें",
+        "loading": "डेटा लोड हो रहा है...",
+        "temperature": "🌡️ तापमान",
+        "humidity": "💧 नमी",
+        "wind": "💨 हवा",
+        "market_prices_title": "### 💰 बाजार भाव",
+        "refresh_prices": "🔄 भाव अपडेट करें",
+        "per_quintal": "/क्विंटल",
+        "crop_suggestions": "### 🌱 फसल के सुझाव",
+        "best_crops": "📍 आपके क्षेत्र में सर्वश्रेष्ठ फसलें: कपास, गेहूँ, चावल, गन्ना",
+        "current_season": "📅 मौसम:",
+        "pest_management": "### 🐛 कीट प्रबंधन",
+        "pest_info": "कीटों की पहचान और नियंत्रण के सुझाव यहाँ मिलेंगे",
+        "irrigation_management": "### 💧 सिंचाई प्रबंधन",
+        "irrigation_info": "स्मार्ट सिंचाई अनुसूची और जल संरक्षण टिप्स",
+        "farm_analytics": "### 📊 खेत विश्लेषण",
+        "analytics_info": "लाभ गणना और खेत के आंकड़े यहाँ दिखेंगे",
+        "disease_detection": "### 📸 रोग पहचान (पत्ती की फोटो लगाएं)",
+        "upload_leaf": "📷 पत्ती की तस्वीर चुनें",
+        "your_photo": "आपकी तस्वीर",
+        "analyze": "🔍 विश्लेषण करें",
+        "analysis_complete": "✅ विश्लेषण पूरा!",
+        "disease": "रोग",
+        "confidence": "विश्वास",
+        "severity": "गंभीरता",
+        "image_recognition_unavailable": "⚠️ छवि पहचान उपलब्ध नहीं है",
+        "soil_check": "### 🧪 मिट्टी की जांच",
+        "soil_ph": "मिट्टी का pH",
+        "nitrogen": "नाइट्रोजन (mg/kg)",
+        "phosphorus": "फॉस्फोरस (mg/kg)",
+        "potassium": "पोटेशियम (mg/kg)",
+        "organic_matter": "जैव पदार्थ (%)",
+        "moisture": "नमी (%)",
+        "save_soil_test": "💾 मिट्टी परीक्षण सहेजें",
+        "saved": "✅ सहेजा गया!",
+        "recommendations": "### 📋 सुझाव:",
+        "acidic_soil": "🔴 **अम्लीय मिट्टी**: चूना (CaCO3) लगाएं",
+        "alkaline_soil": "🔴 **क्षारीय मिट्टी**: गंधक या जैव पदार्थ लगाएं",
+        "ideal_ph": "✅ **आदर्श pH**: 6.5-7.5 के बीच अच्छा है",
+        "low_nitrogen": "🟡 **कम नाइट्रोजन**: NPK 20:20:0 लगाएं",
+        "high_nitrogen": "🟡 **अधिक नाइट्रोजन**: नाइट्रोजन कम करें",
+        "ideal_nitrogen": "✅ **आदर्श नाइट्रोजन**: अच्छा स्तर",
+        "low_phosphorus": "🟡 **कम फॉस्फोरस**: DAP या SSP लगाएं",
+        "ideal_phosphorus": "✅ **आदर्श फॉस्फोरस**: अच्छा स्तर",
+        "low_potassium": "🟡 **कम पोटेशियम**: KCl या MOP लगाएं",
+        "ideal_potassium": "✅ **आदर्श पोटेशियम**: अच्छा स्तर",
+        "yield_prediction": "### 📈 फसल की उपज का अनुमान",
+        "temp_celsius": "तापमान (°C)",
+        "humidity_percent": "नमी (%)",
+        "rainfall_mm": "बारिश (mm)",
+        "predict_yield": "🔮 उपज की भविष्यवाणी करें",
+        "estimated_yield": "📈 अनुमानित उपज:",
+        "quintal_hectare": "क्विंटल/हेक्टेयर",
+        "high_yield": "✅ उच्च उपज की उम्मीद है!",
+        "average_yield": "📊 औसत उपज की उम्मीद है",
+        "low_yield": "⚠️ कम उपज हो सकती है। मिट्टी और मौसम की जांच करें",
+        "profile_settings": "### 👤 प्रोफाइल & सेटिंग्स",
+        "choose_option": "विकल्प चुनें",
+        "login": "🔐 लॉगिन",
+        "register": "📝 रजिस्टर",
+        "login_title": "लॉगिन करें",
+        "username": "���पयोगकर्ता नाम",
+        "password": "पासवर्ड",
+        "login_btn": "लॉगिन",
+        "login_success": "✅ लॉगिन सफल!",
+        "invalid_credentials": "❌ गलत क्रेडेंशियल्स",
+        "register_title": "नया खाता बनाएं",
+        "email": "ईमेल",
+        "register_btn": "रजिस्टर",
+        "registration_success": "✅ रजिस्ट्रेशन सफल! अब लॉगिन करें",
+        "logged_in_as": "✅ लॉगिन किया हुआ:",
+        "logout_btn": "लॉगआउट",
+        "footer": "🌾 किसान साथी v4.0 - सभी किसानों के लिए | 🚜 आसान, सरल, और मुफ्त",
+        "kharif": "खरीफ (Kharif)",
+        "rabi": "रबी (Rabi)",
+        "summer": "गर्मी (Summer)",
+        "wheat": "गेहूँ (Wheat)",
+        "rice": "चावल (Rice)",
+        "cotton": "कपास (Cotton)",
+        "sugarcane": "गन्ना (Sugarcane)",
+        "potato": "आलू (Potato)",
+        "tomato": "टमाटर (Tomato)",
+        "onion": "प्याज (Onion)",
+        "corn": "मक्का (Corn)",
+    },
+    
+    "English": {
+        "title": "🌾 Farmer Copilot v4.0",
+        "subtitle": "🎤 Speak with Voice - Easy and Simple!",
+        "settings": "⚙️ Settings",
+        "location": "📍 Your Location",
+        "language": "🌐 Language",
+        "alerts": "🔔 Alerts",
+        "all_conditions_normal": "✅ All conditions normal!",
+        "frost_risk": "❄️ Frost Risk! Protect delicate crops",
+        "high_temp": "🔥 High Temperature! Increase irrigation",
+        "high_humidity": "🦠 High Humidity! Watch for fungal diseases",
+        "voice_assistant": "🗣️ Voice Assistant",
+        "weather": "🌤️ Weather",
+        "market": "💰 Market",
+        "crops": "🌱 Crops",
+        "pests": "🐛 Pests",
+        "irrigation": "💧 Irrigation",
+        "analytics": "📊 Analytics",
+        "disease": "📸 Disease",
+        "other": "🎤 Other",
+        "soil": "🧪 Soil",
+        "yield": "📈 Yield",
+        "profile": "👤 Profile",
+        "speak_with_voice": "### 🎤 Speak with Your Voice",
+        "what_you_want": "#### What do you want to know?",
+        "rainfall_info": "Rainfall Information",
+        "pest_problem": "Pest Problem",
+        "market_prices": "Market Prices",
+        "speak_question": "🎙️ Ask with Your Voice",
+        "microphone_on": "🎙️ Turn On Microphone",
+        "hear_answer": "🔊 Hear Answer",
+        "listening": "🎙️ Listening... Speak now!",
+        "you_said": "You said:",
+        "weather_unavailable": "Weather data not available",
+        "upload_photo_disease": "📸 Upload leaf photo in Disease tab",
+        "go_disease_tab": "Please go to Disease tab and upload leaf photo",
+        "browser_no_mic": "Your browser does not support microphone",
+        "weather_info": "### 🌤️ Weather Information",
+        "refresh_weather": "🔄 Refresh Weather",
+        "loading": "Loading data...",
+        "temperature": "🌡️ Temperature",
+        "humidity": "💧 Humidity",
+        "wind": "💨 Wind",
+        "market_prices_title": "### 💰 Market Prices",
+        "refresh_prices": "🔄 Refresh Prices",
+        "per_quintal": "/quintal",
+        "crop_suggestions": "### 🌱 Crop Suggestions",
+        "best_crops": "📍 Best crops for your region: Cotton, Wheat, Rice, Sugarcane",
+        "current_season": "📅 Season:",
+        "pest_management": "### 🐛 Pest Management",
+        "pest_info": "Pest identification and control tips here",
+        "irrigation_management": "### 💧 Irrigation Management",
+        "irrigation_info": "Smart irrigation schedule and water conservation tips",
+        "farm_analytics": "### 📊 Farm Analytics",
+        "analytics_info": "Profit calculation and farm statistics here",
+        "disease_detection": "### 📸 Disease Detection (Upload Leaf Photo)",
+        "upload_leaf": "📷 Choose Leaf Photo",
+        "your_photo": "Your Photo",
+        "analyze": "🔍 Analyze",
+        "analysis_complete": "✅ Analysis Complete!",
+        "disease": "Disease",
+        "confidence": "Confidence",
+        "severity": "Severity",
+        "image_recognition_unavailable": "⚠️ Image recognition not available",
+        "soil_check": "### 🧪 Soil Check",
+        "soil_ph": "Soil pH",
+        "nitrogen": "Nitrogen (mg/kg)",
+        "phosphorus": "Phosphorus (mg/kg)",
+        "potassium": "Potassium (mg/kg)",
+        "organic_matter": "Organic Matter (%)",
+        "moisture": "Moisture (%)",
+        "save_soil_test": "💾 Save Soil Test",
+        "saved": "✅ Saved!",
+        "recommendations": "### 📋 Recommendations:",
+        "acidic_soil": "🔴 **Acidic Soil**: Apply lime (CaCO3)",
+        "alkaline_soil": "🔴 **Alkaline Soil**: Apply sulfur or organic matter",
+        "ideal_ph": "✅ **Ideal pH**: Between 6.5-7.5",
+        "low_nitrogen": "🟡 **Low Nitrogen**: Apply NPK 20:20:0",
+        "high_nitrogen": "🟡 **High Nitrogen**: Reduce nitrogen fertilizer",
+        "ideal_nitrogen": "✅ **Ideal Nitrogen**: Good level",
+        "low_phosphorus": "🟡 **Low Phosphorus**: Apply DAP or SSP",
+        "ideal_phosphorus": "✅ **Ideal Phosphorus**: Good level",
+        "low_potassium": "🟡 **Low Potassium**: Apply KCl or MOP",
+        "ideal_potassium": "✅ **Ideal Potassium**: Good level",
+        "yield_prediction": "### 📈 Crop Yield Prediction",
+        "temp_celsius": "Temperature (°C)",
+        "humidity_percent": "Humidity (%)",
+        "rainfall_mm": "Rainfall (mm)",
+        "predict_yield": "🔮 Predict Yield",
+        "estimated_yield": "📈 Estimated Yield:",
+        "quintal_hectare": "quintal/hectare",
+        "high_yield": "✅ High yield expected!",
+        "average_yield": "📊 Average yield expected",
+        "low_yield": "⚠️ Low yield possible. Check soil and weather",
+        "profile_settings": "### 👤 Profile & Settings",
+        "choose_option": "Choose Option",
+        "login": "🔐 Login",
+        "register": "📝 Register",
+        "login_title": "Login",
+        "username": "Username",
+        "password": "Password",
+        "login_btn": "Login",
+        "login_success": "✅ Login successful!",
+        "invalid_credentials": "❌ Invalid credentials",
+        "register_title": "Create New Account",
+        "email": "Email",
+        "register_btn": "Register",
+        "registration_success": "✅ Registration successful! Login now",
+        "logged_in_as": "✅ Logged in as:",
+        "logout_btn": "Logout",
+        "footer": "🌾 Farmer Copilot v4.0 - For All Farmers | 🚜 Easy, Simple, and Free",
+        "kharif": "Kharif",
+        "rabi": "Rabi",
+        "summer": "Summer",
+        "wheat": "Wheat",
+        "rice": "Rice",
+        "cotton": "Cotton",
+        "sugarcane": "Sugarcane",
+        "potato": "Potato",
+        "tomato": "Tomato",
+        "onion": "Onion",
+        "corn": "Corn",
+    },
+    
+    "Marathi": {
+        "title": "🌾 शेतकरी सहकार v4.0",
+        "subtitle": "🎤 आवाजाने बोला - सोपे आणि सरल!",
+        "settings": "⚙️ सेटिंग्स",
+        "location": "📍 आपले स्थान",
+        "language": "🌐 भाषा",
+        "alerts": "🔔 सूचना",
+        "all_conditions_normal": "✅ सर्व स्थिती सामान्य आहे!",
+        "frost_risk": "❄️ हिमांकाचा धोका! नाजूक पिकांचे संरक्षण करा",
+        "high_temp": "🔥 उच्च तापमान! सिंचाई वाढवा",
+        "high_humidity": "🦠 उच्च आर्द्रता! बुरशी रोगांसाठी सावधान रहा",
+        "voice_assistant": "🗣️ आवाज सहायक",
+        "weather": "🌤️ हवामान",
+        "market": "💰 बाजार",
+        "crops": "🌱 पिके",
+        "pests": "🐛 कीटक",
+        "irrigation": "💧 सिंचन",
+        "analytics": "📊 विश्लेषण",
+        "disease": "📸 रोग",
+        "other": "🎤 इतर",
+        "soil": "🧪 मातीचा",
+        "yield": "📈 उत्पादन",
+        "profile": "👤 प्रोफाइल",
+        "speak_with_voice": "### 🎤 आवाजाने बोला",
+        "what_you_want": "#### तुम्हाला काय जाणून घ्यायचे आहे?",
+        "rainfall_info": "पाऊस माहिती",
+        "pest_problem": "कीटक समस्या",
+        "market_prices": "बाजार दर",
+        "speak_question": "🎙️ आवाजाने प्रश्न विचारा",
+        "microphone_on": "🎙️ मायक्रोफोन चालू करा",
+        "hear_answer": "🔊 उत्तर ऐका",
+        "listening": "🎙️ ऐकतो आहे... बोला!",
+        "you_said": "तुम्ही म्हणालात:",
+        "weather_unavailable": "हवामान डेटा उपलब्ध नाही",
+        "upload_photo_disease": "📸 रोग टॅबमध्ये पान फोटो अपलोड करा",
+        "go_disease_tab": "कृपया रोग टॅबमध्ये जा आणि पान फोटो अपलोड करा",
+        "browser_no_mic": "आपल्या ब्राउजरला मायक्रोफोन समर्थन नाही",
+        "weather_info": "### 🌤️ हवामान माहिती",
+        "refresh_weather": "🔄 हवामान ताजे करा",
+        "loading": "डेटा लोड ह���त आहे...",
+        "temperature": "🌡️ तापमान",
+        "humidity": "💧 आर्द्रता",
+        "wind": "💨 वारा",
+        "market_prices_title": "### 💰 बाजार दर",
+        "refresh_prices": "🔄 दर ताजे करा",
+        "per_quintal": "/क्विंटल",
+        "crop_suggestions": "### 🌱 पिकांचे सूचन",
+        "best_crops": "📍 आपल्या प्रदेशासाठी उत्तम पिके: कपास, गहू, तांदूळ, ऊस",
+        "current_season": "📅 ऋतु:",
+        "pest_management": "### 🐛 कीटक व्यवस्थापन",
+        "pest_info": "कीटक ओळख आणि नियंत्रण सूचना येथे",
+        "irrigation_management": "### 💧 सिंचन व्यवस्थापन",
+        "irrigation_info": "स्मार्ट सिंचन वेळापत्रक आणि जल संरक्षण सूचना",
+        "farm_analytics": "### 📊 शेत विश्लेषण",
+        "analytics_info": "लाभ गणना आणि शेत सांख्यिकी येथे",
+        "disease_detection": "### 📸 रोग शोध (पान फोटो अपलोड करा)",
+        "upload_leaf": "📷 पान फोटो निवडा",
+        "your_photo": "आपला फोटो",
+        "analyze": "🔍 विश्लेषण करा",
+        "analysis_complete": "✅ विश्लेषण पूर्ण!",
+        "disease": "रोग",
+        "confidence": "आत्मविश्वास",
+        "severity": "तीव्रता",
+        "image_recognition_unavailable": "⚠️ प्रतिमा ओळख उपलब्ध नाही",
+        "soil_check": "### 🧪 माती तपासा",
+        "soil_ph": "मातीचा pH",
+        "nitrogen": "नायट्रोजन (मिग्रा/किग्रा)",
+        "phosphorus": "फॉस्फरस (मिग्रा/किग्रा)",
+        "potassium": "पोटॅशियम (मिग्रा/किग्रा)",
+        "organic_matter": "सेंद्रिय पदार्थ (%)",
+        "moisture": "ओलावा (%)",
+        "save_soil_test": "💾 माती चाचणी सेव्ह करा",
+        "saved": "✅ सेव्ह केले!",
+        "recommendations": "### 📋 सूचना:",
+        "acidic_soil": "🔴 **अम्लीय माती**: चूना (CaCO3) लावा",
+        "alkaline_soil": "🔴 **क्षारीय माती**: गंधक किंवा सेंद्रिय पदार्थ लावा",
+        "ideal_ph": "✅ **आदर्श pH**: 6.5-7.5 दरम्यान",
+        "low_nitrogen": "🟡 **कमी नायट्रोजन**: NPK 20:20:0 लावा",
+        "high_nitrogen": "🟡 **उच्च नायट्रोजन**: नायट्रोजन कमी करा",
+        "ideal_nitrogen": "✅ **आदर्श नायट्रोजन**: चांगला स्तर",
+        "low_phosphorus": "🟡 **कमी फॉस्फरस**: DAP किंवा SSP लावा",
+        "ideal_phosphorus": "✅ **आदर्श फॉस्फरस**: चांगला स्तर",
+        "low_potassium": "🟡 **कमी पोटॅशियम**: KCl किंवा MOP लावा",
+        "ideal_potassium": "✅ **आदर्श पोटॅशियम**: चांगला स्तर",
+        "yield_prediction": "### 📈 पिक उत्पादन अंदाज",
+        "temp_celsius": "तापमान (°C)",
+        "humidity_percent": "आर्द्रता (%)",
+        "rainfall_mm": "पाऊस (मिमी)",
+        "predict_yield": "🔮 उत्पादन अंदाज लावा",
+        "estimated_yield": "📈 अंदाजे उत्पादन:",
+        "quintal_hectare": "क्विंटल/हेक्टर",
+        "high_yield": "✅ उच्च उत्पादन अपेक्षित आहे!",
+        "average_yield": "📊 सरासरी उत्पादन अपेक्षित आहे",
+        "low_yield": "⚠️ कमी उत्पादन संभव आहे। माती आणि हवामान तपासा",
+        "profile_settings": "### 👤 प्रोफाइल आणि सेटिंग्स",
+        "choose_option": "पर्याय निवडा",
+        "login": "🔐 लॉगिन",
+        "register": "📝 नोंदणी",
+        "login_title": "लॉगिन करा",
+        "username": "वापरकर्ता नाव",
+        "password": "पासवर्ड",
+        "login_btn": "लॉगिन",
+        "login_success": "✅ लॉगिन यशस्वी!",
+        "invalid_credentials": "❌ अयोग्य क्रेडेंशियल्स",
+        "register_title": "नवीन खाते तयार करा",
+        "email": "ईमेल",
+        "register_btn": "नोंदणी",
+        "registration_success": "✅ नोंदणी यशस्वी! आता लॉगिन करा",
+        "logged_in_as": "✅ लॉगिन केले आहे:",
+        "logout_btn": "लॉगआउट",
+        "footer": "🌾 शेतकरी सहकार v4.0 - सर्व शेतकर्यांसाठी | 🚜 सोपे, सरल आणि विनामूल्य",
+        "kharif": "खरीफ",
+        "rabi": "रबी",
+        "summer": "उन्हाळा",
+        "wheat": "गहू",
+        "rice": "तांदूळ",
+        "cotton": "कपास",
+        "sugarcane": "ऊस",
+        "potato": "बटाटा",
+        "tomato": "टमाटर",
+        "onion": "कांदा",
+        "corn": "मक्का",
+    }
+}
+
+def t(key):
+    """Translate a key based on user's language preference"""
+    lang = st.session_state.get("language", "Hindi")
+    return TRANSLATIONS.get(lang, TRANSLATIONS["Hindi"]).get(key, key)
+
+# ════════════════════════════════════════════════════════════════════════════
+# STREAMLIT PAGE CONFIG
+# ════════════════════════════════════════════════════════════════════════════
+
+st.set_page_config(
+    page_title="🌾 Farmer Copilot v4.0",
+    page_icon="🚜",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# ════════════════════════════════════════════════════════════════════════════
+# CUSTOM CSS
+# ════════════════════════════════════════════════════════════════════════════
+
+def inject_css():
+    st.markdown("""
+    <style>
+    .main { 
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        padding: 20px;
+    }
+    [data-testid="stSidebar"] { 
+        background: linear-gradient(180deg, #1a472a 0%, #2d5a3d 100%);
+    }
+    h1, h2, h3 { 
+        color: #1a472a; 
+        font-weight: 700;
+        text-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .stButton > button {
+        background: linear-gradient(135deg, #2d915e 0%, #1a472a 100%);
+        color: white;
+        font-weight: bold;
+        border: none;
+        border-radius: 12px;
+        padding: 15px 30px;
+        font-size: 18px;
+        transition: all 0.3s ease;
+        cursor: pointer;
+    }
+    .stButton > button:hover {
+        box-shadow: 0 4px 12px rgba(45, 145, 94, 0.4);
+        transform: scale(1.05);
+    }
+    .big-emoji {
+        font-size: 60px;
+        text-align: center;
+        margin: 20px 0;
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #32B899 0%, #2180A0 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+inject_css()
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 1: VOICE I/O
+# ════════════════════════════════════════════════════════════════════════════
+
+def voice_input(language="en-IN"):
+    """Capture voice input from microphone"""
+    if not VOICE_AVAILABLE:
+        return None, "Voice feature not available"
+    
+    try:
+        recognizer = sr.Recognizer()
+        with sr.Microphone() as source:
+            st.info(t("listening"))
+            recognizer.adjust_for_ambient_noise(source, duration=1)
+            audio = recognizer.listen(source, timeout=10)
+        
+        text = recognizer.recognize_google(audio, language=language)
+        return text, None
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+def voice_output(text, language="en"):
+    """Convert text to speech"""
+    if not VOICE_AVAILABLE:
+        return
+    
+    try:
+        tts = gTTS(text=text, lang=language, slow=True)
+        audio_file = "response.mp3"
+        tts.save(audio_file)
+        
+        with open(audio_file, "rb") as f:
+            audio_bytes = f.read()
+        st.audio(audio_bytes, format="audio/mp3")
+        
+        if os.path.exists(audio_file):
+            os.remove(audio_file)
+    except Exception as e:
+        st.error(f"Voice error: {str(e)}")
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 2: IMAGE RECOGNITION
+# ════════════════════════════════════════════════════════════════════════════
+
+@st.cache_resource
+def load_disease_model():
+    """Load pre-trained disease detection model"""
+    if not IMAGE_RECOGNITION_AVAILABLE:
+        return None
+    try:
+        model = tf.keras.applications.MobileNetV2(
+            weights='imagenet',
+            input_shape=(224, 224, 3)
+        )
+        return model
+    except:
+        return None
+
+def analyze_plant_disease(image_file):
+    """Analyze plant leaf for diseases"""
+    if not IMAGE_RECOGNITION_AVAILABLE:
+        return None, "Image recognition not available"
+    
+    try:
+        image = Image.open(image_file).convert('RGB')
+        image_array = np.array(image.resize((224, 224))) / 255.0
+        image_array = np.expand_dims(image_array, axis=0)
+        
+        model = load_disease_model()
+        if model is None:
+            return None, "Model not loaded"
+        
+        predictions = model.predict(image_array)
+        disease_map = {
+            0: "Early Blight - Treatment: Spray fungicide",
+            1: "Late Blight - Treatment: Spray mancozeb",
+            2: "Powdery Mildew - Treatment: Apply sulfur powder",
+            3: "Leaf Spot - Treatment: Spray neem oil",
+            4: "Healthy Plant - No disease!"
+        }
+        
+        predicted_disease_idx = np.argmax(predictions[0])
+        confidence = float(predictions[0][predicted_disease_idx]) * 100
+        disease_name = disease_map.get(predicted_disease_idx, "Unknown")
+        
+        return {
+            "disease": disease_name,
+            "confidence": confidence,
+            "severity": "High" if confidence > 80 else "Medium" if confidence > 50 else "Low"
+        }, None
+        
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 3: DATABASES
+# ════════════════════════════════════════════════════════════════════════════
+
+def init_farm_database():
+    """Initialize SQLite database for farm data"""
+    conn = sqlite3.connect('farm_data.db')
+    c = conn.cursor()
+    c.execute('''CREATE TABLE IF NOT EXISTS yields
+                 (id INTEGER PRIMARY KEY, date TEXT, crop TEXT, area REAL, yield REAL, location TEXT)''')
+    conn.commit()
+    conn.close()
+
+def save_farm_data(crop, area, yield_amount, location):
+    """Save yield data to database"""
+    conn = sqlite3.connect('farm_data.db')
+    c = conn.cursor()
+    date = datetime.now().strftime("%Y-%m-%d")
+    c.execute('INSERT INTO yields VALUES (NULL, ?, ?, ?, ?, ?)',
+              (date, crop, area, yield_amount, location))
+    conn.commit()
+    conn.close()
+
+def init_soil_database():
+    """Initialize soil data database"""
+    conn = sqlite3.connect('soil_data.db')
+    c = conn.cursor()
+    c.execute('''CREATE TABLE IF NOT EXISTS soil_tests
+                 (id INTEGER PRIMARY KEY, date TEXT, location TEXT, pH REAL, nitrogen INTEGER, 
+                  phosphorus INTEGER, potassium INTEGER, organic_matter REAL, moisture REAL)''')
+    conn.commit()
+    conn.close()
+
+def save_soil_test(location, pH, nitrogen, phosphorus, potassium, organic_matter, moisture):
+    """Save soil test results"""
+    conn = sqlite3.connect('soil_data.db')
+    c = conn.cursor()
+    date = datetime.now().strftime("%Y-%m-%d")
+    c.execute('''INSERT INTO soil_tests VALUES (NULL, ?, ?, ?, ?, ?, ?, ?, ?)''',
+              (date, location, pH, nitrogen, phosphorus, potassium, organic_matter, moisture))
+    conn.commit()
+    conn.close()
+
+def get_soil_recommendations(pH, nitrogen, phosphorus, potassium):
+    """Get fertilizer recommendations"""
+    recommendations = []
+    
+    if pH < 6.0:
+        recommendations.append(t("acidic_soil"))
+    elif pH > 8.0:
+        recommendations.append(t("alkaline_soil"))
+    else:
+        recommendations.append(t("ideal_ph"))
+    
+    if nitrogen < 200:
+        recommendations.append(t("low_nitrogen"))
+    elif nitrogen > 500:
+        recommendations.append(t("high_nitrogen"))
+    else:
+        recommendations.append(t("ideal_nitrogen"))
+    
+    if phosphorus < 10:
+        recommendations.append(t("low_phosphorus"))
+    else:
+        recommendations.append(t("ideal_phosphorus"))
+    
+    if potassium < 100:
+        recommendations.append(t("low_potassium"))
+    else:
+        recommendations.append(t("ideal_potassium"))
+    
+    return recommendations
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 4: ML YIELD PREDICTION
+# ════════════════════════════════════════════════════════════════════════════
+
+def train_yield_model():
+    """Train ML model for yield prediction"""
+    if not ML_AVAILABLE:
+        return None, None
+    
+    X_train = np.array([
+        [25, 80, 250, 6.5, 2.5],
+        [28, 70, 200, 6.5, 3.0],
+        [22, 85, 300, 6.8, 2.8],
+        [26, 75, 250, 7.0, 3.2],
+    ])
+    
+    y_train = np.array([25.5, 23.0, 28.5, 26.0])
+    
+    model = RandomForestRegressor(n_estimators=100, random_state=42)
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X_train)
+    model.fit(X_scaled, y_train)
+    
+    joblib.dump(model, 'yield_model.pkl')
+    joblib.dump(scaler, 'scaler.pkl')
+    
+    return model, scaler
+
+@st.cache_resource
+def load_yield_model():
+    """Load trained yield prediction model"""
+    if not ML_AVAILABLE:
+        return None, None
+    try:
+        model = joblib.load('yield_model.pkl')
+        scaler = joblib.load('scaler.pkl')
+        return model, scaler
+    except:
+        return None, None
+
+def predict_yield(temperature, humidity, rainfall, pH, organic_matter):
+    """Predict crop yield"""
+    if not ML_AVAILABLE:
+        return 22.0
+    
+    model, scaler = load_yield_model()
+    
+    if model is None:
+        model, scaler = train_yield_model()
+    
+    if model is None:
+        return 22.0
+    
+    features = np.array([[temperature, humidity, rainfall, pH, organic_matter]])
+    features_scaled = scaler.transform(features)
+    
+    yield_pred = model.predict(features_scaled)[0]
+    
+    return max(0, yield_pred)
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 5: WEATHER & ALERTS
+# ════════════════════════════════════════════════════════════════════════════
+
+def get_weather_data(location: str) -> Optional[Dict]:
+    """Get weather from OpenWeatherMap"""
+    try:
+        api_key = None
+        try:
+            if hasattr(st, 'secrets') and "OPENWEATHER_API_KEY" in st.secrets:
+                api_key = st.secrets["OPENWEATHER_API_KEY"]
+        except:
+            pass
+        
+        if not api_key:
+            api_key = os.environ.get("OPENWEATHER_API_KEY", "")
+        
+        if not api_key:
+            return None
+        
+        geo_url = "https://api.openweathermap.org/geo/1.0/direct"
+        geo_params = {"q": location, "limit": 1, "appid": api_key}
+        geo_resp = requests.get(geo_url, params=geo_params, timeout=5)
+        
+        if not geo_resp.json():
+            return None
+        
+        lat, lon = geo_resp.json()[0]['lat'], geo_resp.json()[0]['lon']
+        
+        weather_url = "https://api.openweathermap.org/data/2.5/weather"
+        weather_params = {"lat": lat, "lon": lon, "appid": api_key, "units": "metric"}
+        weather_resp = requests.get(weather_url, params=weather_params, timeout=5)
+        data = weather_resp.json()
+        
+        return {
+            'temperature': data['main']['temp'],
+            'humidity': data['main']['humidity'],
+            'pressure': data['main']['pressure'],
+            'wind_speed': data['wind']['speed'],
+            'description': data['weather'][0]['description'],
+            'location': data['name']
+        }
+    except:
+        return None
+
+def get_current_season() -> str:
+    """Get current agricultural season"""
+    month = datetime.now().month
+    if month in [6, 7, 8, 9]:
+        return t("kharif")
+    elif month in [10, 11, 12, 1, 2]:
+        return t("rabi")
+    else:
+        return t("summer")
+
+def check_weather_alerts(weather_data):
+    """Check weather for farming alerts"""
+    alerts = []
+    
+    if weather_data:
+        temp = weather_data.get('temperature', 0)
+        humidity = weather_data.get('humidity', 0)
+        
+        if temp < 0:
+            alerts.append({'message': t("frost_risk"), 'severity': 'HIGH'})
+        elif temp > 40:
+            alerts.append({'message': t("high_temp"), 'severity': 'HIGH'})
+        
+        if humidity > 85:
+            alerts.append({'message': t("high_humidity"), 'severity': 'MEDIUM'})
+    
+    return alerts
+
+def display_alerts():
+    """Display all alerts in sidebar"""
+    with st.sidebar:
+        st.markdown(f"### {t('alerts')}")
+        
+        all_alerts = []
+        
+        try:
+            weather = get_weather_data(st.session_state.location)
+            all_alerts.extend(check_weather_alerts(weather))
+        except:
+            pass
+        
+        if all_alerts:
+            for alert in all_alerts:
+                if alert['severity'] == 'HIGH':
+                    st.error(alert['message'])
+                elif alert['severity'] == 'MEDIUM':
+                    st.warning(alert['message'])
+                else:
+                    st.info(alert['message'])
+        else:
+            st.success(t("all_conditions_normal"))
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 6: MARKET PRICES
+# ════════════════════════════════════════════════════════════════════════════
+
+@st.cache_data(ttl=3600)
+def get_live_market_prices():
+    """Get live market prices"""
+    return {
+        t("wheat"): 2250, 
+        t("rice"): 2650, 
+        t("cotton"): 5800, 
+        t("sugarcane"): 295,
+        t("potato"): 1650, 
+        t("tomato"): 1350, 
+        t("onion"): 1950, 
+        t("corn"): 2000
+    }
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 7: USER AUTHENTICATION
+# ════════════════════════════════════════════════════════════════════════════
+
+def init_user_database():
+    """Initialize user database"""
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('''CREATE TABLE IF NOT EXISTS users
+                 (id INTEGER PRIMARY KEY, username TEXT UNIQUE, password TEXT, email TEXT, location TEXT, created_date TEXT)''')
+    conn.commit()
+    conn.close()
+
+def hash_password(password):
+    """Hash password"""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def register_user(username, password, email, location):
+    """Register new user"""
+    try:
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        hashed_pwd = hash_password(password)
+        date = datetime.now().strftime("%Y-%m-%d")
+        c.execute('INSERT INTO users VALUES (NULL, ?, ?, ?, ?, ?)',
+                  (username, hashed_pwd, email, location, date))
+        conn.commit()
+        conn.close()
+        return True, "User registered successfully!"
+    except sqlite3.IntegrityError:
+        return False, "Username already exists"
+    except Exception as e:
+        return False, str(e)
+
+def login_user(username, password):
+    """Login user"""
+    try:
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        hashed_pwd = hash_password(password)
+        c.execute('SELECT * FROM users WHERE username=? AND password=?', (username, hashed_pwd))
+        user = c.fetchone()
+        conn.close()
+        return (True, user) if user else (False, "Invalid credentials")
+    except Exception as e:
+        return False, str(e)
+
+# ════════════════════════════════════════════════════════════════════════════
+# SESSION STATE INITIALIZATION
+# ════════════════════════════════════════════════════════════════════════════
+
+if "location" not in st.session_state:
+    st.session_state.location = "महाराष्ट्र"
+if "language" not in st.session_state:
+    st.session_state.language = "Hindi"
+if "user_authenticated" not in st.session_state:
+    st.session_state.user_authenticated = False
+    st.session_state.username = None
+if 'db_initialized' not in st.session_state:
+    init_farm_database()
+    init_soil_database()
+    init_user_database()
+    st.session_state.db_initialized = True
+
+# ════════════════════════════════════════════════════════════════════════════
+# SIDEBAR - LANGUAGE SELECTION
+# ════════════════════��═══════════════════════════════════════════════════════
+
+with st.sidebar:
+    st.markdown(f"### {t('settings')}")
+    
+    location = st.selectbox(
+        t("location"),
+        ["महाराष्ट्र", "पंजाब", "हरियाणा", "उत्तर प्रदेश", "कर्नाटक", "राजस्थान"],
+        key="sidebar_location_key"
+    )
+    st.session_state.location = location
+    
+    language = st.selectbox(
+        t("language"),
+        ["Hindi", "English", "Marathi"],
+        index=["Hindi", "English", "Marathi"].index(st.session_state.language) if st.session_state.language in ["Hindi", "English", "Marathi"] else 0,
+        key="sidebar_language_key"
+    )
+    
+    if language != st.session_state.language:
+        st.session_state.language = language
+        st.rerun()
+    
+    st.divider()
+    display_alerts()
+
+# ════════════════════════════════════════════════════════════════════════════
+# MAIN CONTENT
+# ════════════════════════════════════════════════════════════════════════════
+
+st.markdown(f"# {t('title')}")
+st.markdown(f"### {t('subtitle')}")
+st.divider()
+
+# DEFINE TABS WITH UNIQUE KEYS
+tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8, tab9, tab10, tab11, tab12 = st.tabs([
+    t("voice_assistant"), t("weather"), t("market"), t("crops"), 
+    t("pests"), t("irrigation"), t("analytics"), t("disease"), 
+    t("other"), t("soil"), t("yield"), t("profile")
+])
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 1: VOICE INTERACTION
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab1:
+    st.markdown(t("speak_with_voice"))
+    st.markdown(t("what_you_want"))
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("<div class='big-emoji'>🌧️</div>", unsafe_allow_html=True)
+        if st.button(t("rainfall_info"), key="voice_rainfall_btn", use_container_width=True):
+            with st.spinner("..."):
+                weather = get_weather_data(st.session_state.location)
+                if weather:
+                    msg = f"Temperature {weather['temperature']:.0f}°C, Humidity {weather['humidity']}%"
+                    st.success(msg)
+                    if VOICE_AVAILABLE:
+                        lang_code = "hi" if st.session_state.language == "Hindi" else "mr" if st.session_state.language == "Marathi" else "en"
+                        voice_output(msg, language=lang_code)
+                else:
+                    st.info(t("weather_unavailable"))
+    
+    with col2:
+        st.markdown("<div class='big-emoji'>🐛</div>", unsafe_allow_html=True)
+        if st.button(t("pest_problem"), key="voice_pest_btn", use_container_width=True):
+            st.info(t("upload_photo_disease"))
+            if VOICE_AVAILABLE:
+                lang_code = "hi" if st.session_state.language == "Hindi" else "mr" if st.session_state.language == "Marathi" else "en"
+                voice_output(t("go_disease_tab"), language=lang_code)
+    
+    with col3:
+        st.markdown("<div class='big-emoji'>💱</div>", unsafe_allow_html=True)
+        if st.button(t("market_prices"), key="voice_market_btn", use_container_width=True):
+            prices = get_live_market_prices()
+            price_list = ", ".join([f"{crop}: ₹{price}" for crop, price in list(prices.items())[:3]])
+            st.success(price_list)
+            if VOICE_AVAILABLE:
+                lang_code = "hi" if st.session_state.language == "Hindi" else "mr" if st.session_state.language == "Marathi" else "en"
+                voice_output(price_list, language=lang_code)
+    
+    st.divider()
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown(f"<h3 style='text-align: center;'>{t('speak_question')}</h3>", unsafe_allow_html=True)
+        if st.button(t("microphone_on"), key="voice_listen_btn", use_container_width=True):
+            if VOICE_AVAILABLE:
+                lang_code = "hi-IN" if st.session_state.language == "Hindi" else "mr-IN" if st.session_state.language == "Marathi" else "en-IN"
+                text, error = voice_input(language=lang_code)
+                if error:
+                    st.error(error)
+                elif text:
+                    st.success(f"{t('you_said')} {text}")
+    
+    with col2:
+        st.markdown(f"<h3 style='text-align: center;'>{t('hear_answer')}</h3>", unsafe_allow_html=True)
+        if st.button("🔊 Replay", key="voice_replay_btn", use_container_width=True):
+            if VOICE_AVAILABLE:
+                lang_code = "hi" if st.session_state.language == "Hindi" else "mr" if st.session_state.language == "Marathi" else "en"
+                voice_output("Thank you for using Farmer Copilot", language=lang_code)
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 2: WEATHER
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab2:
+    st.markdown(t("weather_info"))
+    
+    if st.button(t("refresh_weather"), key="weather_refresh_btn", use_container_width=True):
+        with st.spinner(t("loading")):
+            weather = get_weather_data(st.session_state.location)
+        if weather:
+            col1, col2, col3, col4 = st.columns(4)
+            col1.metric(t("temperature"), f"{weather['temperature']:.1f}°C")
+            col2.metric(t("humidity"), f"{weather['humidity']}%")
+            col3.metric(t("wind"), f"{weather['wind_speed']:.1f} m/s")
+            col4.metric(t("location"), weather['location'])
+        else:
+            st.warning(t("weather_unavailable"))
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 3: MARKET PRICES
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab3:
+    st.markdown(t("market_prices_title"))
+    
+    if st.button(t("refresh_prices"), key="market_refresh_btn", use_container_width=True):
+        live_prices = get_live_market_prices()
+        if live_prices:
+            cols = st.columns(2)
+            crops_list = list(live_prices.keys())
+            
+            for idx, crop in enumerate(crops_list):
+                col = cols[idx % 2]
+                col.metric(crop, f"₹{live_prices[crop]}{t('per_quintal')}")
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 4-7: PLACEHOLDER TABS
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab4:
+    st.markdown(t("crop_suggestions"))
+    st.info(t("best_crops"))
+    st.write(f"{t('current_season')} {get_current_season()}")
+
+with tab5:
+    st.markdown(t("pest_management"))
+    st.info(t("pest_info"))
+
+with tab6:
+    st.markdown(t("irrigation_management"))
+    st.info(t("irrigation_info"))
+
+with tab7:
+    st.markdown(t("farm_analytics"))
+    st.info(t("analytics_info"))
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 8: IMAGE RECOGNITION
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab8:
+    st.markdown(t("disease_detection"))
+    
+    uploaded_file = st.file_uploader(t("upload_leaf"), type=['jpg', 'jpeg', 'png'], key="image_uploader_key")
+    
+    if uploaded_file:
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            image = Image.open(uploaded_file)
+            st.image(image, caption=t("your_photo"), use_column_width=True)
+        
+        with col2:
+            if st.button(t("analyze"), key="image_analyze_btn"):
+                if IMAGE_RECOGNITION_AVAILABLE:
+                    result, error = analyze_plant_disease(uploaded_file)
+                    if error:
+                        st.error(error)
+                    else:
+                        st.success(t("analysis_complete"))
+                        st.metric(t("disease"), result['disease'].split('-')[0])
+                        st.metric(t("confidence"), f"{result['confidence']:.1f}%")
+                        st.metric(t("severity"), result['severity'])
+                else:
+                    st.warning(t("image_recognition_unavailable"))
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 9: MISC
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab9:
+    st.markdown(f"### 🎤 {t('other')}")
+    st.info("Additional voice options")
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 10: SOIL HEALTH
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab10:
+    st.markdown(t("soil_check"))
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        pH = st.slider(t("soil_ph"), 4.0, 9.0, 6.5, key="soil_pH_slider_tab10")
+        nitrogen = st.slider(t("nitrogen"), 0, 1000, 250, key="soil_nitrogen_slider_tab10")
+    with col2:
+        phosphorus = st.slider(t("phosphorus"), 0, 100, 20, key="soil_phosphorus_slider_tab10")
+        potassium = st.slider(t("potassium"), 0, 500, 150, key="soil_potassium_slider_tab10")
+    with col3:
+        organic_matter = st.slider(t("organic_matter"), 0.0, 10.0, 2.5, key="soil_organic_slider_tab10")
+        moisture = st.slider(t("moisture"), 0.0, 50.0, 25.0, key="soil_moisture_slider_tab10")
+    
+    if st.button(t("save_soil_test"), key="soil_save_btn_tab10", use_container_width=True):
+        save_soil_test(st.session_state.location, pH, nitrogen, phosphorus, potassium, organic_matter, moisture)
+        st.success(t("saved"))
+    
+    recommendations = get_soil_recommendations(pH, nitrogen, phosphorus, potassium)
+    st.markdown(t("recommendations"))
+    for rec in recommendations:
+        st.markdown(rec)
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 11: YIELD PREDICTION
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab11:
+    st.markdown(t("yield_prediction"))
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        temp = st.slider(t("temp_celsius"), 0, 45, 25, key="yield_temp_slider_tab11")
+        humidity = st.slider(t("humidity_percent"), 0, 100, 70, key="yield_humidity_slider_tab11")
+    with col2:
+        rainfall = st.slider(t("rainfall_mm"), 0, 500, 250, key="yield_rainfall_slider_tab11")
+        pH = st.slider(t("soil_ph"), 4.0, 9.0, 6.8, key="yield_pH_slider_tab11")
+    with col3:
+        org_matter = st.slider(t("organic_matter"), 0.0, 10.0, 2.5, key="yield_orgmatter_slider_tab11")
+    
+    if st.button(t("predict_yield"), key="yield_predict_btn_tab11", use_container_width=True):
+        yield_pred = predict_yield(temp, humidity, rainfall, pH, org_matter)
+        st.success(f"{t('estimated_yield')} {yield_pred:.1f} {t('quintal_hectare')}")
+        
+        if yield_pred > 25:
+            st.info(t("high_yield"))
+        elif yield_pred > 20:
+            st.info(t("average_yield"))
+        else:
+            st.warning(t("low_yield"))
+
+# ════════════════════════════════════════════════════════════════════════════
+# TAB 12: USER PROFILE
+# ════════════════════════════════════════════════════════════════════════════
+
+with tab12:
+    st.markdown(t("profile_settings"))
+    
+    if not st.session_state.user_authenticated:
+        auth_choice = st.radio(t("choose_option"), [t("login"), t("register")], key="auth_choice_radio_tab12")
+        
+        if auth_choice == t("login"):
+            st.subheader(t("login_title"))
+            
+            username = st.text_input(t("username"), key="login_username_tab12")
+            password = st.text_input(t("password"), type="password", key="login_password_tab12")
+            
+            if st.button(t("login_btn"), key="login_btn_tab12", use_container_width=True):
+                success, result = login_user(username, password)
+                
+                if success:
+                    st.session_state.user_authenticated = True
+                    st.session_state.username = username
+                    st.success(t("login_success"))
+                    st.rerun()
+                else:
+                    st.error(t("invalid_credentials"))
+        
+        else:
+            st.subheader(t("register_title"))
+            
+            new_username = st.text_input(t("username"), key="register_username_tab12")
+            new_email = st.text_input(t("email"), key="register_email_tab12")
+            new_password = st.text_input(t("password"), type="password", key="register_password_tab12")
+            
+            if st.button(t("register_btn"), key="register_btn_tab12", use_container_width=True):
+                success, msg = register_user(new_username, new_password, new_email, st.session_state.location)
+                
+                if success:
+                    st.success(t("registration_success"))
+                else:
+                    st.error(f"❌ {msg}")
+    
+    else:
+        st.success(f"{t('logged_in_as')} **{st.session_state.username}**")
+        
+        if st.button(t("logout_btn"), key="logout_btn_tab12", use_container_width=True):
+            st.session_state.user_authenticated = False
+            st.session_state.username = None
+            st.rerun()
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.divider()
+st.markdown(f"<div style='text-align: center'><p>{t('footer')}</p></div>", unsafe_allow_html=True)