app.py

import gradio as gr
import pandas as pd
import datetime
import json
import os
from typing import Dict, List, Tuple
import plotly.graph_objects as go
import plotly.express as px
from dataclasses import dataclass, asdict
import google.generativeai as genai

# Data structure for health records
@dataclass
class HealthRecord:
    date: str
    morning_mood: int
    morning_energy: int
    morning_sleep_quality: int
    afternoon_water_intake: int
    afternoon_physical_activity: int
    afternoon_stress_level: int
    evening_meal_quality: int
    evening_screen_time: int
    evening_gratitude: int
    daily_score: float
    ai_recommendation: str

class AIDoctor:
    def __init__(self):
        self.data_file = "health_data.json"
        self.setup_gemini()
        self.load_data()
    
    def setup_gemini(self):
        """Setup Google Gemini AI"""
        # Get API key from environment variable or Hugging Face Secrets
        api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
        
        if api_key:
            genai.configure(api_key=api_key)
            self.model = genai.GenerativeModel('gemini-pro')
            self.gemini_available = True
        else:
            self.gemini_available = False
            print("⚠️ Gemini API key not found. Using fallback recommendations.")
    
    def load_data(self):
        """Load existing health data"""
        if os.path.exists(self.data_file):
            try:
                with open(self.data_file, 'r') as f:
                    data = json.load(f)
                    self.records = [HealthRecord(**record) for record in data]
            except:
                self.records = []
        else:
            self.records = []
    
    def save_data(self):
        """Save health data to file"""
        try:
            with open(self.data_file, 'w') as f:
                json.dump([asdict(record) for record in self.records], f, indent=2)
        except:
            pass
    
    def calculate_daily_score(self, morning_data: Dict, afternoon_data: Dict, evening_data: Dict) -> float:
        """Calculate daily health score (0-100)"""
        # Morning score (30% weight)
        morning_score = (
            morning_data['mood'] * 0.4 +
            morning_data['energy'] * 0.4 +
            morning_data['sleep_quality'] * 0.2
        ) * 10
        
        # Afternoon score (40% weight)
        afternoon_score = (
            min(morning_data['water_intake'] / 8, 1) * 40 +  # 8 glasses target
            min(afternoon_data['physical_activity'] / 60, 1) * 40 +  # 60 min target
            (10 - afternoon_data['stress_level']) * 2  # Lower stress is better
        )
        
        # Evening score (30% weight)
        evening_score = (
            evening_data['meal_quality'] * 8 +
            max(0, (8 - evening_data['screen_time'])) * 2 +  # Less than 8 hours
            evening_data['gratitude'] * 10
        )
        
        # Weighted total
        total_score = (morning_score * 0.3 + afternoon_score * 0.4 + evening_score * 0.3)
        return min(100, max(0, total_score))
    
    def generate_ai_recommendation(self, score: float, morning_data: Dict, afternoon_data: Dict, evening_data: Dict) -> str:
        """Generate AI doctor recommendations using Gemini"""
        
        if self.gemini_available:
            try:
                # Create detailed health context for Gemini
                health_context = f"""
                You are an AI Health Doctor analyzing a patient's daily health data. Provide personalized, actionable health recommendations.
                
                PATIENT DAILY HEALTH DATA:
                - Overall Health Score: {score:.1f}/100
                
                Morning Metrics:
                - Mood: {morning_data['mood']}/10
                - Energy Level: {morning_data['energy']}/10
                - Sleep Quality: {morning_data['sleep_quality']}/10
                
                Afternoon Metrics:
                - Water Intake: {morning_data['water_intake']} glasses (target: 8)
                - Physical Activity: {afternoon_data['physical_activity']} minutes (target: 60)
                - Stress Level: {afternoon_data['stress_level']}/10 (lower is better)
                
                Evening Metrics:
                - Meal Quality: {evening_data['meal_quality']}/10
                - Screen Time: {evening_data['screen_time']} hours
                - Gratitude Practice: {evening_data['gratitude']}/10
                
                INSTRUCTIONS:
                1. Analyze the overall health pattern
                2. Identify 2-3 key areas for improvement
                3. Provide specific, actionable recommendations
                4. Use encouraging, doctor-like tone
                5. Include emojis for better engagement
                6. Keep response under 300 words
                7. Focus on the lowest-scoring metrics
                
                Format: Start with overall assessment, then provide specific recommendations for improvement areas.
                """
                
                # Get historical context if available
                if len(self.records) >= 3:
                    recent_scores = [r.daily_score for r in self.records[-3:]]
                    trend = "improving" if recent_scores[-1] > recent_scores[0] else "declining" if recent_scores[-1] < recent_scores[0] else "stable"
                    health_context += f"\n\nRecent 3-day trend: {trend} (scores: {recent_scores})"
                
                # Generate response with Gemini
                response = self.model.generate_content(health_context)
                return response.text
                
            except Exception as e:
                print(f"Gemini API error: {e}")
                return self.fallback_recommendations(score, morning_data, afternoon_data, evening_data)
        else:
            return self.fallback_recommendations(score, morning_data, afternoon_data, evening_data)
    
    def fallback_recommendations(self, score: float, morning_data: Dict, afternoon_data: Dict, evening_data: Dict) -> str:
        """Fallback recommendations when Gemini is not available"""
        recommendations = []
        
        # Score-based general advice
        if score >= 85:
            recommendations.append("🌟 Excellent health habits! You're doing amazing!")
        elif score >= 70:
            recommendations.append("👍 Good health practices! Small improvements can make you even better.")
        elif score >= 50:
            recommendations.append("⚠️ Moderate health status. Focus on key areas for improvement.")
        else:
            recommendations.append("🚨 Your health needs attention. Let's work on fundamental habits.")
        
        # Specific recommendations
        if morning_data['sleep_quality'] < 6:
            recommendations.append("💤 Sleep Quality: Aim for 7-9 hours of sleep. Create a bedtime routine.")
        
        if morning_data['mood'] < 6:
            recommendations.append("😊 Mood: Try 10 minutes of meditation or journaling in the morning.")
        
        if morning_data['energy'] < 6:
            recommendations.append("⚡ Energy: Consider a protein-rich breakfast and light morning exercise.")
        
        if morning_data['water_intake'] < 6:
            recommendations.append("💧 Hydration: Aim for 8 glasses of water daily. Set hourly reminders.")
        
        if afternoon_data['physical_activity'] < 30:
            recommendations.append("🏃 Activity: Try to get at least 30 minutes of physical activity daily.")
        
        if afternoon_data['stress_level'] > 7:
            recommendations.append("🧘 Stress: Practice deep breathing or take short breaks throughout the day.")
        
        if evening_data['meal_quality'] < 6:
            recommendations.append("🥗 Nutrition: Focus on whole foods, vegetables, and balanced meals.")
        
        if evening_data['screen_time'] > 6:
            recommendations.append("📱 Screen Time: Reduce screen time before bed for better sleep quality.")
        
        return " | ".join(recommendations)
    
    def morning_checkin(self, mood: int, energy: int, sleep_quality: int, water_goal: int) -> str:
        """Process morning check-in"""
        today = datetime.date.today().isoformat()
        
        # Store morning data temporarily
        self.temp_morning = {
            'mood': mood,
            'energy': energy, 
            'sleep_quality': sleep_quality,
            'water_intake': water_goal
        }
        
        return f"✅ Morning check-in completed!\n\nMood: {mood}/10\nEnergy: {energy}/10\nSleep Quality: {sleep_quality}/10\nWater Goal: {water_goal} glasses\n\n👉 Complete your afternoon check-in next!"
    
    def afternoon_checkin(self, water_consumed: int, physical_activity: int, stress_level: int) -> str:
        """Process afternoon check-in"""
        if not hasattr(self, 'temp_morning'):
            return "❌ Please complete your morning check-in first!"
        
        self.temp_afternoon = {
            'physical_activity': physical_activity,
            'stress_level': stress_level
        }
        
        # Update water intake
        self.temp_morning['water_intake'] = water_consumed
        
        return f"✅ Afternoon check-in completed!\n\nWater Consumed: {water_consumed} glasses\nPhysical Activity: {physical_activity} minutes\nStress Level: {stress_level}/10\n\n👉 Complete your evening check-in to get your daily score!"
    
    def evening_checkin(self, meal_quality: int, screen_time: int, gratitude: int) -> Tuple[str, str, object]:
        """Process evening check-in and generate daily report"""
        if not hasattr(self, 'temp_morning') or not hasattr(self, 'temp_afternoon'):
            return "❌ Please complete morning and afternoon check-ins first!", "", None
        
        evening_data = {
            'meal_quality': meal_quality,
            'screen_time': screen_time,
            'gratitude': gratitude
        }
        
        # Calculate daily score
        score = self.calculate_daily_score(self.temp_morning, self.temp_afternoon, evening_data)
        
        # Generate AI recommendation
        recommendation = self.generate_ai_recommendation(score, self.temp_morning, self.temp_afternoon, evening_data)
        
        # Create health record
        today = datetime.date.today().isoformat()
        record = HealthRecord(
            date=today,
            morning_mood=self.temp_morning['mood'],
            morning_energy=self.temp_morning['energy'],
            morning_sleep_quality=self.temp_morning['sleep_quality'],
            afternoon_water_intake=self.temp_morning['water_intake'],
            afternoon_physical_activity=self.temp_afternoon['physical_activity'],
            afternoon_stress_level=self.temp_afternoon['stress_level'],
            evening_meal_quality=evening_data['meal_quality'],
            evening_screen_time=evening_data['screen_time'],
            evening_gratitude=evening_data['gratitude'],
            daily_score=score,
            ai_recommendation=recommendation
        )
        
        # Save record
        self.records = [r for r in self.records if r.date != today]  # Remove today's old record
        self.records.append(record)
        self.save_data()
        
        # Generate report
        report = f"""
# 🏥 Daily Health Report - {today}

## 📊 Your Health Score: {score:.1f}/100

### 🌅 Morning Metrics:
- Mood: {self.temp_morning['mood']}/10
- Energy: {self.temp_morning['energy']}/10  
- Sleep Quality: {self.temp_morning['sleep_quality']}/10

### 🌞 Afternoon Metrics:
- Water Intake: {self.temp_morning['water_intake']} glasses
- Physical Activity: {self.temp_afternoon['physical_activity']} minutes
- Stress Level: {self.temp_afternoon['stress_level']}/10

### 🌙 Evening Metrics:
- Meal Quality: {evening_data['meal_quality']}/10
- Screen Time: {evening_data['screen_time']} hours
- Gratitude Practice: {gratitude}/10

## 🤖 AI Doctor Recommendations:
{recommendation}

---
*Keep up the great work! Consistency is key to better health.* 🌟
        """
        
        # Create progress chart
        chart = self.create_progress_chart()
        
        # Clear temporary data
        delattr(self, 'temp_morning')
        delattr(self, 'temp_afternoon')
        
        return f"✅ Evening check-in completed!", report, chart
    
    def create_progress_chart(self):
        """Create progress visualization"""
        if len(self.records) < 2:
            return None
        
        df = pd.DataFrame([asdict(record) for record in self.records[-7:]])  # Last 7 days
        
        fig = go.Figure()
        fig.add_trace(go.Scatter(
            x=df['date'],
            y=df['daily_score'],
            mode='lines+markers',
            name='Daily Health Score',
            line=dict(color='#2E86AB', width=3),
            marker=dict(size=8)
        ))
        
        fig.update_layout(
            title='📈 Your 7-Day Health Progress',
            xaxis_title='Date',
            yaxis_title='Health Score',
            yaxis=dict(range=[0, 100]),
            template='plotly_white',
            height=400
        )
        
        return fig
    
    def get_weekly_summary(self) -> str:
        """Generate weekly health summary"""
        if len(self.records) < 7:
            return "📊 Complete 7 days of check-ins to see your weekly summary!"
        
        recent_records = self.records[-7:]
        avg_score = sum(r.daily_score for r in recent_records) / len(recent_records)
        
        # Find trends
        scores = [r.daily_score for r in recent_records]
        trend = "📈 Improving" if scores[-1] > scores[0] else "📉 Declining" if scores[-1] < scores[0] else "➡️ Stable"
        
        best_day = max(recent_records, key=lambda x: x.daily_score)
        
        summary = f"""
# 📅 Weekly Health Summary

## 🎯 Average Score: {avg_score:.1f}/100
## 📊 Trend: {trend}
## 🌟 Best Day: {best_day.date} (Score: {best_day.daily_score:.1f})

### Key Insights:
- Best performing area: {"Sleep" if sum(r.morning_sleep_quality for r in recent_records) > 42 else "Physical Activity" if sum(r.afternoon_physical_activity for r in recent_records) > 210 else "Nutrition"}
- Focus area: {"Sleep routine" if sum(r.morning_sleep_quality for r in recent_records) < 35 else "Exercise" if sum(r.afternoon_physical_activity for r in recent_records) < 140 else "Stress management"}

*Keep building those healthy habits! 💪*
        """
        
        return summary

# Initialize AI Doctor
ai_doctor = AIDoctor()

# Create Gradio Interface
with gr.Blocks(title="🏥 AI Doctor - Daily Health Checkup", theme=gr.themes.Soft()) as app:
    gr.Markdown("""
    # 🏥 AI Doctor - Your Personal Health Assistant
    
    Complete 3 daily check-ins to track your health and get **AI-powered recommendations from Google Gemini**! 🤖✨
    
    **📱 How it works:**
    1. **Morning Check-in** - Rate your mood, energy, and sleep
    2. **Afternoon Check-in** - Log water, activity, and stress  
    3. **Evening Check-in** - Rate meals, screen time, and gratitude
    
    Get your daily health score and personalized AI recommendations! 
    
    > 🔑 **Setup**: Add your `GEMINI_API_KEY` in Hugging Face Secrets for enhanced AI recommendations!
    """)
    
    # API Key status indicator
    if ai_doctor.gemini_available:
        gr.Markdown("✅ **Gemini AI Active** - Enhanced recommendations enabled!")
    else:
        gr.Markdown("⚠️ **Gemini AI Inactive** - Add GEMINI_API_KEY for enhanced recommendations (using fallback mode)")
    
    with gr.Tabs():
        # Morning Check-in Tab
        with gr.TabItem("🌅 Morning Check-in"):
            gr.Markdown("### Start your day with a quick health check!")
            
            with gr.Row():
                mood_slider = gr.Slider(1, 10, value=7, label="😊 How's your mood? (1=Terrible, 10=Amazing)")
                energy_slider = gr.Slider(1, 10, value=7, label="⚡ Energy level? (1=Exhausted, 10=Energetic)")
            
            with gr.Row():
                sleep_slider = gr.Slider(1, 10, value=7, label="💤 Sleep quality? (1=Terrible, 10=Perfect)")
                water_goal = gr.Slider(4, 12, value=8, label="💧 Water goal today? (glasses)")
            
            morning_btn = gr.Button("Complete Morning Check-in ✅", variant="primary")
            morning_output = gr.Textbox(label="Morning Status", lines=6)
            
            morning_btn.click(
                ai_doctor.morning_checkin,
                inputs=[mood_slider, energy_slider, sleep_slider, water_goal],
                outputs=morning_output
            )
        
        # Afternoon Check-in Tab  
        with gr.TabItem("🌞 Afternoon Check-in"):
            gr.Markdown("### Midday health update!")
            
            with gr.Row():
                water_consumed = gr.Slider(0, 15, value=4, label="💧 Water consumed so far? (glasses)")
                activity_minutes = gr.Slider(0, 180, value=30, label="🏃 Physical activity? (minutes)")
                
            stress_slider = gr.Slider(1, 10, value=5, label="😰 Stress level? (1=Zen, 10=Overwhelmed)")
            
            afternoon_btn = gr.Button("Complete Afternoon Check-in ✅", variant="primary")
            afternoon_output = gr.Textbox(label="Afternoon Status", lines=6)
            
            afternoon_btn.click(
                ai_doctor.afternoon_checkin,
                inputs=[water_consumed, activity_minutes, stress_slider],
                outputs=afternoon_output
            )
        
        # Evening Check-in Tab
        with gr.TabItem("🌙 Evening Check-in"):
            gr.Markdown("### End your day and get your health score!")
            
            with gr.Row():
                meal_quality = gr.Slider(1, 10, value=7, label="🥗 Meal quality today? (1=Junk, 10=Nutritious)")
                screen_time = gr.Slider(0, 12, value=4, label="📱 Screen time? (hours)")
                
            gratitude_slider = gr.Slider(1, 10, value=7, label="🙏 Gratitude practice? (1=None, 10=Very mindful)")
            
            evening_btn = gr.Button("Complete Evening Check-in & Get Score! 🎯", variant="primary")
            
            with gr.Row():
                evening_status = gr.Textbox(label="Evening Status")
                daily_report = gr.Markdown(label="📋 Daily Health Report")
            
            progress_chart = gr.Plot(label="📈 Progress Chart")
            
            evening_btn.click(
                ai_doctor.evening_checkin,
                inputs=[meal_quality, screen_time, gratitude_slider],
                outputs=[evening_status, daily_report, progress_chart]
            )
        
        # Progress Tab
        with gr.TabItem("📊 Weekly Summary"):
            gr.Markdown("### Your health journey overview")
            
            summary_btn = gr.Button("Generate Weekly Summary 📅", variant="secondary")
            weekly_summary = gr.Markdown()
            
            summary_btn.click(
                ai_doctor.get_weekly_summary,
                outputs=weekly_summary
            )
    
    gr.Markdown("""
    ---
    
    ### 💡 Health Tips:
    - **Consistency** is more important than perfection
    - Aim for **8 glasses** of water daily  
    - Get **7-9 hours** of quality sleep
    - **30+ minutes** of physical activity
    - Practice **gratitude** for mental wellness
    
    *Your AI Doctor is here to help you build lasting healthy habits! 🌟*
    """)

if __name__ == "__main__":
    app.launch()