app.py

import re
import random
import gradio as gr
import json
import os
from typing import Dict, List, Any

# Try to import AI libraries
try:
    import openai
    OPENAI_AVAILABLE = True
except ImportError:
    OPENAI_AVAILABLE = False

try:
    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
    import torch
    TRANSFORMERS_AVAILABLE = True
except ImportError:
    TRANSFORMERS_AVAILABLE = False

# Try to import sentence transformers for semantic search
try:
    from sentence_transformers import SentenceTransformer
    import numpy as np
    SENTENCE_TRANSFORMERS_AVAILABLE = True
except ImportError:
    SENTENCE_TRANSFORMERS_AVAILABLE = False

class AgriBot:
    def __init__(self):
        self.name = "AgriBot"
        self.user_name = ""
        self.conversation_history = []
        self.model_loaded = False
        self.generator = None
        self.tokenizer = None
        self.model = None
        self.embedding_model = None
        
        # Load agricultural data from JSON
        self.agricultural_data = self.load_agricultural_data()
        self.knowledge_base = self.prepare_knowledge_base()
        
        # Initialize embedding model for semantic search
        self.init_embedding_model()
        
    def load_agricultural_data(self) -> Dict:
        """Load agricultural data from JSON file"""
        try:
            json_path = os.path.join(os.path.dirname(__file__), 'agricultural_data.json')
            with open(json_path, 'r', encoding='utf-8') as file:
                return json.load(file)
        except FileNotFoundError:
            print("Agricultural data file not found. Using basic data.")
            return self.get_fallback_data()
        except json.JSONDecodeError:
            print("Error reading agricultural data. Using basic data.")
            return self.get_fallback_data()
    
    def get_fallback_data(self) -> Dict:
        """Fallback data if JSON file is not available"""
        return {
            "crops": {
                "rice": {
                    "season": "Kharif (June-November)",
                    "water_requirement": "High water requirement, flooded fields",
                    "soil": {"type": "Clay or loamy soil with good water retention"},
                    "fertilizer": {"npk": "120:60:40 kg/ha"},
                    "diseases": [{"name": "Blast"}, {"name": "Brown spot"}],
                    "pests": [{"name": "Stem borer"}, {"name": "Brown planthopper"}],
                    "market_uses": ["Staple food", "Rice flour"]
                }
            }
        }
    
    def prepare_knowledge_base(self) -> List[Dict]:
        """Prepare searchable knowledge base from agricultural data"""
        knowledge_items = []
        
        # Process crops data
        for crop_name, crop_data in self.agricultural_data.get('crops', {}).items():
            # Basic crop info
            knowledge_items.append({
                'type': 'crop_info',
                'crop': crop_name,
                'content': f"{crop_name} cultivation information: Season - {crop_data.get('season', 'N/A')}, "
                          f"Climate - {crop_data.get('climate', 'N/A')}, "
                          f"Soil - {crop_data.get('soil', {}).get('type', 'N/A')}, "
                          f"Water requirement - {crop_data.get('water_requirement', 'N/A')}",
                'data': crop_data
            })
            
            # Diseases
            for disease in crop_data.get('diseases', []):
                knowledge_items.append({
                    'type': 'disease',
                    'crop': crop_name,
                    'content': f"{disease.get('name', 'Unknown')} disease in {crop_name}: "
                              f"Cause - {disease.get('cause', 'N/A')}, "
                              f"Symptoms - {disease.get('symptoms', 'N/A')}, "
                              f"Control - {disease.get('control', 'N/A')}",
                    'data': disease
                })
            
            # Pests
            for pest in crop_data.get('pests', []):
                knowledge_items.append({
                    'type': 'pest',
                    'crop': crop_name,
                    'content': f"{pest.get('name', 'Unknown')} pest in {crop_name}: "
                              f"Damage - {pest.get('damage', 'N/A')}, "
                              f"Control - {pest.get('control', 'N/A')}",
                    'data': pest
                })
        
        # Process farming techniques
        for technique_name, technique_data in self.agricultural_data.get('farming_techniques', {}).items():
            knowledge_items.append({
                'type': 'technique',
                'content': f"{technique_name}: {technique_data.get('definition', 'N/A')}. "
                          f"Benefits: {', '.join(technique_data.get('benefits', []))}",
                'data': technique_data
            })
        
        return knowledge_items
    
    def init_embedding_model(self):
        """Initialize embedding model for semantic search"""
        if SENTENCE_TRANSFORMERS_AVAILABLE:
            try:
                self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
                # Pre-compute embeddings for knowledge base
                self.knowledge_embeddings = self.embedding_model.encode([item['content'] for item in self.knowledge_base])
            except Exception as e:
                print(f"Failed to load embedding model: {e}")
                self.embedding_model = None
        else:
            self.embedding_model = None
    
    def semantic_search(self, query: str, top_k: int = 3) -> List[Dict]:
        """Perform semantic search on knowledge base"""
        if self.embedding_model is None:
            return self.fallback_search(query, top_k)
        
        try:
            query_embedding = self.embedding_model.encode([query])
            similarities = np.dot(query_embedding, self.knowledge_embeddings.T)[0]
            top_indices = np.argsort(similarities)[-top_k:][::-1]
            
            results = []
            for idx in top_indices:
                if similarities[idx] > 0.3:  # Threshold for relevance
                    results.append({
                        'item': self.knowledge_base[idx],
                        'score': float(similarities[idx])
                    })
            
            return results
        except Exception as e:
            print(f"Semantic search error: {e}")
            return self.fallback_search(query, top_k)
    
    def fallback_search(self, query: str, top_k: int = 3) -> List[Dict]:
        """Fallback search using keyword matching"""
        query_words = set(query.lower().split())
        results = []
        
        for item in self.knowledge_base:
            content_words = set(item['content'].lower().split())
            overlap = len(query_words.intersection(content_words))
            if overlap > 0:
                results.append({
                    'item': item,
                    'score': overlap / len(query_words)
                })
        
        results.sort(key=lambda x: x['score'], reverse=True)
        return results[:top_k]

    def load_model(self):
        """Load AI model for advanced queries"""
        if self.model_loaded:
            return True
            
        if TRANSFORMERS_AVAILABLE:
            try:
                # Use a smaller, more reliable model
                model_name = "microsoft/DialoGPT-medium"
                
                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
                self.model = AutoModelForCausalLM.from_pretrained(
                    model_name,
                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
                    device_map="auto" if torch.cuda.is_available() else None,
                    low_cpu_mem_usage=True
                )
                
                # Add pad token if not present
                if self.tokenizer.pad_token is None:
                    self.tokenizer.pad_token = self.tokenizer.eos_token
                
                self.generator = pipeline(
                    "text-generation",
                    model=self.model,
                    tokenizer=self.tokenizer,
                    device=0 if torch.cuda.is_available() else -1,
                    return_full_text=False
                )
                
                self.model_loaded = True
                print("✅ AI model loaded successfully!")
                return True
                
            except Exception as e:
                print(f"⚠️ Could not load AI model: {str(e)}")
                return False
        else:
            print("🔧 Install transformers and torch for AI features")
            return False
    
    def generate_ai_response(self, query: str, context: str = "") -> str:
        """Generate conversational AI response using agricultural data as knowledge"""
        if not self.model_loaded:
            if not self.load_model():
                return self.generate_openai_style_response(query, context)
        
        try:
            # Create a conversational prompt that makes AI process the data
            system_prompt = """You are an expert agricultural consultant with years of experience helping farmers. 
Your job is to provide helpful, conversational advice based on agricultural knowledge.
Don't just list data - explain it naturally as if you're talking to a farmer.
Give practical recommendations and explain the reasoning behind them."""

            user_prompt = f"""Based on this agricultural information: {context}

Please answer this farmer's question in a helpful, conversational way: {query}

Provide practical advice and explain why these recommendations work."""

            # Generate response
            full_prompt = f"{system_prompt}\n\nUser: {user_prompt}\nAssistant:"
            
            response = self.generator(
                full_prompt,
                max_new_tokens=200,
                do_sample=True,
                temperature=0.8,
                top_p=0.9,
                pad_token_id=self.tokenizer.eos_token_id,
                repetition_penalty=1.2,
                no_repeat_ngram_size=3
            )
            
            if response and len(response) > 0:
                generated_text = response[0]["generated_text"]
                # Extract only the assistant's response
                if "Assistant:" in generated_text:
                    ai_response = generated_text.split("Assistant:")[-1].strip()
                    if len(ai_response) > 20:
                        return ai_response
                        
        except Exception as e:
            print(f"AI generation error: {e}")
        
        # Fallback to OpenAI-style response
        return self.generate_openai_style_response(query, context)
    
    def generate_openai_style_response(self, query: str, context: str) -> str:
        """Generate OpenAI-style conversational response using template"""
        query_lower = query.lower()
        
        # Extract key information from context
        crop_mentioned = None
        for crop in ['wheat', 'rice', 'corn', 'tomato', 'potato']:
            if crop in query_lower or crop in context.lower():
                crop_mentioned = crop
                break
        
        if crop_mentioned:
            crop_data = self.agricultural_data.get('crops', {}).get(crop_mentioned, {})
            
            if 'how to' in query_lower or 'grow' in query_lower or 'cultivate' in query_lower:
                return self.generate_cultivation_response(crop_mentioned, crop_data, query)
            elif 'fertilizer' in query_lower or 'nutrient' in query_lower:
                return self.generate_fertilizer_response(crop_mentioned, crop_data)
            elif 'disease' in query_lower or 'pest' in query_lower:
                return self.generate_pest_disease_response(crop_mentioned, crop_data, query)
            elif 'harvest' in query_lower:
                return self.generate_harvest_response(crop_mentioned, crop_data)
            else:
                return self.generate_general_crop_response(crop_mentioned, crop_data, query)
        
        return self.generate_general_farming_response(query, context)
    
    def generate_cultivation_response(self, crop: str, crop_data: dict, query: str) -> str:
        """Generate detailed cultivation guide response"""
        season = crop_data.get('season', 'appropriate season')
        climate = crop_data.get('climate', 'suitable climate conditions')
        soil_info = crop_data.get('soil', {})
        soil_type = soil_info.get('type', 'well-prepared soil')
        water_req = crop_data.get('water_requirement', 'adequate water')
        
        planting_info = crop_data.get('planting', {})
        spacing = planting_info.get('spacing', 'proper spacing')
        depth = planting_info.get('depth', 'appropriate depth')
        
        response = f"""Great question about growing {crop}! Let me walk you through the complete cultivation process:

🌱 **Getting Started:**
{crop.capitalize()} grows best during {season}. You'll want {climate} for optimal growth. The key is starting with {soil_type} - this gives your crop the foundation it needs.

🌾 **Planting Process:**
When planting, maintain {spacing} between plants and sow at {depth}. This spacing is crucial because it allows each plant enough room to develop properly and reduces competition for nutrients.

💧 **Water Management:**
Your {crop} will need {water_req}. The timing of watering is just as important as the amount - too much early on can cause root rot, while too little during grain formation reduces yield.

📈 **Why This Works:**
These recommendations are based on the plant's natural growth patterns. {crop.capitalize()} has specific nutritional and environmental needs during different growth stages, and following these guidelines maximizes your chances of a successful harvest.

Would you like me to explain any specific part of the cultivation process in more detail?"""
        
        return response
    
    def generate_fertilizer_response(self, crop: str, crop_data: dict) -> str:
        """Generate fertilizer recommendation response"""
        fertilizer_info = crop_data.get('fertilizer', {})
        npk = fertilizer_info.get('npk', 'balanced NPK')
        organic = fertilizer_info.get('organic', 'organic matter')
        micronutrients = fertilizer_info.get('micronutrients', 'essential micronutrients')
        
        response = f"""Excellent question about fertilizing {crop}! Proper nutrition is absolutely critical for good yields.

🧪 **Primary Nutrition (NPK):**
For {crop}, I recommend {npk} per hectare. Here's why this ratio works:
- **Nitrogen (N)**: Promotes leaf growth and protein development
- **Phosphorus (P)**: Essential for root development and grain formation  
- **Potassium (K)**: Improves disease resistance and grain quality

🌿 **Organic Approach:**
Don't forget about {organic} - this improves soil structure and provides slow-release nutrients. Organic matter also feeds beneficial soil microorganisms that help your plants absorb nutrients more efficiently.

⚡ **Micronutrients:**
{crop.capitalize()} also needs {micronutrients}. These might seem minor, but deficiencies can severely limit yield even when NPK levels are adequate.

💡 **Application Strategy:**
Apply fertilizers in split doses rather than all at once. This prevents nutrient loss and ensures the plant gets nutrition when it needs it most during different growth stages.

**Timing is Everything:**
Early application supports vegetative growth, while later applications during flowering/grain filling stages directly impact your final yield.

Need specific timing recommendations for your growing season?"""
        
        return response
    
    def generate_pest_disease_response(self, crop: str, crop_data: dict, query: str) -> str:
        """Generate pest/disease management response"""
        diseases = crop_data.get('diseases', [])
        pests = crop_data.get('pests', [])
        
        if 'disease' in query.lower() and diseases:
            main_disease = diseases[0] if diseases else {}
            disease_name = main_disease.get('name', 'common diseases')
            symptoms = main_disease.get('symptoms', 'various symptoms')
            control = main_disease.get('control', 'appropriate treatment')
            
            response = f"""I understand your concern about {crop} diseases. {disease_name} is indeed one of the most common issues farmers face.

🔍 **What to Look For:**
{symptoms} - catching this early is crucial for effective management.

💊 **Treatment Approach:**
{control} is your best bet for control. But remember, prevention is always better than cure.

🛡️ **Prevention Strategy:**
- Ensure proper plant spacing for air circulation
- Avoid overhead watering when possible
- Remove and destroy infected plant material immediately
- Practice crop rotation to break disease cycles

🌿 **Integrated Approach:**
Combine chemical treatments with cultural practices for best results. Healthy plants with good nutrition are naturally more resistant to diseases.

The key is regular monitoring - walk your fields weekly and check for early signs. Early detection means easier, cheaper, and more effective treatment."""
            
        elif 'pest' in query.lower() and pests:
            main_pest = pests[0] if pests else {}
            pest_name = main_pest.get('name', 'common pests')
            damage = main_pest.get('damage', 'plant damage')
            control = main_pest.get('control', 'pest control measures')
            
            response = f"""Pest management in {crop} is definitely important for protecting your investment. {pest_name} can cause significant {damage} if not managed properly.

🎯 **Control Strategy:**
{control} - but let's talk about a comprehensive approach.

🔍 **Monitoring:**
Regular field scouting is essential. Check plants weekly, especially during vulnerable growth stages.

🌿 **Integrated Pest Management (IPM):**
1. **Biological control**: Encourage beneficial insects
2. **Cultural practices**: Proper spacing, sanitation
3. **Chemical control**: Only when necessary and at right timing

💡 **Pro Tip:**
Economic thresholds matter - not every pest requires immediate chemical intervention. Sometimes the cost of treatment exceeds the potential damage.

**Timing is Critical:**
Apply controls when pests are in their most vulnerable stage, not necessarily when you first see them."""
        
        else:
            response = f"""For {crop} protection, I recommend an integrated approach combining prevention, monitoring, and targeted treatment.

🛡️ **Prevention First:**
- Choose resistant varieties when available
- Maintain proper plant spacing and field sanitation
- Practice crop rotation to break pest/disease cycles

🔍 **Regular Monitoring:**
Weekly field scouting helps catch problems early when they're easier and cheaper to manage.

⚡ **Quick Response:**
When you do identify issues, act quickly but strategically. Consider economic thresholds and use targeted treatments rather than broad-spectrum approaches."""
        
        return response
    
    def generate_harvest_response(self, crop: str, crop_data: dict) -> str:
        """Generate harvest timing and method response"""
        harvest_info = crop_data.get('harvesting', {})
        timing = harvest_info.get('time', 'appropriate maturity')
        indicators = harvest_info.get('indicators', 'visual cues')
        method = harvest_info.get('method', 'proper harvesting technique')
        yield_expected = crop_data.get('yield', 'good yields')
        
        response = f"""Timing your {crop} harvest correctly is crucial for maximizing both quantity and quality!

⏰ **Perfect Timing:**
{crop.capitalize()} is typically ready for harvest {timing}. But don't just go by the calendar - the plant will tell you when it's ready.

👀 **What to Look For:**
{indicators} - these are nature's signals that your crop has reached optimal maturity.

🌾 **Harvesting Method:**
Use {method} for best results. The method you choose affects not just efficiency, but also grain quality and storage life.

📊 **Expected Results:**
With proper cultivation and timing, you can expect {yield_expected} under good conditions.

💡 **Pro Tips:**
- Harvest during dry weather when possible
- Early morning harvesting often gives better quality
- Don't delay once the crop is ready - overripe crops can lose quality quickly
- Proper post-harvest handling is just as important as growing

🏪 **Post-Harvest:**
Quick drying and proper storage will protect your hard work and maintain market value.

The key is balancing maximum maturity with optimal quality - harvest too early and you lose yield, too late and you lose quality."""
        
        return response
    
    def generate_general_crop_response(self, crop: str, crop_data: dict, query: str) -> str:
        """Generate general crop information response"""
        season = crop_data.get('season', 'growing season')
        climate = crop_data.get('climate', 'suitable climate')
        uses = crop_data.get('market_uses', ['food production'])
        
        response = f"""Let me share some key insights about {crop} cultivation that might help you.

🌾 **Overview:**
{crop.capitalize()} is typically grown during {season} and thrives in {climate}. It's a valuable crop with multiple uses including {', '.join(uses[:3]) if isinstance(uses, list) else uses}.

📊 **Key Success Factors:**
1. **Timing**: Planting at the right time for your region
2. **Soil preparation**: Proper soil conditions are fundamental
3. **Water management**: Balanced irrigation throughout the season
4. **Nutrition**: Adequate fertilization for healthy growth
5. **Protection**: Monitoring and managing pests/diseases

💼 **Market Potential:**
{crop.capitalize()} has good market demand, making it a commercially viable option when grown properly.

🎯 **My Recommendation:**
Start with small test plots if you're new to {crop} cultivation. This lets you learn the crop's behavior in your specific conditions before scaling up.

Would you like me to dive deeper into any specific aspect of {crop} production?"""
        
        return response
    
    def generate_general_farming_response(self, query: str, context: str) -> str:
        """Generate general farming advice response"""
        response = f"""That's a great farming question! Based on current agricultural best practices, here's my advice:

💡 **General Recommendations:**
Agriculture success comes from understanding your local conditions and adapting proven techniques to your specific situation.

🌱 **Key Principles:**
- Soil health is the foundation of everything
- Prevention is more cost-effective than treatment
- Regular monitoring helps catch issues early
- Sustainable practices ensure long-term success

📈 **Next Steps:**
I'd recommend consulting with local agricultural extension services for region-specific advice, as local conditions can significantly impact the best approaches.

Would you like me to elaborate on any specific aspect of this topic?"""
        
        return response

    def get_user_name(self, message):
        name_patterns = [
            r"my name is (\w+)",
            r"i'm (\w+)",
            r"i am (\w+)",
            r"call me (\w+)"
        ]
        
        for pattern in name_patterns:
            match = re.search(pattern, message.lower())
            if match:
                self.user_name = match.group(1).capitalize()
                return f"Nice to meet you, {self.user_name}! How can I assist you with your farming needs?"
        return None

    def process_message(self, message: str) -> str:
        """Main method to process user messages and generate AI responses"""
        # Check if the user is introducing themselves
        name_response = self.get_user_name(message)
        if name_response:
            return name_response
        
        # Search for relevant information in our knowledge base
        search_results = self.semantic_search(message, top_k=3)
        
        # Extract context from search results
        context = ""
        if search_results:
            context_parts = []
            for result in search_results:
                if result['score'] > 0.3:  # Relevance threshold
                    context_parts.append(result['item']['content'])
            context = " ".join(context_parts)
        
        # Generate AI response using context
        ai_response = self.generate_ai_response(message, context)
        
        if ai_response and len(ai_response.strip()) > 20:
            return ai_response
        else:
            # Final fallback
            return self.get_fallback_response(message)
    
    def get_fallback_response(self, query: str) -> str:
        """Provide fallback response when no specific information is found"""
        query_lower = query.lower()
        
        if any(word in query_lower for word in ['crop', 'plant', 'grow']):
            available_crops = list(self.agricultural_data.get('crops', {}).keys())
            return f"""I'd be happy to help you with crop cultivation! I have detailed information about {', '.join(available_crops)}.

These crops have different requirements for soil, climate, and management practices. Each one offers unique opportunities and challenges.

Could you let me know which specific crop you're interested in, or would you like me to recommend crops suitable for your conditions?"""
        
        elif any(word in query_lower for word in ['pest', 'insect', 'bug']):
            return """Pest management is crucial for successful farming! Here's my approach:

🎯 **Integrated Pest Management (IPM):**
The most effective strategy combines multiple approaches rather than relying solely on pesticides.

🔍 **Early Detection:**
Regular field scouting is your best tool - catching problems early makes them much easier and cheaper to manage.

🌿 **Natural Controls:**
Encourage beneficial insects, practice crop rotation, and maintain healthy soil to build natural resistance.

⚡ **Strategic Intervention:**
When chemical control is needed, timing and targeted application are key to effectiveness.

Which specific pest are you dealing with? I can provide more targeted advice."""
        
        elif any(word in query_lower for word in ['disease', 'fungus', 'infection']):
            return """Plant diseases can significantly impact your harvest, but they're manageable with the right approach:

🛡️ **Prevention Strategy:**
- Choose disease-resistant varieties when available
- Ensure proper plant spacing for air circulation  
- Practice crop rotation to break disease cycles
- Maintain soil health for stronger plants

🔍 **Early Recognition:**
Learn to identify early symptoms - quick action is always more effective than waiting.

💊 **Treatment Options:**
Combine cultural practices with appropriate fungicides or bactericides when necessary.

Which crop disease are you concerned about? I can provide specific guidance."""
        
        else:
            return """I'm here to help with all aspects of modern agriculture! Whether you're dealing with:

🌱 **Crop selection and cultivation**
🌍 **Soil health and fertilization** 
🐛 **Pest and disease management**
⛅ **Weather-related challenges**
📈 **Yield optimization strategies**

Each farming situation is unique, and the best approach depends on your specific conditions, resources, and goals.

What specific agricultural challenge can I help you tackle today?"""

# Initialize the bot
bot = AgriBot()

def chat_response(message, history):
    """Generate response for Gradio chat interface"""
    if not message.strip():
        return "Please ask me something about agriculture!"
    
    response = bot.process_message(message)
    return response

def greet():
    return "Hello! I'm AgriBot, your AI-powered agricultural assistant. I can help you with crop cultivation, pest management, disease control, fertilizers, and general farming advice. What would you like to know about farming today?"

# Create Gradio interface
def create_interface():
    with gr.Blocks(
        title="🌾 AgriBot - AI Agricultural Assistant",
        theme=gr.themes.Base(
            primary_hue="green",
            secondary_hue="emerald",
            neutral_hue="gray",
            font=[gr.themes.GoogleFont("Inter"), "Arial", "sans-serif"]
        ),
        css="""
        /* Main Container Styling */
        .gradio-container {
            max-width: 1400px !important;
            margin: 0 auto !important;
            padding: 20px !important;
            background: linear-gradient(135deg, #f0f8f0 0%, #e8f5e8 100%) !important;
        }
        
        /* Header Styling */
        .main-header {
            text-align: center;
            padding: 30px 20px;
            background: linear-gradient(135deg, #2d5016 0%, #4a7c3c 50%, #5d8b4a 100%);
            border-radius: 15px;
            margin-bottom: 25px;
            color: white !important;
            box-shadow: 0 8px 32px rgba(45, 80, 22, 0.3);
            border: 1px solid rgba(255, 255, 255, 0.2);
        }
        
        .main-header h1 {
            color: white !important;
            font-size: 2.5rem !important;
            font-weight: 700 !important;
            margin-bottom: 10px !important;
            text-shadow: 2px 2px 4px rgba(0,0,0,0.3) !important;
        }
        
        .main-header p {
            color: #e8f5e8 !important;
            font-size: 1.2rem !important;
            margin: 0 !important;
            font-weight: 400 !important;
        }
        
        /* Feature Cards */
        .feature-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 20px;
            margin-bottom: 25px;
        }
        
        .feature-card {
            background: white !important;
            padding: 25px !important;
            border-radius: 12px !important;
            border-left: 5px solid #4CAF50 !important;
            box-shadow: 0 4px 15px rgba(0,0,0,0.1) !important;
            transition: transform 0.3s ease, box-shadow 0.3s ease !important;
            color: #2d5016 !important;
        }
        
        .feature-card:hover {
            transform: translateY(-5px) !important;
            box-shadow: 0 8px 25px rgba(0,0,0,0.15) !important;
        }
        
        .feature-card h3 {
            color: #2d5016 !important;
            font-size: 1.3rem !important;
            font-weight: 600 !important;
            margin-bottom: 10px !important;
        }
        
        .feature-card p {
            color: #4a7c3c !important;
            font-size: 1rem !important;
            line-height: 1.5 !important;
            margin: 0 !important;
        }
        
        /* Chat Container */
        .chat-container {
            background: white !important;
            border-radius: 15px !important;
            padding: 25px !important;
            box-shadow: 0 8px 32px rgba(0,0,0,0.1) !important;
            margin-bottom: 20px !important;
        }
        
        /* Chatbot Styling */
        .chatbot-container {
            border: 2px solid #e8f5e8 !important;
            border-radius: 12px !important;
            background: #fafffe !important;
        }
        
        /* Override Gradio's default message styling */
        .chatbot .message-wrap {
            background: transparent !important;
        }
        
        .chatbot .message.user {
            background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%) !important;
            color: #0d47a1 !important;
            border: 1px solid #90caf9 !important;
            margin-left: 15% !important;
            padding: 15px 20px !important;
            border-radius: 15px 15px 5px 15px !important;
            box-shadow: 0 2px 8px rgba(13, 71, 161, 0.2) !important;
            font-weight: 500 !important;
        }
        
        .chatbot .message.bot {
            background: linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%) !important;
            color: #1b5e20 !important;
            border: 1px solid #a5d6a7 !important;
            margin-right: 15% !important;
            padding: 15px 20px !important;
            border-radius: 15px 15px 15px 5px !important;
            box-shadow: 0 2px 8px rgba(27, 94, 32, 0.2) !important;
            font-weight: 500 !important;
        }
        
        /* Force text color in chat messages */
        .chatbot .message.user * {
            color: #0d47a1 !important;
        }
        
        .chatbot .message.bot * {
            color: #1b5e20 !important;
        }
        
        /* Ensure chat text is always visible */
        .gradio-chatbot .chatbot .message {
            color: inherit !important;
        }
        
        .gradio-chatbot .chatbot .message p {
            color: inherit !important;
            margin: 5px 0 !important;
            line-height: 1.5 !important;
        }
        
        /* User message styling */
        .gradio-chatbot .user {
            background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%) !important;
            color: #0d47a1 !important;
            border: 1px solid #90caf9 !important;
            border-radius: 15px 15px 5px 15px !important;
            margin-left: 15% !important;
            margin-right: 5% !important;
        }
        
        /* Bot message styling */
        .gradio-chatbot .bot {
            background: linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%) !important;
            color: #1b5e20 !important;
            border: 1px solid #a5d6a7 !important;
            border-radius: 15px 15px 15px 5px !important;
            margin-right: 15% !important;
            margin-left: 5% !important;
        }
        
        /* Input Styling */
        .input-container {
            background: white !important;
            border-radius: 12px !important;
            border: 2px solid #e8f5e8 !important;
            padding: 5px !important;
            margin-top: 15px !important;
        }
        
        .input-container:focus-within {
            border-color: #4CAF50 !important;
            box-shadow: 0 0 10px rgba(76, 175, 80, 0.2) !important;
        }
        
        /* Input text styling */
        .input-container textarea,
        .input-container input {
            color: #2d5016 !important;
            background: white !important;
            border: none !important;
            font-size: 1rem !important;
            font-weight: 500 !important;
        }
        
        .input-container textarea::placeholder,
        .input-container input::placeholder {
            color: #6b7280 !important;
            opacity: 0.8 !important;
        }
        
        /* Override any Gradio input styling */
        .gradio-textbox {
            background: white !important;
        }
        
        .gradio-textbox textarea {
            color: #2d5016 !important;
            background: white !important;
            border: 2px solid #e8f5e8 !important;
            border-radius: 8px !important;
            padding: 12px !important;
            font-size: 1rem !important;
        }
        
        .gradio-textbox textarea:focus {
            border-color: #4CAF50 !important;
            box-shadow: 0 0 10px rgba(76, 175, 80, 0.2) !important;
            outline: none !important;
        }
        
        /* Button Styling */
        .btn-primary {
            background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%) !important;
            color: white !important;
            border: none !important;
            border-radius: 8px !important;
            padding: 12px 24px !important;
            font-weight: 600 !important;
            font-size: 1rem !important;
            transition: all 0.3s ease !important;
            box-shadow: 0 4px 15px rgba(76, 175, 80, 0.3) !important;
        }
        
        .btn-primary:hover {
            background: linear-gradient(135deg, #45a049 0%, #3d8b40 100%) !important;
            transform: translateY(-2px) !important;
            box-shadow: 0 6px 20px rgba(76, 175, 80, 0.4) !important;
        }
        
        .btn-secondary {
            background: linear-gradient(135deg, #6c757d 0%, #5a6268 100%) !important;
            color: white !important;
            border: none !important;
            border-radius: 8px !important;
            padding: 12px 24px !important;
            font-weight: 600 !important;
            transition: all 0.3s ease !important;
        }
        
        .btn-secondary:hover {
            background: linear-gradient(135deg, #5a6268 0%, #495057 100%) !important;
            transform: translateY(-2px) !important;
        }
        
        /* Sidebar Styling */
        .sidebar {
            background: white !important;
            border-radius: 15px !important;
            padding: 25px !important;
            box-shadow: 0 8px 32px rgba(0,0,0,0.1) !important;
            height: fit-content !important;
        }
        
        .sidebar h3 {
            color: #2d5016 !important;
            font-size: 1.4rem !important;
            font-weight: 600 !important;
            margin-bottom: 15px !important;
            padding-bottom: 10px !important;
            border-bottom: 2px solid #e8f5e8 !important;
        }
        
        .sidebar ul {
            list-style: none !important;
            padding: 0 !important;
            margin: 0 !important;
        }
        
        .sidebar li {
            color: #4a7c3c !important;
            padding: 8px 0 !important;
            border-bottom: 1px solid #f0f8f0 !important;
            font-size: 0.95rem !important;
            line-height: 1.4 !important;
        }
        
        .sidebar strong {
            color: #2d5016 !important;
            font-weight: 600 !important;
        }
        
        /* Examples Section */
        .examples-section {
            background: #f8fffe !important;
            padding: 20px !important;
            border-radius: 10px !important;
            margin-top: 20px !important;
            border: 1px solid #e8f5e8 !important;
        }
        
        /* Footer Styling */
        .footer {
            text-align: center;
            padding: 25px;
            background: linear-gradient(135deg, #2d5016 0%, #4a7c3c 100%);
            border-radius: 15px;
            margin-top: 30px;
            color: white !important;
            box-shadow: 0 8px 32px rgba(45, 80, 22, 0.3);
        }
        
        .footer p {
            color: white !important;
            margin: 5px 0 !important;
            font-size: 1rem !important;
        }
        
        .footer strong {
            color: #e8f5e8 !important;
            font-size: 1.2rem !important;
        }
        
        /* Responsive Design */
        @media (max-width: 768px) {
            .gradio-container {
                padding: 10px !important;
            }
            
            .main-header {
                padding: 20px 15px !important;
            }
            
            .main-header h1 {
                font-size: 2rem !important;
            }
            
            .feature-grid {
                grid-template-columns: 1fr !important;
                gap: 15px !important;
            }
            
            .chat-container, .sidebar {
                padding: 15px !important;
            }
            
            .feature-card {
                padding: 20px !important;
            }
        }
        
        /* Text Visibility Fixes */
        .gr-textbox textarea {
            color: #2d5016 !important;
            background: white !important;
        }
        
        .gr-textbox label {
            color: #2d5016 !important;
            font-weight: 600 !important;
        }
        
        /* Loading Animation */
        .loading {
            display: inline-block;
            width: 20px;
            height: 20px;
            border: 3px solid #e8f5e8;
            border-radius: 50%;
            border-top-color: #4CAF50;
            animation: spin 1s ease-in-out infinite;
        }
        
        @keyframes spin {
            to { transform: rotate(360deg); }
        }
        """
    ) as iface:
        
        # Header
        gr.HTML("""
        <div class="main-header">
            <h1>🌾 AgriBot - AI Agricultural Assistant</h1>
            <p>Expert farming guidance powered by artificial intelligence and comprehensive agricultural data</p>
        </div>
        """)
        
        # Feature highlights
        gr.HTML("""
        <div class="feature-grid">
            <div class="feature-card">
                <h3>🧠 AI-Powered Intelligence</h3>
                <p>Advanced AI models process your questions and provide conversational, expert-level agricultural advice tailored to your specific needs.</p>
            </div>
            <div class="feature-card">
                <h3>🌱 Comprehensive Database</h3>
                <p>Extensive knowledge base covering crops, diseases, pests, fertilizers, soil management, and modern farming techniques.</p>
            </div>
            <div class="feature-card">
                <h3>💡 Professional Guidance</h3>
                <p>Get practical, actionable advice from cultivation to harvest, including organic farming, IPM, and sustainable practices.</p>
            </div>
        </div>
        """)
        
        # Main chat area
        with gr.Row(equal_height=True):
            with gr.Column(scale=7):
                gr.HTML('<div class="chat-container">')
                
                chatbot = gr.Chatbot(
                    value=[(None, greet())],
                    height=520,
                    label="💬 Chat with AgriBot",
                    show_label=True,
                    container=True,
                    bubble_full_width=False,
                    avatar_images=(
                        "https://cdn-icons-png.flaticon.com/512/1077/1077012.png",  # User
                        "https://cdn-icons-png.flaticon.com/512/1998/1998667.png"   # Bot
                    ),
                    elem_classes=["chatbot-container"]
                )
                
                with gr.Row():
                    msg = gr.Textbox(
                        label="🌾 Ask me anything about agriculture...",
                        placeholder="Example: 'How to grow wheat in clay soil?' or 'Best fertilizer for rice cultivation?' or 'Organic pest control methods?'",
                        lines=2,
                        max_lines=4,
                        scale=4,
                        elem_classes=["input-container"]
                    )
                
                with gr.Row():
                    with gr.Column(scale=2):
                        submit_btn = gr.Button("🚀 Send Message", variant="primary", elem_classes=["btn-primary"])
                    with gr.Column(scale=1):
                        clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary", elem_classes=["btn-secondary"])
                
                gr.HTML('</div>')
            
            with gr.Column(scale=3):
                gr.HTML("""
                <div class="sidebar">
                    <h3>🌾 Agricultural Topics</h3>
                    <ul>
                        <li><strong>🌱 Crops:</strong> Rice, Wheat, Corn, Tomato, Potato</li>
                        <li><strong>🌱 Cultivation:</strong> Planting, Growing, Harvesting</li>
                        <li><strong>🧪 Nutrition:</strong> NPK Fertilizers, Organic Matter</li>
                        <li><strong>🛡️ Protection:</strong> Pest Control, Disease Management</li>
                        <li><strong>⚙️ Techniques:</strong> Organic Farming, IPM, Crop Rotation</li>
                        <li><strong>🌍 Soil:</strong> pH Management, Soil Health</li>
                        <li><strong>⛅ Weather:</strong> Climate Adaptation, Seasonal Advice</li>
                    </ul>
                    
                    <div class="examples-section">
                        <h3>💬 Try These Questions</h3>
                        <ul>
                            <li>"How to cultivate wheat in winter?"</li>
                            <li>"Rice fertilizer requirements and timing"</li>
                            <li>"Organic methods for tomato pest control"</li>
                            <li>"Soil preparation for corn planting"</li>
                            <li>"Disease management in potato crops"</li>
                            <li>"Best practices for crop rotation"</li>
                        </ul>
                    </div>
                    
                    <div style="margin-top: 20px; padding: 15px; background: #f0f8f0; border-radius: 8px; text-align: center;">
                        <p style="margin: 0; color: #2d5016; font-weight: 600;">🤖 AI Status</p>
                        <p style="margin: 5px 0 0 0; color: #4a7c3c; font-size: 0.9rem;">Ready to help!</p>
                    </div>
                </div>
                """)
        
        # Quick action buttons
        gr.HTML("""
        <div style="margin: 20px 0; text-align: center;">
            <h3 style="color: #2d5016; margin-bottom: 15px;">🚀 Quick Start Topics</h3>
        </div>
        """)
        
        with gr.Row():
            crop_btn = gr.Button("🌾 Crop Cultivation", elem_classes=["btn-primary"])
            pest_btn = gr.Button("🐛 Pest Management", elem_classes=["btn-primary"])
            disease_btn = gr.Button("🦠 Disease Control", elem_classes=["btn-primary"])
            fertilizer_btn = gr.Button("🧪 Fertilizers", elem_classes=["btn-primary"])
        
        # Function to handle chat
        def respond(message, chat_history):
            if not message.strip():
                return chat_history, ""
            
            response = bot.process_message(message)
            chat_history.append((message, response))
            return chat_history, ""
        
        # Function to set quick questions
        def set_quick_question(question):
            return question
        
        # Event handlers for main chat
        submit_btn.click(respond, [msg, chatbot], [chatbot, msg])
        msg.submit(respond, [msg, chatbot], [chatbot, msg])
        clear_btn.click(lambda: ([(None, greet())], ""), outputs=[chatbot, msg])
        
        # Quick action button handlers
        crop_btn.click(
            set_quick_question,
            inputs=gr.State("Tell me about crop cultivation techniques and best practices for growing healthy crops"),
            outputs=msg
        )
        
        pest_btn.click(
            set_quick_question,
            inputs=gr.State("How can I manage pests in my crops using organic and sustainable methods?"),
            outputs=msg
        )
        
        disease_btn.click(
            set_quick_question,
            inputs=gr.State("What are effective disease control strategies for common crop diseases?"),
            outputs=msg
        )
        
        fertilizer_btn.click(
            set_quick_question,
            inputs=gr.State("What fertilizers should I use for optimal crop growth and when to apply them?"),
            outputs=msg
        )
        
        # Footer
        gr.HTML("""
        <div class="footer">
            <p><strong>🌾 AgriBot - Your AI Agricultural Consultant</strong></p>
            <p>Powered by advanced AI • Comprehensive agricultural database • Expert farming guidance</p>
            <p>© 2025 AgriBot | Helping farmers grow smarter with AI technology</p>
        </div>
        """)
    
    return iface

# Create and launch the interface
if __name__ == "__main__":
    interface = create_interface()
    interface.launch(
        share=True,
        server_name="0.0.0.0",
        server_port=7860,
        show_api=False
    )