Update src/streamlit_app.py

src/streamlit_app.py

@@ -3,9 +3,8 @@ 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
+from typing import Optional, Dict, List, Any
 import json
 from io import BytesIO
 from PIL import Image
@@ -14,9 +13,12 @@ import os
 import sqlite3
 import hashlib
 
-# ════════════════════════════════════════════════════════════════════════════
-# OPTIONAL DEPENDENCIES WITH FALLBACK
-# ════════════════════════════════════════════════════════════════════════════
+# OpenAI Integration
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
 
 # Image Recognition
 try:
@@ -62,404 +64,17 @@ except ImportError:
 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_title="🌾 Farmer Copilot v3.0 - Complete",
     page_icon="🚜",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# ════════════════════════════════════════════════════════════════════════════
-# CUSTOM CSS
-# ════════════════════════════════════════════════════════════════════════════
-
 def inject_css():
     st.markdown("""
     <style>
@@ -480,27 +95,13 @@ def inject_css():
         color: white;
         font-weight: bold;
         border: none;
-        border-radius: 12px;
-        padding: 15px 30px;
-        font-size: 18px;
+        border-radius: 8px;
+        padding: 10px 24px;
         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);
+        transform: translateY(-2px);
     }
     </style>
     """, unsafe_allow_html=True)
@@ -508,47 +109,7 @@ def inject_css():
 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
+# FEATURE 1: IMAGE RECOGNITION
 # ════════════════════════════════════════════════════════════════════════════
 
 @st.cache_resource
@@ -581,11 +142,11 @@ def analyze_plant_disease(image_file):
         
         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!"
+            0: "Early Blight - Use fungicide",
+            1: "Late Blight - Spray mancozeb",
+            2: "Powdery Mildew - Apply sulfur",
+            3: "Leaf Spot - Spray neem oil",
+            4: "Healthy Plant - No disease"
         }
         
         predicted_disease_idx = np.argmax(predictions[0])
@@ -602,15 +163,63 @@ def analyze_plant_disease(image_file):
         return None, f"Error: {str(e)}"
 
 # ════════════════════════════════════════════════════════════════════════════
-# FEATURE 3: DATABASES
+# FEATURE 2: VOICE I/O
+# ════════════════════════════════════════════════════════════════════════════
+
+def voice_input():
+    """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("🎙️ Listening...")
+            recognizer.adjust_for_ambient_noise(source, duration=1)
+            audio = recognizer.listen(source, timeout=10)
+        
+        text = recognizer.recognize_google(audio, language='en-IN')
+        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=False)
+        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 3: HISTORICAL DATA TRACKING
 # ════════════════════════════════════════════════════════════════════════════
 
 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)''')
+                 (id INTEGER PRIMARY KEY, 
+                  date TEXT, 
+                  crop TEXT, 
+                  area REAL, 
+                  yield REAL, 
+                  location TEXT)''')
+    
     conn.commit()
     conn.close()
 
@@ -618,19 +227,235 @@ 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 get_historical_yields(crop=None, days=90):
+    """Get historical yield data"""
+    conn = sqlite3.connect('farm_data.db')
+    
+    if crop:
+        df = pd.read_sql_query(
+            f"SELECT * FROM yields WHERE crop='{crop}' ORDER BY date DESC LIMIT 10",
+            conn
+        )
+    else:
+        df = pd.read_sql_query(
+            f"SELECT * FROM yields ORDER BY date DESC LIMIT 10",
+            conn
+        )
+    
+    conn.close()
+    return df
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 4: DATA EXPORT
+# ════════════════════════════════════════════════════════════════════════════
+
+def export_to_csv(data_dict, filename="farm_report"):
+    """Export data to CSV"""
+    df = pd.DataFrame(data_dict)
+    csv_buffer = BytesIO()
+    df.to_csv(csv_buffer, index=False)
+    csv_buffer.seek(0)
+    return csv_buffer, f"{filename}.csv"
+
+def export_to_excel(data_dict, filename="farm_report"):
+    """Export data to Excel"""
+    df = pd.DataFrame(data_dict)
+    excel_buffer = BytesIO()
+    
+    try:
+        with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
+            df.to_excel(writer, sheet_name='Farm Data', index=False)
+    except:
+        df.to_excel(excel_buffer, sheet_name='Farm Data', index=False)
+    
+    excel_buffer.seek(0)
+    return excel_buffer, f"{filename}.xlsx"
+
+def export_to_pdf(report_text, filename="farm_report"):
+    """Export report to PDF"""
+    if not EXPORT_AVAILABLE:
+        return None, None
+    
+    pdf_buffer = BytesIO()
+    c = canvas.Canvas(pdf_buffer, pagesize=letter)
+    
+    width, height = letter
+    y_position = height - 50
+    
+    c.setFont("Helvetica-Bold", 16)
+    c.drawString(50, y_position, "Farmer Copilot Report")
+    y_position -= 30
+    
+    c.setFont("Helvetica", 10)
+    for line in report_text.split('\n'):
+        if y_position < 50:
+            c.showPage()
+            y_position = height - 50
+        c.drawString(50, y_position, line[:80])
+        y_position -= 15
+    
+    c.save()
+    pdf_buffer.seek(0)
+    return pdf_buffer, f"{filename}.pdf"
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 5: SMART NOTIFICATIONS
+# ════════════════════════════════════════════════════════════════════════════
+
+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': '❄️ Frost Risk! Protect delicate crops', 'severity': 'HIGH'})
+        elif temp > 40:
+            alerts.append({'message': '🔥 High Temperature! Increase irrigation', 'severity': 'HIGH'})
+        
+        if humidity > 85:
+            alerts.append({'message': '🦠 High Humidity! Watch for fungal diseases', 'severity': 'MEDIUM'})
+    
+    return alerts
+
+def display_alerts():
+    """Display all alerts in sidebar"""
+    with st.sidebar:
+        st.markdown("### 🔔 Smart 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("✅ All conditions normal!")
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 6: REAL-TIME MARKET PRICES
+# ════════════════════════════════════════════════════════════════════════════
+
+@st.cache_data(ttl=3600)
+def get_live_market_prices():
+    """Get live market prices"""
+    return {
+        "Wheat": 2250, "Rice": 2650, "Cotton": 5800, "Sugarcane": 295,
+        "Potato": 1650, "Tomato": 1350, "Onion": 1950, "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)
+
+def get_user_profile(username):
+    """Get user profile"""
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    
+    c.execute('SELECT * FROM users WHERE username=?', (username,))
+    user = c.fetchone()
+    conn.close()
+    
+    return user
+
+# ════════════════════════════════════════════════════════════════════════════
+# FEATURE 8: SOIL HEALTH MONITORING
+# ════════════════════════════════════════════════════════════════════════════
+
 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)''')
+                 (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()
 
@@ -638,9 +463,13 @@ def save_soil_test(location, pH, nitrogen, phosphorus, potassium, organic_matter
     """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, ?, ?, ?, ?, ?, ?, ?, ?)''',
+    
+    c.execute('''INSERT INTO soil_tests 
+                VALUES (NULL, ?, ?, ?, ?, ?, ?, ?, ?)''',
               (date, location, pH, nitrogen, phosphorus, potassium, organic_matter, moisture))
+    
     conn.commit()
     conn.close()
 
@@ -649,33 +478,37 @@ def get_soil_recommendations(pH, nitrogen, phosphorus, potassium):
     recommendations = []
     
     if pH < 6.0:
-        recommendations.append(t("acidic_soil"))
+        recommendations.append("🔴 **Acidic Soil**: Apply lime (CaCO3)")
     elif pH > 8.0:
-        recommendations.append(t("alkaline_soil"))
+        recommendations.append("🔴 **Alkaline Soil**: Apply sulfur or organic matter")
     else:
-        recommendations.append(t("ideal_ph"))
+        recommendations.append("✅ **Ideal pH**: Between 6.5-7.5")
     
     if nitrogen < 200:
-        recommendations.append(t("low_nitrogen"))
+        recommendations.append("🟡 **Low Nitrogen**: Apply NPK 20:20:0")
     elif nitrogen > 500:
-        recommendations.append(t("high_nitrogen"))
+        recommendations.append("🟡 **High Nitrogen**: Reduce nitrogen fertilizer")
     else:
-        recommendations.append(t("ideal_nitrogen"))
+        recommendations.append("✅ **Optimal Nitrogen**: Good")
     
     if phosphorus < 10:
-        recommendations.append(t("low_phosphorus"))
+        recommendations.append("🟡 **Low Phosphorus**: Apply DAP or SSP")
+    elif phosphorus > 30:
+        recommendations.append("🟡 **High Phosphorus**: No additional needed")
     else:
-        recommendations.append(t("ideal_phosphorus"))
+        recommendations.append("✅ **Optimal Phosphorus**: Good")
     
     if potassium < 100:
-        recommendations.append(t("low_potassium"))
+        recommendations.append("🟡 **Low Potassium**: Apply KCl or MOP")
+    elif potassium > 300:
+        recommendations.append("🟡 **High Potassium**: Reduce fertilizer")
     else:
-        recommendations.append(t("ideal_potassium"))
+        recommendations.append("✅ **Optimal Potassium**: Good")
     
     return recommendations
 
 # ════════════════════════════════════════════════════════════════════════════
-# FEATURE 4: ML YIELD PREDICTION
+# FEATURE 9: YIELD PREDICTION ML
 # ════════════════════════════════════════════════════════════════════════════
 
 def train_yield_model():
@@ -684,7 +517,7 @@ def train_yield_model():
         return None, None
     
     X_train = np.array([
-        [25, 80, 250, 6.5, 2.5],
+        [25, 80, 250, 20, 2.5],
         [28, 70, 200, 6.5, 3.0],
         [22, 85, 300, 6.8, 2.8],
         [26, 75, 250, 7.0, 3.2],
@@ -735,7 +568,108 @@ def predict_yield(temperature, humidity, rainfall, pH, organic_matter):
     return max(0, yield_pred)
 
 # ════════════════════════════════════════════════════════════════════════════
-# FEATURE 5: WEATHER & ALERTS
+# FEATURE 10: 7-DAY WEATHER FORECAST
+# ════════════════════════════════════════════════════════════════════════════
+
+def get_7day_forecast(location):
+    """Get 7-day weather forecast"""
+    try:
+        api_key = st.secrets.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)
+        
+        if not geo_resp.json():
+            return None
+        
+        lat, lon = geo_resp.json()[0]['lat'], geo_resp.json()[0]['lon']
+        
+        forecast_url = "https://api.openweathermap.org/data/2.5/forecast"
+        forecast_params = {
+            "lat": lat, "lon": lon, "appid": api_key,
+            "units": "metric", "cnt": 56
+        }
+        
+        forecast_resp = requests.get(forecast_url, params=forecast_params)
+        forecast_data = forecast_resp.json()
+        
+        forecast_list = []
+        
+        for item in forecast_data['list'][::8]:
+            forecast_list.append({
+                'Date': datetime.fromtimestamp(item['dt']).strftime("%a, %d %b"),
+                'Temp': f"{item['main']['temp']:.1f}°C",
+                'Humidity': f"{item['main']['humidity']}%",
+                'Condition': item['weather'][0]['main'],
+                'Wind': f"{item['wind']['speed']:.1f} m/s"
+            })
+        
+        return pd.DataFrame(forecast_list)
+        
+    except Exception as e:
+        return None
+
+# ════════════════════════════════════════════════════════════════════════════
+# OPENAI SETUP
+# ════════════════════════════════════════════════════════════════════════════
+
+def initialize_openai():
+    """Initialize OpenAI client"""
+    if not OPENAI_AVAILABLE:
+        return None, "OpenAI library not installed"
+    
+    api_key = None
+    
+    try:
+        if hasattr(st, 'secrets') and "OPENAI_API_KEY" in st.secrets:
+            api_key = st.secrets["OPENAI_API_KEY"]
+    except:
+        pass
+    
+    if not api_key:
+        api_key = os.environ.get("OPENAI_API_KEY")
+    
+    if api_key and api_key.strip():
+        try:
+            client = OpenAI(api_key=api_key.strip())
+            return client, None
+        except Exception as e:
+            return None, f"Failed: {str(e)}"
+    else:
+        return None, "No API key found"
+
+def get_ai_response(client, user_message: str, context: Dict, language: str = "English") -> str:
+    """Get response from OpenAI GPT"""
+    try:
+        if not client:
+            return "AI service not available."
+        
+        system_prompt = "You are an expert agricultural advisor. Provide helpful farming advice."
+        location = context.get("location", "India")
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Location: {location}\n\n{user_message}"}
+        ]
+        
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            temperature=0.7,
+            max_tokens=500
+        )
+        
+        return response.choices[0].message.content
+    
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# ════════════════════════════════════════════════════════════════════════════
+# HELPER FUNCTIONS
 # ═══════��════════════════════════════════════════════════════════════════════
 
 def get_weather_data(location: str) -> Optional[Dict]:
@@ -783,127 +717,36 @@ def get_current_season() -> str:
     """Get current agricultural season"""
     month = datetime.now().month
     if month in [6, 7, 8, 9]:
-        return t("kharif")
+        return "Kharif"
     elif month in [10, 11, 12, 1, 2]:
-        return t("rabi")
+        return "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
-# ════════════════════════════════════════════════════════════════════════════
+        return "Summer"
 
-@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
+def get_market_prices(crop: str) -> Dict:
+    """Get market prices"""
+    prices = {
+        "Wheat": 2200, "Rice": 2500, "Cotton": 5500, "Sugarcane": 290,
+        "Potato": 1500, "Tomato": 1200, "Onion": 1800, "Corn": 1900
     }
-
-# ════════════════════════════════════════════════════════════════════════════
-# 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)
+    
+    base = prices.get(crop, 2000)
+    return {'crop': crop, 'price': base, 'min': base * 0.85, 'max': base * 1.15}
 
 # ════════════════════════════════════════════════════════════════════════════
 # SESSION STATE INITIALIZATION
 # ════════════════════════════════════════════════════════════════════════════
 
+if "messages" not in st.session_state:
+    st.session_state.messages = []
 if "location" not in st.session_state:
-    st.session_state.location = "महाराष्ट्र"
+    st.session_state.location = "Maharashtra"
 if "language" not in st.session_state:
-    st.session_state.language = "Hindi"
+    st.session_state.language = "English"
+if "openai_client" not in st.session_state:
+    client, error = initialize_openai()
+    st.session_state.openai_client = client
+    st.session_state.openai_error = error
 if "user_authenticated" not in st.session_state:
     st.session_state.user_authenticated = False
     st.session_state.username = None
@@ -914,28 +757,38 @@ if 'db_initialized' not in st.session_state:
     st.session_state.db_initialized = True
 
 # ════════════════════════════════════════════════════════════════════════════
-# SIDEBAR - LANGUAGE SELECTION
+# SIDEBAR
 # ════════════════════════════════════════════════════════════════════════════
 
 with st.sidebar:
-    st.markdown(f"### {t('settings')}")
+    st.markdown("### ⚙️ SETTINGS")
     
     location = st.selectbox(
-        t("location"),
-        ["महाराष्ट्र", "पंजाब", "हरियाणा", "उत्तर प्रदेश", "कर्नाटक", "राजस्थान"],
-        key="sidebar_location_key"
+        "📍 Your Location",
+        ["Maharashtra", "Punjab", "Haryana", "Uttar Pradesh", "Karnataka"],
+        key="sidebar_location"
     )
     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"
+        "🌐 Language",
+        ["English", "Hindi", "Marathi"],
+        key="sidebar_language"
     )
+    st.session_state.language = language
     
-    if language != st.session_state.language:
-        st.session_state.language = language
+    st.divider()
+    st.markdown("### 🤖 AI STATUS")
+    
+    if st.session_state.openai_client:
+        st.success("✅ AI Enabled")
+    else:
+        st.error("❌ AI Disabled")
+    
+    if st.button("🔄 Reinitialize AI"):
+        client, error = initialize_openai()
+        st.session_state.openai_client = client
+        st.session_state.openai_error = error
         st.rerun()
     
     st.divider()
@@ -945,280 +798,253 @@ with st.sidebar:
 # MAIN CONTENT
 # ════════════════════════════════════════════════════════════════════════════
 
-st.markdown(f"# {t('title')}")
-st.markdown(f"### {t('subtitle')}")
+st.markdown("# 🌾 FARMER COPILOT v3.0 - COMPLETE")
+st.markdown("### AI Agricultural Intelligence Platform with 15 Features 🚜")
 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")
+    "💬 AI Chat", "🌤️ Weather", "💰 Market", "🌱 Crops", 
+    "🐛 Pests", "💧 Irrigation", "📊 Analytics", "📸 Image", 
+    "🎤 Voice", "🧪 Soil", "📈 Yield", "👤 Profile"
 ])
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 1: VOICE INTERACTION
+# TAB 1: AI CHAT
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab1:
-    st.markdown(t("speak_with_voice"))
-    st.markdown(t("what_you_want"))
-    
-    col1, col2, col3 = st.columns(3)
+    st.markdown("### 💬 Talk to Your AI Copilot")
     
-    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()
+    if not st.session_state.openai_client:
+        st.warning("⚠️ AI is disabled! Add OPENAI_API_KEY to secrets.")
     
-    col1, col2 = st.columns(2)
+    user_input = st.text_input("Your question...", key="chat_input_main")
     
-    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}")
+    if st.button("🚀 Send", key="chat_send_btn"):
+        if user_input:
+            st.session_state.messages.append(("user", user_input))
+            
+            if st.session_state.openai_client:
+                context = {"location": st.session_state.location, "season": get_current_season()}
+                with st.spinner("🤔 Thinking..."):
+                    ai_response = get_ai_response(
+                        st.session_state.openai_client,
+                        user_input, 
+                        context, 
+                        st.session_state.language
+                    )
+            else:
+                ai_response = "AI is disabled."
+            
+            st.session_state.messages.append(("ai", ai_response))
+            st.rerun()
     
-    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)
+    if st.session_state.messages:
+        for msg_type, content in st.session_state.messages[-10:]:
+            if msg_type == "user":
+                st.info(f"👨‍🌾 You: {content}")
+            else:
+                st.success(f"🤖 Copilot: {content}")
+        
+        if st.button("🗑️ Clear Chat", key="clear_chat_btn"):
+            st.session_state.messages = []
+            st.rerun()
 
 # ════════════════════════════════════════════════════════════════════════════
 # TAB 2: WEATHER
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab2:
-    st.markdown(t("weather_info"))
+    st.markdown("### 🌤️ Weather & Climate")
     
-    if st.button(t("refresh_weather"), key="weather_refresh_btn", use_container_width=True):
-        with st.spinner(t("loading")):
+    if st.button("🔄 Refresh Weather", key="weather_refresh"):
+        with st.spinner("Fetching..."):
             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"))
+            col1, col2, col3 = st.columns(3)
+            col1.metric("🌡️ Temperature", f"{weather['temperature']:.1f}°C")
+            col2.metric("💧 Humidity", f"{weather['humidity']}%")
+            col3.metric("💨 Wind", f"{weather['wind_speed']:.1f} m/s")
+    
+    if st.button("📅 Get 7-Day Forecast", key="weather_forecast"):
+        forecast_df = get_7day_forecast(st.session_state.location)
+        if forecast_df is not None:
+            st.dataframe(forecast_df, use_container_width=True)
 
 # ════════════════════════════════════════════════════════════════════════════
 # TAB 3: MARKET PRICES
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab3:
-    st.markdown(t("market_prices_title"))
+    st.markdown("### 💰 Live Market Prices")
     
-    if st.button(t("refresh_prices"), key="market_refresh_btn", use_container_width=True):
+    if st.button("🔄 Refresh Prices", key="market_refresh"):
         live_prices = get_live_market_prices()
         if live_prices:
-            cols = st.columns(2)
+            col1, col2 = 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')}")
+            with col1:
+                for crop in crops_list[:4]:
+                    st.metric(crop, f"₹{live_prices[crop]}")
+            
+            with col2:
+                for crop in crops_list[4:]:
+                    st.metric(crop, f"₹{live_prices[crop]}")
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 4-7: PLACEHOLDER TABS
+# TAB 4-7: PLACEHOLDER TABS (Crops, Pests, Irrigation, Analytics)
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab4:
-    st.markdown(t("crop_suggestions"))
-    st.info(t("best_crops"))
-    st.write(f"{t('current_season')} {get_current_season()}")
+    st.markdown("### 🌱 Crop Recommendations")
+    st.info("🌾 Cotton, Wheat, Rice, Sugarcane - Select based on season")
+    st.write("Current Season:", get_current_season())
 
 with tab5:
-    st.markdown(t("pest_management"))
-    st.info(t("pest_info"))
+    st.markdown("### 🐛 Pest & Disease Management")
+    st.info("Pest management tips and identification guide")
 
 with tab6:
-    st.markdown(t("irrigation_management"))
-    st.info(t("irrigation_info"))
+    st.markdown("### 💧 Irrigation Management")
+    st.info("Smart irrigation scheduling and water conservation")
 
 with tab7:
-    st.markdown(t("farm_analytics"))
-    st.info(t("analytics_info"))
+    st.markdown("### 📊 Farm Analytics")
+    st.info("Profit calculations and farm statistics")
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 8: IMAGE RECOGNITION
+# TAB 8: IMAGE RECOGNITION (UNIQUE KEYS!)
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab8:
-    st.markdown(t("disease_detection"))
-    
-    uploaded_file = st.file_uploader(t("upload_leaf"), type=['jpg', 'jpeg', 'png'], key="image_uploader_key")
+    st.markdown("### 📸 Pest & Disease Detection")
+    uploaded_file = st.file_uploader("Upload leaf photo", type=['jpg', 'jpeg', 'png'], key="image_uploader")
     
-    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"))
+    if uploaded_file and st.button("🔍 Analyze", key="image_analyze_btn"):
+        if IMAGE_RECOGNITION_AVAILABLE:
+            result, error = analyze_plant_disease(uploaded_file)
+            if error:
+                st.error(error)
+            else:
+                col1, col2, col3 = st.columns(3)
+                col1.metric("Disease", result['disease'].split('-')[0])
+                col2.metric("Confidence", f"{result['confidence']:.1f}%")
+                col3.metric("Severity", result['severity'])
+        else:
+            st.warning("Image recognition not available")
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 9: MISC
+# TAB 9: VOICE (UNIQUE KEYS!)
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab9:
-    st.markdown(f"### 🎤 {t('other')}")
-    st.info("Additional voice options")
+    st.markdown("### 🎤 Voice Interaction")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("🎙️ Speak Question", key="voice_input_btn"):
+            if VOICE_AVAILABLE:
+                text, error = voice_input()
+                if error:
+                    st.error(error)
+                elif text:
+                    st.success(f"You said: {text}")
+            else:
+                st.warning("Voice not available")
+    
+    with col2:
+        if st.button("🔊 Play Response", key="voice_output_btn"):
+            if VOICE_AVAILABLE and st.session_state.messages:
+                last_response = st.session_state.messages[-1][1]
+                voice_output(last_response)
+            else:
+                st.warning("No response to play")
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 10: SOIL HEALTH
+# TAB 10: SOIL HEALTH (UNIQUE KEYS!)
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab10:
-    st.markdown(t("soil_check"))
+    st.markdown("### 🧪 Soil Health Monitoring")
     
     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")
+        pH = st.slider("Soil pH", 4.0, 9.0, 6.5, key="soil_pH_slider")
+        nitrogen = st.slider("Nitrogen (mg/kg)", 0, 1000, 250, key="soil_nitrogen_slider")
     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")
+        phosphorus = st.slider("Phosphorus (mg/kg)", 0, 100, 20, key="soil_phosphorus_slider")
+        potassium = st.slider("Potassium (mg/kg)", 0, 500, 150, key="soil_potassium_slider")
     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")
+        organic_matter = st.slider("Organic Matter (%)", 0.0, 10.0, 2.5, key="soil_organic_slider")
+        moisture = st.slider("Soil Moisture (%)", 0.0, 50.0, 25.0, key="soil_moisture_slider")
     
-    if st.button(t("save_soil_test"), key="soil_save_btn_tab10", use_container_width=True):
+    if st.button("💾 Save Soil Test", key="soil_save_btn"):
         save_soil_test(st.session_state.location, pH, nitrogen, phosphorus, potassium, organic_matter, moisture)
-        st.success(t("saved"))
+        st.success("Saved!")
     
     recommendations = get_soil_recommendations(pH, nitrogen, phosphorus, potassium)
-    st.markdown(t("recommendations"))
     for rec in recommendations:
         st.markdown(rec)
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 11: YIELD PREDICTION
+# TAB 11: YIELD PREDICTION (UNIQUE KEYS!)
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab11:
-    st.markdown(t("yield_prediction"))
+    st.markdown("### 📈 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")
+        temp = st.slider("Temperature (°C)", 0, 45, 25, key="yield_temp_slider")
+        humidity = st.slider("Humidity (%)", 0, 100, 70, key="yield_humidity_slider")
     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")
+        rainfall = st.slider("Rainfall (mm)", 0, 500, 250, key="yield_rainfall_slider")
+        pH = st.slider("Soil pH", 4.0, 9.0, 6.8, key="yield_pH_slider")
     with col3:
-        org_matter = st.slider(t("organic_matter"), 0.0, 10.0, 2.5, key="yield_orgmatter_slider_tab11")
+        org_matter = st.slider("Organic Matter (%)", 0.0, 10.0, 2.5, key="yield_orgmatter_slider")
     
-    if st.button(t("predict_yield"), key="yield_predict_btn_tab11", use_container_width=True):
+    if st.button("🔮 Predict Yield", key="yield_predict_btn"):
         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"))
+        st.metric("Predicted Yield", f"{yield_pred:.1f} q/hectare")
 
 # ════════════════════════════════════════════════════════════════════════════
-# TAB 12: USER PROFILE
+# TAB 12: USER PROFILE (UNIQUE KEYS!)
 # ════════════════════════════════════════════════════════════════════════════
 
 with tab12:
-    st.markdown(t("profile_settings"))
+    st.markdown("### 👤 User 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")
+        auth_choice = st.radio("Choose", ["🔐 Login", "📝 Register"], key="auth_choice_radio")
         
-        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 auth_choice == "🔐 Login":
+            username = st.text_input("Username", key="login_username")
+            password = st.text_input("Password", type="password", key="login_password")
             
-            if st.button(t("login_btn"), key="login_btn_tab12", use_container_width=True):
+            if st.button("Login", key="login_btn"):
                 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.success("Logged in!")
                     st.rerun()
                 else:
-                    st.error(t("invalid_credentials"))
-        
+                    st.error("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")
+            new_username = st.text_input("Username", key="register_username")
+            new_email = st.text_input("Email", key="register_email")
+            new_password = st.text_input("Password", type="password", key="register_password")
             
-            if st.button(t("register_btn"), key="register_btn_tab12", use_container_width=True):
+            if st.button("Register", key="register_btn"):
                 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}")
-    
+                st.success(msg) if success else st.error(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.success(f"Logged in as: {st.session_state.username}")
+        if st.button("Logout", key="logout_btn"):
             st.session_state.user_authenticated = False
-            st.session_state.username = None
             st.rerun()
 
 st.divider()
-st.markdown(f"<div style='text-align: center'><p>{t('footer')}</p></div>", unsafe_allow_html=True)
+st.markdown("<div style='text-align: center'><p>🌾 FARMER COPILOT v3.0 - All 15 Features | Powered by OpenAI</p></div>", unsafe_allow_html=True)