gemini_service.py

import google.generativeai as genai
import json
import os
from datetime import datetime, date
from typing import Dict, Any, Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class GeminiAIService:
    """Service class for Gemini AI integration"""
    
    def __init__(self, api_key: str):
        """Initialize Gemini AI service"""
        self.api_key = api_key
        genai.configure(api_key=api_key)
        self.model = genai.GenerativeModel('gemini-2.0-flash')
    
    def generate_daily_advisory(self, farmer_data: Dict[str, Any], farm_data: Dict[str, Any], 
                              soil_data: Dict[str, Any], weather_data: Dict[str, Any], 
                              current_date: str = None) -> Dict[str, str]:
        """
        Generate daily farming advisory using Gemini AI
        
        Args:
            farmer_data: Farmer information
            farm_data: Farm details including crops
            soil_data: Current soil parameters
            weather_data: Current weather data
            current_date: Date for the advisory (default: today)
            
        Returns:
            Dictionary with task_to_do, task_to_avoid, and reason_explanation
        """
        
        if current_date is None:
            current_date = date.today().strftime('%Y-%m-%d')
        
        # Prepare the prompt for Gemini
        prompt = self._create_advisory_prompt(farmer_data, farm_data, soil_data, weather_data, current_date)
        
        try:
            # Generate response from Gemini
            response = self.model.generate_content(prompt)
            
            # Parse the response
            advisory = self._parse_gemini_response(response.text)
            
            logger.info(f"Generated advisory for farmer {farmer_data.get('name')} on {current_date}")
            return advisory
            
        except Exception as e:
            logger.error(f"Error generating advisory: {str(e)}")
            return self._get_fallback_advisory()
    
    def _create_advisory_prompt(self, farmer_data: Dict[str, Any], farm_data: Dict[str, Any], 
                               soil_data: Dict[str, Any], weather_data: Dict[str, Any], 
                               current_date: str) -> str:
        """Create a detailed prompt for Gemini AI"""
        
        crop_types = ', '.join(farm_data.get('crop_types', []))
        
        prompt = f"""
You are an expert agricultural advisor. Generate a daily farming advisory for the following farmer:

FARMER INFORMATION:
- Name: {farmer_data.get('name', 'Unknown')}
- Farm Name: {farm_data.get('farm_name', 'Unknown')}
- Farm Size: {farm_data.get('farm_size', 0)} acres
- Crops: {crop_types}
- Irrigation Type: {farm_data.get('irrigation_type', 'Unknown')}

SOIL CONDITIONS:
- Soil Type: {soil_data.get('soil_type', 'Unknown')}
- pH Level: {soil_data.get('ph_level', 'Unknown')}
- Nitrogen: {soil_data.get('nitrogen_level', 'Unknown')} ppm
- Phosphorus: {soil_data.get('phosphorus_level', 'Unknown')} ppm
- Potassium: {soil_data.get('potassium_level', 'Unknown')} ppm
- Moisture: {soil_data.get('moisture_percentage', 'Unknown')}%

WEATHER CONDITIONS:
- Date: {current_date}
- Temperature: {weather_data.get('main', {}).get('temp_min', 'Unknown')}°C - {weather_data.get('main', {}).get('temp_max', 'Unknown')}°C
- Humidity: {weather_data.get('main', {}).get('humidity', 'Unknown')}%
- Wind Speed: {weather_data.get('wind', {}).get('speed', 0) * 3.6:.1f} km/h
- Weather Condition: {weather_data.get('weather', [{}])[0].get('description', 'Unknown').title()}

INSTRUCTIONS:
Please provide a daily farming advisory in the following JSON format:
{{
  "task_to_do": "Specific task the farmer should do today",
  "task_to_avoid": "Specific task the farmer should avoid today",
  "reason_explanation": "Simple, farmer-friendly explanation for the recommendations",
  "crop_stage": "Current estimated crop growth stage"
}}

Consider the weather conditions, soil parameters, crop requirements, and seasonal farming practices. 
Provide practical, actionable advice that a farmer can easily understand and implement.
Make the language simple and direct.
"""
        
        return prompt
    
    def _parse_gemini_response(self, response_text: str) -> Dict[str, str]:
        """Parse Gemini's response and extract advisory information"""
        
        try:
            # Try to extract JSON from the response
            # Look for JSON-like content in the response
            start_idx = response_text.find('{')
            end_idx = response_text.rfind('}') + 1
            
            if start_idx != -1 and end_idx != -1:
                json_text = response_text[start_idx:end_idx]
                advisory = json.loads(json_text)
                
                # Validate required fields
                required_fields = ['task_to_do', 'task_to_avoid', 'reason_explanation']
                for field in required_fields:
                    if field not in advisory:
                        advisory[field] = "No recommendation available"
                
                return advisory
            else:
                # If no JSON found, try to parse manually
                return self._manual_parse_response(response_text)
                
        except json.JSONDecodeError:
            # If JSON parsing fails, try manual parsing
            return self._manual_parse_response(response_text)
        except Exception as e:
            logger.error(f"Error parsing Gemini response: {str(e)}")
            return self._get_fallback_advisory()
    
    def _manual_parse_response(self, response_text: str) -> Dict[str, str]:
        """Manually parse response if JSON parsing fails"""
        
        lines = response_text.split('\n')
        advisory = {
            'task_to_do': 'No specific task recommended',
            'task_to_avoid': 'No specific task to avoid',
            'reason_explanation': 'Advisory not available',
            'crop_stage': 'Unknown'
        }
        
        for line in lines:
            line = line.strip()
            if line.startswith('✅') or 'task_to_do' in line.lower():
                advisory['task_to_do'] = line.replace('✅', '').strip()
            elif line.startswith('❌') or 'task_to_avoid' in line.lower():
                advisory['task_to_avoid'] = line.replace('❌', '').strip()
            elif line.startswith('ℹ️') or 'reason' in line.lower():
                advisory['reason_explanation'] = line.replace('ℹ️', '').strip()
        
        return advisory
    
    def _get_fallback_advisory(self) -> Dict[str, str]:
        """Provide a fallback advisory when Gemini fails"""
        
        return {
            'task_to_do': 'Check crop condition and water levels',
            'task_to_avoid': 'Avoid heavy farm work during extreme weather',
            'reason_explanation': 'General farming best practices for safety and crop health',
            'crop_stage': 'Unknown'
        }
    
    def generate_year_plan(self, farmer_data: Dict[str, Any], farm_data: Dict[str, Any], 
                          soil_data: Dict[str, Any]) -> Dict[str, Any]:
        """Generate a comprehensive year-long farming plan with detailed HTML formatting"""
        
        crop_types = ', '.join(farm_data.get('crop_types', []))
        farm_size = farm_data.get('farm_size', 0)
        irrigation_type = farm_data.get('irrigation_type', 'Unknown')
        soil_type = soil_data.get('soil_type', 'Unknown')
        
        # Construct crop details with areas (assume equal distribution if not specified)
        crops = farm_data.get('crop_types', [])
        if crops and farm_size:
            area_per_crop = farm_size / len(crops)
            crop_details = ", ".join([f"{crop} ({area_per_crop:.1f} acres)" for crop in crops])
        else:
            crop_details = crop_types or "Mixed crops"
        
        prompt = f"""
You are a skilled agriculture expert and data analyst. I am providing you with the following farm details:

FARM INFORMATION:
- Farmer Name: {farmer_data.get('name', 'Unknown')}
- Farm Name: {farm_data.get('farm_name', 'Unknown')}
- Total Farm Area: {farm_size} acres
- Location/Address: {farmer_data.get('address', 'Unknown')}
- Irrigation Type: {irrigation_type}
- Soil Type: {soil_type}
- Soil pH: {soil_data.get('ph_level', 'Unknown')}
- Nitrogen Level: {soil_data.get('nitrogen_level', 'Unknown')} ppm
- Phosphorus Level: {soil_data.get('phosphorus_level', 'Unknown')} ppm
- Potassium Level: {soil_data.get('potassium_level', 'Unknown')} ppm
- Current Crops: {crop_details}

Using the above input, please generate a fully formatted HTML page with enhanced CSS styling that includes the following sections:

1. **Main Heading:**
   - A centrally aligned, bold heading in green titled "Comprehensive Yearly Farming Plan 2025" with proper spacing and clear font sizes.

2. **Farm Overview Statistics:**
   - A left-aligned, blue bold subheading "Farm Overview & Current Status".
   - Below it, include a green table with columns for:
     - Parameter
     - Current Value
     - Recommended Range
     - Status (Good/Needs Improvement)
   - Include farm size, soil parameters, irrigation type, etc.

3. **Monthly Farming Calendar (12-Month Plan):**
   - A left-aligned, blue bold subheading titled "Monthly Farming Calendar".
   - Create a comprehensive green table displaying month-wise activities for the entire year:
     - Month
     - Primary Activities
     - Crop Operations
     - Fertilizer Schedule
     - Irrigation Requirements
     - Expected Weather Considerations
   - Include specific activities for each month based on crop cycles, seasons (Rabi/Kharif), and local agricultural practices.

4. **Crop-wise Annual Strategy:**
   - A left-aligned, blue bold subheading "Crop-wise Annual Strategy".
   - Add a detailed green table showing for each crop:
     - Crop Name
     - Sowing Period
     - Growing Duration
     - Harvest Period
     - Expected Yield (per acre)
     - Estimated Revenue
     - Key Care Instructions

5. **Financial Projections:**
   - Include a section with a blue left-aligned subheading "Annual Financial Forecast".
   - Present tables showing:
     - Expected Production Costs (seeds, fertilizers, labor, etc.)
     - Projected Revenue by crop
     - Estimated Profit Margins
     - Monthly cash flow predictions

6. **Soil Management Plan:**
   - A blue left-aligned subheading "Soil Health & Fertilizer Schedule".
   - Create tables for:
     - Soil testing schedule
     - Fertilizer application timeline
     - Organic matter enhancement plan
     - pH management strategies

7. **Risk Management & Weather Planning:**
   - A blue left-aligned subheading "Risk Management Strategies".
   - Include tables for:
     - Seasonal weather challenges
     - Pest and disease prevention calendar
     - Backup crop strategies
     - Insurance and financial protection

8. **Key Recommendations & Action Items:**
   - At the bottom, include a bullet-point list with specific, actionable recommendations.
   - Style each bullet point in bold with yellow highlights on key dates, quantities, and financial figures.
   - Include immediate actions, seasonal priorities, and long-term improvements.

IMPORTANT REQUIREMENTS:
- Generate the entire response in Hindi language. All text, headings, table headers, and content should be in Hindi.
- Use realistic data based on Indian agricultural practices and the provided farm details.
- Make tables interactive, beautiful, and colorful with proper spacing and margins.
- Increase font size for headings and optimize spacing for readability.
- Do not include any extra spacing at the beginning or end of the response.
- Ensure all content is properly formatted as HTML with appropriate CSS styling.
- Include specific dates, quantities, and actionable advice suitable for Indian farmers.
- Consider Indian seasons (Rabi, Kharif, Zayad) and local agricultural practices.
- Use metric measurements and Indian rupee currency where applicable.

Generate a comprehensive, professional, and farmer-friendly yearly plan that can guide the farmer throughout the entire agricultural year.
"""

        try:
            response = self.model.generate_content(prompt)
            
            # Return the comprehensive HTML plan
            html_plan = response.text.strip()
            
            return {
                'plan': html_plan,
                'type': 'comprehensive_html',
                'generated_at': datetime.now().isoformat(),
                'ai_generated': True,
                'farmer_name': farmer_data.get('name'),
                'farm_name': farm_data.get('farm_name')
            }
            
        except Exception as e:
            logger.error(f"Error generating comprehensive year plan: {str(e)}")
            return {
                'plan': self._get_fallback_yearly_plan(farmer_data, farm_data, soil_data),
                'type': 'fallback_html',
                'generated_at': datetime.now().isoformat(),
                'ai_generated': False
            }
    
    def _get_fallback_yearly_plan(self, farmer_data: Dict[str, Any], farm_data: Dict[str, Any], soil_data: Dict[str, Any]) -> str:
        """Generate a fallback yearly plan in HTML format when AI fails"""
        
        crop_types = ', '.join(farm_data.get('crop_types', ['Mixed crops']))
        
        return f"""
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; margin: 20px; background-color: #f5f5f5; }}
        .header {{ text-align: center; color: #2e7d32; font-size: 28px; font-weight: bold; margin-bottom: 30px; }}
        .section {{ margin-bottom: 25px; }}
        .section-title {{ color: #1976d2; font-size: 20px; font-weight: bold; margin-bottom: 15px; }}
        table {{ width: 100%; border-collapse: collapse; background-color: #e8f5e8; margin-bottom: 20px; }}
        th {{ background-color: #4caf50; color: white; padding: 12px; text-align: left; }}
        td {{ padding: 10px; border: 1px solid #ddd; }}
        .highlight {{ background-color: #ffeb3b; font-weight: bold; }}
        .recommendation {{ margin: 10px 0; padding: 10px; background-color: #fff3e0; border-left: 4px solid #ff9800; }}
    </style>
</head>
<body>
    <div class="header">वार्षिक खेती योजना 2025</div>
    
    <div class="section">
        <div class="section-title">खेत की जानकारी</div>
        <table>
            <tr><th>विवरण</th><th>मान</th></tr>
            <tr><td>किसान का नाम</td><td>{farmer_data.get('name', 'अज्ञात')}</td></tr>
            <tr><td>खेत का नाम</td><td>{farm_data.get('farm_name', 'अज्ञात')}</td></tr>
            <tr><td>कुल क्षेत्रफल</td><td>{farm_data.get('farm_size', 0)} एकड़</td></tr>
            <tr><td>फसलें</td><td>{crop_types}</td></tr>
            <tr><td>सिंचाई प्रकार</td><td>{farm_data.get('irrigation_type', 'अज्ञात')}</td></tr>
        </table>
    </div>
    
    <div class="section">
        <div class="section-title">मासिक गतिविधि कैलेंडर</div>
        <table>
            <tr><th>महीना</th><th>मुख्य गतिविधियां</th><th>सिंचाई</th></tr>
            <tr><td>जनवरी</td><td>रबी फसल की देखभाल, खाद डालना</td><td>आवश्यकता अनुसार</td></tr>
            <tr><td>फरवरी</td><td>फसल की निगरानी, कीट नियंत्रण</td><td>नियमित</td></tr>
            <tr><td>मार्च</td><td>रबी फसल की कटाई तैयारी</td><td>कम</td></tr>
            <tr><td>अप्रैल</td><td>रबी फसल कटाई, खरीफ की तैयारी</td><td>गर्मी के कारण अधिक</td></tr>
            <tr><td>मई</td><td>खेत की तैयारी, बीज खरीदारी</td><td>अधिक</td></tr>
            <tr><td>जून</td><td>खरीफ फसल बुआई</td><td>मानसून शुरुआत</td></tr>
            <tr><td>जुलाई</td><td>खरीफ फसल देखभाल</td><td>मानसून</td></tr>
            <tr><td>अगस्त</td><td>निराई-गुड़ाई, खाद</td><td>मानसून</td></tr>
            <tr><td>सितंबर</td><td>फसल निगरानी</td><td>मध्यम</td></tr>
            <tr><td>अक्टूबर</td><td>खरीफ कटाई, रबी तैयारी</td><td>आवश्यकता अनुसार</td></tr>
            <tr><td>नवंबर</td><td>रबी फसल बुआई</td><td>नियमित</td></tr>
            <tr><td>दिसंबर</td><td>रबी फसल देखभाल</td><td>ठंड में कम</td></tr>
        </table>
    </div>
    
    <div class="recommendation">
        <strong>मुख्य सुझाव:</strong><br>
        • मिट्टी की जांच <span class="highlight">वर्ष में दो बार</span> कराएं<br>
        • उन्नत बीजों का प्रयोग करें<br>
        • <span class="highlight">समय पर</span> सिंचाई और खाद डालें<br>
        • कीट-रोग की नियमित निगरानी करें<br>
        • मौसम की जानकारी रखें
    </div>
</body>
</html>
"""

def format_sms_message(farmer_name: str, advisory: Dict[str, str]) -> str:
    """Format the advisory as an SMS message"""
    
    message = f"Good Morning, {farmer_name} 🌱\n"
    message += f"✅ Task: {advisory.get('task_to_do', 'No task')}\n"
    message += f"❌ Avoid: {advisory.get('task_to_avoid', 'No restrictions')}\n"
    
    if advisory.get('reason_explanation'):
        message += f"ℹ️ {advisory.get('reason_explanation')}"
    
    return message