"""
AI Nutrition Tracker with Image Recognition
Author: RSK World (https://rskworld.in)
Founded by: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
"""

import base64
import json
import requests
from datetime import datetime, timedelta
from typing import Dict, List, Any, Optional

class NutritionAI:
    """Advanced AI-powered nutrition tracking with image recognition"""
    
    def __init__(self):
        self.food_database = self._load_food_database()
        self.nutrition_goals = self._load_nutrition_goals()
        self.meal_patterns = {}
        
    def _load_food_database(self) -> Dict:
        """Load comprehensive food nutrition database"""
        return {
            # Fruits
            "apple": {
                "calories": 52, "protein": 0.3, "carbs": 14, "fat": 0.2, "fiber": 2.4,
                "vitamins": {"C": 8, "A": 54}, "category": "fruit", "glycemic_index": 38
            },
            "banana": {
                "calories": 89, "protein": 1.1, "carbs": 23, "fat": 0.3, "fiber": 2.6,
                "vitamins": {"C": 15, "B6": 20}, "category": "fruit", "glycemic_index": 51
            },
            "orange": {
                "calories": 47, "protein": 0.9, "carbs": 12, "fat": 0.1, "fiber": 2.4,
                "vitamins": {"C": 88, "A": 4}, "category": "fruit", "glycemic_index": 43
            },
            
            # Vegetables
            "broccoli": {
                "calories": 34, "protein": 2.8, "carbs": 7, "fat": 0.4, "fiber": 2.6,
                "vitamins": {"C": 135, "K": 116}, "category": "vegetable", "glycemic_index": 10
            },
            "spinach": {
                "calories": 23, "protein": 2.9, "carbs": 3.6, "fat": 0.4, "fiber": 2.2,
                "vitamins": {"K": 402, "A": 105}, "category": "vegetable", "glycemic_index": 15
            },
            "carrot": {
                "calories": 41, "protein": 0.9, "carbs": 10, "fat": 0.2, "fiber": 2.8,
                "vitamins": {"A": 835, "K": 13}, "category": "vegetable", "glycemic_index": 47
            },
            
            # Proteins
            "chicken_breast": {
                "calories": 165, "protein": 31, "carbs": 0, "fat": 3.6, "fiber": 0,
                "vitamins": {"B6": 30, "B12": 6}, "category": "protein", "glycemic_index": 0
            },
            "salmon": {
                "calories": 208, "protein": 20, "carbs": 0, "fat": 13, "fiber": 0,
                "vitamins": {"D": 236, "B12": 209}, "category": "protein", "glycemic_index": 0
            },
            "eggs": {
                "calories": 155, "protein": 13, "carbs": 1.1, "fat": 11, "fiber": 0,
                "vitamins": {"B12": 46, "D": 21}, "category": "protein", "glycemic_index": 42
            },
            
            # Grains
            "rice_white": {
                "calories": 130, "protein": 2.7, "carbs": 28, "fat": 0.3, "fiber": 0.4,
                "vitamins": {"B1": 8}, "category": "grain", "glycemic_index": 73
            },
            "rice_brown": {
                "calories": 111, "protein": 2.6, "carbs": 23, "fat": 0.9, "fiber": 1.8,
                "vitamins": {"B1": 12}, "category": "grain", "glycemic_index": 50
            },
            "quinoa": {
                "calories": 120, "protein": 4.4, "carbs": 21, "fat": 1.9, "fiber": 2.8,
                "vitamins": {"B1": 13, "E": 6}, "category": "grain", "glycemic_index": 35
            },
            
            # Dairy
            "milk": {
                "calories": 42, "protein": 3.4, "carbs": 5, "fat": 1, "fiber": 0,
                "vitamins": {"B12": 18, "D": 51}, "category": "dairy", "glycemic_index": 46
            },
            "yogurt": {
                "calories": 59, "protein": 10, "carbs": 3.6, "fat": 0.4, "fiber": 0,
                "vitamins": {"B12": 17}, "category": "dairy", "glycemic_index": 47
            },
            
            # Nuts & Seeds
            "almonds": {
                "calories": 579, "protein": 21, "carbs": 22, "fat": 50, "fiber": 12.5,
                "vitamins": {"E": 173}, "category": "nuts", "glycemic_index": 0
            },
            "chia_seeds": {
                "calories": 486, "protein": 17, "carbs": 42, "fat": 31, "fiber": 34.4,
                "vitamins": {"E": 14}, "category": "seeds", "glycemic_index": 1
            }
        }
    
    def _load_nutrition_goals(self) -> Dict:
        """Load nutrition goals based on user profiles"""
        return {
            "weight_loss": {
                "calories": 1800,
                "protein": 150,  # grams
                "carbs": 180,
                "fat": 60,
                "fiber": 25
            },
            "muscle_gain": {
                "calories": 2800,
                "protein": 180,
                "carbs": 280,
                "fat": 90,
                "fiber": 30
            },
            "maintenance": {
                "calories": 2200,
                "protein": 120,
                "carbs": 220,
                "fat": 73,
                "fiber": 25
            },
            "endurance": {
                "calories": 2500,
                "protein": 130,
                "carbs": 312,
                "fat": 83,
                "fiber": 28
            }
        }
    
    async def analyze_food_image(self, image_data: str, user_profile: Dict) -> Dict:
        """Analyze food image using AI vision"""
        try:
            # Prepare image for AI analysis
            image_base64 = image_data.split(',')[1] if ',' in image_data else image_data
            
            # Use OpenAI Vision API for food recognition
            response = await self._call_vision_api(image_base64)
            
            # Parse the response and identify foods
            identified_foods = self._parse_food_response(response)
            
            # Calculate nutrition information
            nutrition_analysis = self._calculate_meal_nutrition(identified_foods, user_profile)
            
            # Generate recommendations
            recommendations = self._generate_nutrition_recommendations(nutrition_analysis, user_profile)
            
            return {
                "success": True,
                "identified_foods": identified_foods,
                "nutrition_analysis": nutrition_analysis,
                "recommendations": recommendations,
                "timestamp": datetime.now().isoformat()
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "fallback_analysis": self._fallback_food_analysis()
            }
    
    async def _call_vision_api(self, image_base64: str) -> str:
        """Call vision API for food recognition"""
        # This would integrate with OpenAI Vision API or similar
        # For now, we'll simulate the response
        prompt = """
        Analyze this food image and identify all visible food items. 
        For each food item, provide:
        1. Name of the food
        2. Estimated portion size (in grams or common measurements)
        3. Confidence level (0-100)
        4. Preparation method (grilled, fried, raw, etc.)
        
        Format as JSON array.
        """
        
        # Simulated response - replace with actual API call
        return json.dumps([
            {
                "name": "grilled_chicken_breast",
                "portion": "150g",
                "confidence": 95,
                "preparation": "grilled"
            },
            {
                "name": "broccoli",
                "portion": "100g",
                "confidence": 88,
                "preparation": "steamed"
            },
            {
                "name": "rice_brown",
                "portion": "200g",
                "confidence": 92,
                "preparation": "boiled"
            }
        ])
    
    def _parse_food_response(self, response: str) -> List[Dict]:
        """Parse AI vision response to identify foods"""
        try:
            foods_data = json.loads(response)
            identified_foods = []
            
            for food in foods_data:
                # Map to our database
                food_name = self._normalize_food_name(food["name"])
                if food_name in self.food_database:
                    nutrition = self.food_database[food_name]
                    portion_grams = self._estimate_portion_grams(food["portion"])
                    
                    identified_foods.append({
                        "name": food_name,
                        "display_name": food["name"].replace("_", " ").title(),
                        "portion": food["portion"],
                        "portion_grams": portion_grams,
                        "confidence": food["confidence"],
                        "preparation": food["preparation"],
                        "nutrition": self._scale_nutrition(nutrition, portion_grams, 100)
                    })
            
            return identified_foods
            
        except Exception as e:
            print(f"Error parsing food response: {e}")
            return []
    
    def _normalize_food_name(self, food_name: str) -> str:
        """Normalize food name to match database"""
        # Remove preparation methods and normalize
        normalized = food_name.lower().replace("grilled_", "").replace("fried_", "").replace("baked_", "")
        
        # Map common variations
        name_mapping = {
            "chicken": "chicken_breast",
            "rice": "rice_white" if "white" in food_name else "rice_brown",
            "bread": "whole_wheat_bread"
        }
        
        return name_mapping.get(normalized, normalized)
    
    def _estimate_portion_grams(self, portion: str) -> float:
        """Estimate portion size in grams"""
        portion = portion.lower().strip()
        
        # Common portion sizes
        portion_sizes = {
            "small": 100,
            "medium": 150,
            "large": 200,
            "cup": 240,
            "half_cup": 120,
            "tablespoon": 15,
            "teaspoon": 5,
            "slice": 30,
            "piece": 50
        }
        
        # Extract numbers from portion string
        import re
        numbers = re.findall(r'\d+', portion)
        if numbers:
            return float(numbers[0])
        
        # Check for common terms
        for term, grams in portion_sizes.items():
            if term in portion:
                return grams
        
        return 100  # Default portion
    
    def _scale_nutrition(self, base_nutrition: Dict, portion_grams: float, base_grams: float) -> Dict:
        """Scale nutrition based on portion size"""
        scale_factor = portion_grams / base_grams
        scaled = {}
        
        for key, value in base_nutrition.items():
            if isinstance(value, (int, float)):
                scaled[key] = round(value * scale_factor, 2)
            elif isinstance(value, dict):
                scaled[key] = {k: round(v * scale_factor, 2) for k, v in value.items()}
            else:
                scaled[key] = value
        
        return scaled
    
    def _calculate_meal_nutrition(self, foods: List[Dict], user_profile: Dict) -> Dict:
        """Calculate total nutrition for the meal"""
        total_nutrition = {
            "calories": 0,
            "protein": 0,
            "carbs": 0,
            "fat": 0,
            "fiber": 0,
            "vitamins": {},
            "categories": {}
        }
        
        for food in foods:
            nutrition = food["nutrition"]
            total_nutrition["calories"] += nutrition.get("calories", 0)
            total_nutrition["protein"] += nutrition.get("protein", 0)
            total_nutrition["carbs"] += nutrition.get("carbs", 0)
            total_nutrition["fat"] += nutrition.get("fat", 0)
            total_nutrition["fiber"] += nutrition.get("fiber", 0)
            
            # Sum vitamins
            for vitamin, amount in nutrition.get("vitamins", {}).items():
                total_nutrition["vitamins"][vitamin] = total_nutrition["vitamins"].get(vitamin, 0) + amount
            
            # Track categories
            category = nutrition.get("category", "unknown")
            total_nutrition["categories"][category] = total_nutrition["categories"].get(category, 0) + nutrition.get("calories", 0)
        
        # Calculate macros percentages
        total_macros = total_nutrition["protein"] * 4 + total_nutrition["carbs"] * 4 + total_nutrition["fat"] * 9
        if total_macros > 0:
            total_nutrition["macro_percentages"] = {
                "protein": round((total_nutrition["protein"] * 4 / total_macros) * 100, 1),
                "carbs": round((total_nutrition["carbs"] * 4 / total_macros) * 100, 1),
                "fat": round((total_nutrition["fat"] * 9 / total_macros) * 100, 1)
            }
        
        # Compare to goals
        goal = self.nutrition_goals.get(user_profile.get("goal", "maintenance"), self.nutrition_goals["maintenance"])
        total_nutrition["goal_comparison"] = {
            "calories": {
                "current": total_nutrition["calories"],
                "goal": goal["calories"],
                "percentage": round((total_nutrition["calories"] / goal["calories"]) * 100, 1)
            },
            "protein": {
                "current": total_nutrition["protein"],
                "goal": goal["protein"],
                "percentage": round((total_nutrition["protein"] / goal["protein"]) * 100, 1)
            }
        }
        
        return total_nutrition
    
    def _generate_nutrition_recommendations(self, nutrition: Dict, user_profile: Dict) -> List[str]:
        """Generate personalized nutrition recommendations"""
        recommendations = []
        goal = user_profile.get("goal", "maintenance")
        
        # Calorie recommendations
        calorie_percentage = nutrition["goal_comparison"]["calories"]["percentage"]
        if calorie_percentage > 120:
            recommendations.append("This meal is high in calories. Consider reducing portion sizes for your goal.")
        elif calorie_percentage < 80:
            recommendations.append("This meal is relatively low in calories. You could add healthy fats or complex carbs.")
        
        # Protein recommendations
        protein_percentage = nutrition["goal_comparison"]["protein"]["percentage"]
        if protein_percentage < 80 and goal in ["muscle_gain", "weight_loss"]:
            recommendations.append("Consider adding more protein to support muscle maintenance and growth.")
        
        # Balance recommendations
        macros = nutrition.get("macro_percentages", {})
        if macros.get("protein", 0) < 20:
            recommendations.append("Increase protein intake for better satiety and muscle support.")
        if macros.get("carbs", 0) > 60:
            recommendations.append("Consider reducing carbohydrates and increasing healthy fats.")
        
        # Fiber recommendations
        if nutrition.get("fiber", 0) < 5:
            recommendations.append("Add more vegetables or whole grains to increase fiber intake.")
        
        # Category balance
        categories = nutrition.get("categories", {})
        if categories.get("vegetable", 0) < 100:
            recommendations.append("Include more non-starchy vegetables for micronutrients and fiber.")
        
        # Goal-specific recommendations
        if goal == "muscle_gain":
            if protein_percentage < 100:
                recommendations.append("For muscle gain, aim for higher protein intake (1.6-2.2g per kg bodyweight).")
        elif goal == "weight_loss":
            if calorie_percentage > 100:
                recommendations.append("For weight loss, create a moderate calorie deficit through portion control.")
        
        return recommendations
    
    def _fallback_food_analysis(self) -> Dict:
        """Fallback analysis when AI vision fails"""
        return {
            "message": "Unable to analyze image. Please try again with better lighting or manually log your meal.",
            "suggestions": [
                "Ensure food is well-lit and clearly visible",
                "Take photo from above (top-down view)",
                "Avoid shadows and glare",
                "Use manual entry as backup"
            ]
        }
    
    def track_daily_nutrition(self, user_id: str, date: str) -> Dict:
        """Track and analyze daily nutrition"""
        # This would integrate with database to track daily intake
        # For now, return sample analysis
        return {
            "date": date,
            "total_calories": 1850,
            "total_protein": 142,
            "total_carbs": 198,
            "total_fat": 65,
            "meals_logged": 3,
            "water_intake": 2.1,  # liters
            "goal_progress": {
                "calories": 84,
                "protein": 95,
                "water": 84
            },
            "recommendations": [
                "Increase water intake to reach 2.5L daily goal",
                "Add a protein-rich snack to meet protein goals",
                "Consider adding more vegetables to dinner"
            ]
        }
    
    def generate_meal_plan(self, user_profile: Dict, preferences: Dict) -> Dict:
        """Generate personalized meal plan"""
        goal = user_profile.get("goal", "maintenance")
        calories = user_profile.get("daily_calories", 2200)
        dietary_restrictions = preferences.get("restrictions", [])
        meal_frequency = preferences.get("meal_frequency", 3)
        
        # Calculate calories per meal
        calories_per_meal = calories // meal_frequency
        
        meal_plan = {
            "goal": goal,
            "daily_calories": calories,
            "meals": [],
            "shopping_list": [],
            "prep_tips": []
        }
        
        # Generate meals for each meal type
        meal_types = ["breakfast", "lunch", "dinner", "snack"]
        for meal_type in meal_types[:meal_frequency]:
            meal = self._generate_meal(meal_type, calories_per_meal, dietary_restrictions)
            meal_plan["meals"].append(meal)
        
        # Generate shopping list
        meal_plan["shopping_list"] = self._generate_shopping_list(meal_plan["meals"])
        
        # Add prep tips
        meal_plan["prep_tips"] = [
            "Prep vegetables in advance for quick meal assembly",
            "Cook proteins in batches and store for the week",
            "Use portion control containers for accurate serving sizes",
            "Keep healthy snacks readily available"
        ]
        
        return meal_plan
    
    def _generate_meal(self, meal_type: str, calories: int, restrictions: List[str]) -> Dict:
        """Generate a single meal"""
        meal_templates = {
            "breakfast": [
                {"name": "Protein Oatmeal", "foods": ["oats", "eggs", "berries", "almonds"]},
                {"name": "Greek Yogurt Parfait", "foods": ["yogurt", "granola", "fruits", "chia_seeds"]},
                {"name": "Scrambled Eggs with Toast", "foods": ["eggs", "whole_wheat_bread", "spinach", "milk"]}
            ],
            "lunch": [
                {"name": "Grilled Chicken Salad", "foods": ["chicken_breast", "mixed_greens", "vegetables", "olive_oil"]},
                {"name": "Quinoa Buddha Bowl", "foods": ["quinoa", "chickpeas", "vegetables", "tahini"]},
                {"name": "Turkey Wrap", "foods": ["turkey", "whole_wheat_tortilla", "vegetables", "hummus"]}
            ],
            "dinner": [
                {"name": "Salmon with Vegetables", "foods": ["salmon", "broccoli", "rice_brown", "olive_oil"]},
                {"name": "Lean Beef Stir-fry", "foods": ["lean_beef", "vegetables", "rice_brown", "soy_sauce"]},
                {"name": "Chicken Vegetable Curry", "foods": ["chicken_breast", "vegetables", "coconut_milk", "spices"]}
            ],
            "snack": [
                {"name": "Protein Smoothie", "foods": ["protein_powder", "banana", "almonds", "milk"]},
                {"name": "Apple with Almond Butter", "foods": ["apple", "almond_butter", "cinnamon"]},
                {"name": "Greek Yogurt with Berries", "foods": ["yogurt", "berries", "honey"]}
            ]
        }
        
        templates = meal_templates.get(meal_type, meal_templates["lunch"])
        selected_template = templates[0]  # In production, would rotate based on variety
        
        meal = {
            "type": meal_type,
            "name": selected_template["name"],
            "foods": [],
            "total_calories": 0,
            "total_protein": 0,
            "instructions": self._get_meal_instructions(selected_template["name"])
        }
        
        # Add foods with nutrition
        for food_name in selected_template["foods"]:
            if food_name in self.food_database:
                nutrition = self.food_database[food_name]
                meal["foods"].append({
                    "name": food_name,
                    "display_name": food_name.replace("_", " ").title(),
                    "nutrition": nutrition
                })
                meal["total_calories"] += nutrition.get("calories", 0)
                meal["total_protein"] += nutrition.get("protein", 0)
        
        return meal
    
    def _get_meal_instructions(self, meal_name: str) -> str:
        """Get cooking instructions for meal"""
        instructions = {
            "Protein Oatmeal": "Cook oats with water or milk, stir in protein powder, top with berries and almonds",
            "Grilled Chicken Salad": "Grill chicken breast, slice and serve over mixed greens with vegetables",
            "Salmon with Vegetables": "Bake salmon at 400°F for 15-20 minutes, serve with steamed vegetables",
            "Protein Smoothie": "Blend all ingredients until smooth, add ice if desired"
        }
        
        return instructions.get(meal_name, "Follow standard cooking instructions for best results")
    
    def _generate_shopping_list(self, meals: List[Dict]) -> List[Dict]:
        """Generate shopping list from meal plan"""
        shopping_list = {}
        
        for meal in meals:
            for food in meal["foods"]:
                food_name = food["name"]
                shopping_list[food_name] = shopping_list.get(food_name, 0) + 1
        
        return [
            {"item": food.replace("_", " ").title(), "quantity": quantity}
            for food, quantity in shopping_list.items()
        ]
    
    def analyze_nutrition_trends(self, user_id: str, days: int = 30) -> Dict:
        """Analyze nutrition trends over time"""
        # This would query database for historical data
        # Return sample analysis for now
        return {
            "period": f"Last {days} days",
            "average_daily_calories": 2150,
            "average_daily_protein": 135,
            "goal_consistency": 78,  # percentage
            "most_consumed_foods": [
                {"food": "chicken_breast", "frequency": 12},
                {"food": "rice_brown", "frequency": 10},
                {"food": "broccoli", "frequency": 8}
            ],
            "improvement_areas": [
                "Increase vegetable variety",
                "Add more healthy fats",
                "Maintain consistent protein intake"
            ],
            "achievements": [
                {"name": "7-Day Streak", "description": "Logged meals for 7 consecutive days"},
                {"name": "Protein Goal", "description": "Met protein goals 5 times this week"}
            ]
        }

"""
Fitness Coach Bot - Database Models
Author: RSK World (https://rskworld.in)
Founded by: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
"""

from flask_sqlalchemy import SQLAlchemy
from datetime import datetime, timezone

# db instance will be initialized in app.py and imported here
db = SQLAlchemy()

class User(db.Model):
    """User model for storing user information and fitness goals"""
    __tablename__ = 'users'
    
    id = db.Column(db.String(50), primary_key=True)
    name = db.Column(db.String(100))
    email = db.Column(db.String(120))
    age = db.Column(db.Integer)
    weight = db.Column(db.Float)  # in kg
    height = db.Column(db.Float)  # in cm
    fitness_goal = db.Column(db.String(100))  # weight_loss, muscle_gain, endurance, etc.
    activity_level = db.Column(db.String(50))  # sedentary, light, moderate, active, very_active
    medical_conditions = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
    updated_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
    
    # Relationships
    progress = db.relationship('Progress', backref='user', lazy=True)
    
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'email': self.email,
            'age': self.age,
            'weight': self.weight,
            'height': self.height,
            'fitness_goal': self.fitness_goal,
            'activity_level': self.activity_level,
            'medical_conditions': self.medical_conditions,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'updated_at': self.updated_at.isoformat() if self.updated_at else None
        }

class WorkoutPlan(db.Model):
    """Workout plan model for storing predefined workout routines"""
    __tablename__ = 'workout_plans'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    description = db.Column(db.Text)
    difficulty = db.Column(db.String(20))  # beginner, intermediate, advanced
    duration_weeks = db.Column(db.Integer)
    target_goal = db.Column(db.String(50))  # weight_loss, muscle_gain, strength, etc.
    equipment_needed = db.Column(db.Text)
    category = db.Column(db.String(50))  # full_body, upper_body, lower_body, cardio, etc.
    created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
    
    # Relationships
    exercises = db.relationship('WorkoutExercise', backref='workout_plan', lazy=True)
    
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'description': self.description,
            'difficulty': self.difficulty,
            'duration_weeks': self.duration_weeks,
            'target_goal': self.target_goal,
            'equipment_needed': self.equipment_needed,
            'category': self.category,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'exercises': [we.exercise.to_dict() for we in self.exercises]
        }

class Exercise(db.Model):
    """Exercise model for storing individual exercise information"""
    __tablename__ = 'exercises'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    description = db.Column(db.Text)
    category = db.Column(db.String(50))  # strength, cardio, flexibility, balance
    muscle_group = db.Column(db.String(50))  # chest, back, legs, shoulders, arms, core
    equipment = db.Column(db.String(100))
    difficulty = db.Column(db.String(20))  # beginner, intermediate, advanced
    instructions = db.Column(db.Text)
    tips = db.Column(db.Text)
    calories_per_minute = db.Column(db.Float)
    video_url = db.Column(db.String(255))
    image_url = db.Column(db.String(255))
    created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
    
    # Relationships
    workout_exercises = db.relationship('WorkoutExercise', backref='exercise', lazy=True)
    progress = db.relationship('Progress', backref='exercise', lazy=True)
    
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'description': self.description,
            'category': self.category,
            'muscle_group': self.muscle_group,
            'equipment': self.equipment,
            'difficulty': self.difficulty,
            'instructions': self.instructions,
            'tips': self.tips,
            'calories_per_minute': self.calories_per_minute,
            'video_url': self.video_url,
            'image_url': self.image_url,
            'created_at': self.created_at.isoformat() if self.created_at else None
        }

class WorkoutExercise(db.Model):
    """Junction table for workout plans and exercises"""
    __tablename__ = 'workout_exercises'
    
    id = db.Column(db.Integer, primary_key=True)
    workout_plan_id = db.Column(db.Integer, db.ForeignKey('workout_plans.id'), nullable=False)
    exercise_id = db.Column(db.Integer, db.ForeignKey('exercises.id'), nullable=False)
    day_of_week = db.Column(db.Integer)  # 1-7 for Monday-Sunday
    sets = db.Column(db.Integer)
    reps = db.Column(db.Integer)
    duration_seconds = db.Column(db.Integer)
    rest_seconds = db.Column(db.Integer)
    order = db.Column(db.Integer)
    
    def to_dict(self):
        return {
            'id': self.id,
            'workout_plan_id': self.workout_plan_id,
            'exercise_id': self.exercise_id,
            'day_of_week': self.day_of_week,
            'sets': self.sets,
            'reps': self.reps,
            'duration_seconds': self.duration_seconds,
            'rest_seconds': self.rest_seconds,
            'order': self.order,
            'exercise': self.exercise.to_dict() if self.exercise else None
        }

class Progress(db.Model):
    """Progress model for tracking user workout progress"""
    __tablename__ = 'progress'
    
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.String(50), db.ForeignKey('users.id'), nullable=False)
    exercise_id = db.Column(db.Integer, db.ForeignKey('exercises.id'), nullable=False)
    sets_completed = db.Column(db.Integer)
    reps_completed = db.Column(db.Integer)
    weight_used = db.Column(db.Float)  # weight lifted in kg
    duration_seconds = db.Column(db.Integer)
    calories_burned = db.Column(db.Float)
    notes = db.Column(db.Text)
    date = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
    
    def to_dict(self):
        return {
            'id': self.id,
            'user_id': self.user_id,
            'exercise_id': self.exercise_id,
            'sets_completed': self.sets_completed,
            'reps_completed': self.reps_completed,
            'weight_used': self.weight_used,
            'duration_seconds': self.duration_seconds,
            'calories_burned': self.calories_burned,
            'notes': self.notes,
            'date': self.date.isoformat() if self.date else None,
            'exercise': self.exercise.to_dict() if self.exercise else None
        }

class HealthTip(db.Model):
    """Health tips model for storing fitness and nutrition advice"""
    __tablename__ = 'health_tips'
    
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)
    category = db.Column(db.String(50))  # nutrition, exercise, recovery, motivation, safety
    author = db.Column(db.String(100))
    source_url = db.Column(db.String(255))
    is_featured = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
    updated_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
    
    def to_dict(self):
        return {
            'id': self.id,
            'title': self.title,
            'content': self.content,
            'category': self.category,
            'author': self.author,
            'source_url': self.source_url,
            'is_featured': self.is_featured,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'updated_at': self.updated_at.isoformat() if self.updated_at else None
        }

"""
Fitness Coach Bot - AI-powered fitness coaching engine
Author: RSK World (https://rskworld.in)
Founded by: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
"""

import re
import random
from datetime import datetime, timedelta
from typing import Dict, List, Any

class FitnessCoach:
    """Main fitness coaching AI that provides personalized fitness advice"""
    
    def __init__(self):
        self.greeting_patterns = [
            r'^(hi|hello|hey|good morning|good afternoon|good evening)',
            r'^(how are you|how do you do)',
            r'^(what\'s up|sup)'
        ]
        
        self.workout_requests = [
            r'(workout|exercise|training|fitness|gym)',
            r'(plan|routine|schedule|program)',
            r'(beginner|start|new|first time)'
        ]
        
        self.nutrition_requests = [
            r'(diet|nutrition|food|eat|eating)',
            r'(protein|carbs|fat|calories)',
            r'(meal|breakfast|lunch|dinner)'
        ]
        
        self.progress_requests = [
            r'(progress|track|tracking|record)',
            r'(weight|loss|gain|measurement)',
            r'(goal|target|achievement)'
        ]
        
        self.motivation_quotes = [
            "The only bad workout is the one that didn't happen.",
            "Your body can stand almost anything. It's your mind you have to convince.",
            "Success starts with self-discipline.",
            "Don't stop when you're tired. Stop when you're done.",
            "The pain you feel today will be the strength you feel tomorrow.",
            "Fitness is not about being better than someone else. It's about being better than you used to be.",
            "A one hour workout is 4% of your day. No excuses.",
            "The hardest lift is lifting your butt off the couch."
        ]
    
    def get_response(self, user_message: str, user_id: str) -> str:
        """Generate appropriate response based on user input"""
        message_lower = user_message.lower()
        
        # Check for greetings
        if self._matches_patterns(message_lower, self.greeting_patterns):
            return self._get_greeting_response()
        
        # Check for workout requests
        if self._matches_patterns(message_lower, self.workout_requests):
            return self._get_workout_response(message_lower)
        
        # Check for nutrition requests
        if self._matches_patterns(message_lower, self.nutrition_requests):
            return self._get_nutrition_response(message_lower)
        
        # Check for progress requests
        if self._matches_patterns(message_lower, self.progress_requests):
            return self._get_progress_response(message_lower)
        
        # Check for motivation requests
        if any(word in message_lower for word in ['motivate', 'motivation', 'inspire', 'encourage']):
            return self._get_motivation_response()
        
        # Default response
        return self._get_default_response()
    
    def _matches_patterns(self, text: str, patterns: List[str]) -> bool:
        """Check if text matches any of the given patterns"""
        for pattern in patterns:
            if re.search(pattern, text):
                return True
        return False
    
    def _get_greeting_response(self) -> str:
        """Generate greeting response"""
        greetings = [
            "Hello! I'm your fitness coach bot. I'm here to help you with workout plans, exercise guidance, and health tracking. What would you like to know today?",
            "Hi there! Ready to start your fitness journey? I can help you create workout plans, track your progress, and provide health tips. What's your goal?",
            "Welcome! I'm excited to be your fitness coach. Whether you're a beginner or experienced, I'm here to support your fitness goals. How can I help you today?"
        ]
        return random.choice(greetings)
    
    def _get_workout_response(self, message: str) -> str:
        """Generate workout-related response"""
        if 'beginner' in message or 'start' in message or 'new' in message:
            return self._get_beginner_workout_advice()
        elif 'plan' in message or 'routine' in message:
            return self._get_workout_plan_advice()
        elif 'muscle' in message or 'strength' in message:
            return self._get_strength_training_advice()
        elif 'cardio' in message or 'endurance' in message:
            return self._get_cardio_advice()
        else:
            return self._get_general_workout_advice()
    
    def _get_beginner_workout_advice(self) -> str:
        """Provide advice for beginners"""
        return """Great decision to start your fitness journey! Here's a beginner-friendly approach:

🏋️ **Start with these basics:**
- **Frequency**: 3 days per week, with rest days in between
- **Duration**: 30-45 minutes per session
- **Focus**: Full body workouts to build a foundation

**Sample Beginner Routine:**
1. **Warm-up** (5-10 minutes): Light cardio and dynamic stretching
2. **Strength Training** (20-25 minutes):
   - Bodyweight squats: 2 sets of 10-12 reps
   - Push-ups (knee or regular): 2 sets of 8-10 reps
   - Plank: 2 sets of 20-30 seconds
   - Lunges: 2 sets of 8-10 reps per leg
3. **Cool-down** (5-10 minutes): Static stretching

**Important Tips:**
- Focus on proper form over heavy weights
- Listen to your body and don't push through pain
- Stay consistent and gradually increase intensity
- Consider consulting a certified trainer for personalized guidance

Would you like me to create a more detailed plan based on your specific goals?"""
    
    def _get_workout_plan_advice(self) -> str:
        """Provide workout planning advice"""
        return """I'll help you create an effective workout plan! To give you the best recommendations, I need to know:

📋 **Your Profile:**
- What's your fitness goal? (weight loss, muscle gain, endurance, general fitness)
- What's your current fitness level? (beginner, intermediate, advanced)
- How many days per week can you work out?
- Do you have access to a gym or prefer home workouts?
- Any equipment available?
- Any injuries or medical conditions?

**Popular Workout Plans I can help with:**
- **Weight Loss**: HIIT + Cardio + Strength training (4-5 days/week)
- **Muscle Gain**: Progressive strength training (4-6 days/week)
- **General Fitness**: Balanced routine (3-4 days/week)
- **Home Workouts**: Bodyweight and minimal equipment (3-5 days/week)

Once you share your details, I can create a personalized plan just for you! What's your primary fitness goal?"""
    
    def _get_strength_training_advice(self) -> str:
        """Provide strength training advice"""
        return """Strength training is excellent for building muscle and boosting metabolism! Here's what you need to know:

💪 **Key Principles:**
- **Progressive Overload**: Gradually increase weight, reps, or sets
- **Proper Form**: Quality over quantity always
- **Rest & Recovery**: Muscles grow during rest, not training
- **Consistency**: Regular training is crucial

**Effective Strength Training Split:**
- **Push Day**: Chest, shoulders, triceps
- **Pull Day**: Back, biceps
- **Leg Day**: Quads, hamstrings, glutes, calves
- **Rest/Active Recovery**: Light cardio or stretching

**Sample Exercises:**
- **Compound Movements**: Squats, deadlifts, bench press, overhead press
- **Isolation Exercises**: Bicep curls, tricep extensions, leg curls
- **Core Work**: Planks, Russian twists, leg raises

**Frequency**: 3-5 days per week with adequate rest between muscle groups

Need specific exercise recommendations or form tips?"""
    
    def _get_cardio_advice(self) -> str:
        """Provide cardio training advice"""
        return """Cardio is fantastic for heart health and endurance! Here's your guide:

🏃 **Types of Cardio:**
- **Steady-State**: Moderate intensity for 30-60 minutes
- **HIIT**: High-intensity intervals with rest periods
- **LISS**: Low-intensity steady-state for longer durations

**Effective Cardio Workouts:**
1. **HIIT Protocol** (20 minutes):
   - 30 seconds maximum effort
   - 90 seconds active recovery
   - Repeat 10-12 times

2. **Steady-State Options**:
   - Running/jogging: 30-45 minutes
   - Cycling: 45-60 minutes
   - Swimming: 30-45 minutes
   - Brisk walking: 45-60 minutes

**Frequency Guidelines:**
- **General Fitness**: 3-4 sessions per week
- **Weight Loss**: 4-6 sessions per week
- **Athletic Performance**: 5-7 sessions per week

**Tips for Success:**
- Mix different types to prevent boredom
- Monitor your heart rate zones
- Include warm-up and cool-down
- Stay hydrated throughout

What type of cardio interests you most?"""
    
    def _get_general_workout_advice(self) -> str:
        """Provide general workout advice"""
        return """Here are some essential workout tips for everyone:

🎯 **Workout Fundamentals:**
- **Warm-up**: Always start with 5-10 minutes of light activity
- **Progressive overload**: Gradually increase intensity over time
- **Rest days**: Allow 48 hours between intense sessions for same muscle groups
- **Listen to your body**: Pain vs. discomfort - know the difference

**Balanced Approach:**
- **Strength Training**: 2-4 days per week
- **Cardiovascular Exercise**: 3-5 days per week
- **Flexibility/Mobility**: Daily stretching or yoga

**Common Mistakes to Avoid:**
- Skipping warm-ups and cool-downs
- Using improper form to lift heavier
- Not getting enough rest and recovery
- Comparing your progress to others
- Neglecting nutrition and hydration

**Success Tips:**
- Set realistic, specific goals
- Track your progress consistently
- Find activities you enjoy
- Stay patient and consistent

What specific area would you like to focus on first?"""
    
    def _get_nutrition_response(self, message: str) -> str:
        """Generate nutrition-related response"""
        if 'protein' in message:
            return """**Protein for Fitness:**
- **Daily Needs**: 1.6-2.2g per kg bodyweight for active individuals
- **Best Sources**: Lean meats, fish, eggs, dairy, legumes, protein powder
- **Timing**: 20-30g within 30 minutes post-workout
- **Spread intake**: Every 3-4 hours throughout the day"""
        
        elif 'weight loss' in message or 'diet' in message:
            return """**Weight Loss Nutrition:**
- **Calorie Deficit**: 300-500 calories below maintenance
- **Macros**: 40% protein, 30% carbs, 30% fats (adjust as needed)
- **Focus**: Whole foods, high protein, fiber-rich foods
- **Hydration**: 2-3 liters water daily
- **Meal Timing**: 3 main meals + 1-2 snacks"""
        
        else:
            return """**Basic Nutrition Principles:**
- **Balanced Macros**: Protein, carbs, and healthy fats
- **Whole Foods**: Minimize processed foods
- **Hydration**: 2-3 liters water daily
- **Timing**: Fuel workouts, recover properly
- **Consistency**: Sustainable habits over perfection

Need specific meal planning advice?"""
    
    def _get_progress_response(self, message: str) -> str:
        """Generate progress tracking response"""
        return """**Tracking Your Fitness Progress:**

📊 **What to Track:**
- **Weight**: Weekly measurements (same time/day)
- **Body Measurements**: Monthly (waist, hips, chest, arms)
- **Progress Photos**: Monthly (front, side, back)
- **Performance**: Reps, weights, distances, times
- **How You Feel**: Energy levels, sleep quality

**Tools for Tracking:**
- Fitness apps and wearables
- Workout journal
- Body composition scales
- Progress photos

**Remember:**
- Progress isn't always linear
- Focus on trends, not daily fluctuations
- Celebrate non-scale victories
- Adjust goals as needed

What aspect of progress tracking would you like help with?"""
    
    def _get_motivation_response(self) -> str:
        """Generate motivational response"""
        quote = random.choice(self.motivation_quotes)
        return f"""💪 **Daily Motivation:**

*{quote}*

**Stay Motivated With These Tips:**
- Set specific, achievable goals
- Track your progress and celebrate wins
- Find a workout buddy or community
- Mix up your routine to prevent boredom
- Remember your "why" - your reason for starting
- Be patient with yourself
- Focus on how far you've come, not how far to go

You've got this! Every workout counts, every healthy choice matters. What's your next step toward your goal?"""
    
    def _get_default_response(self) -> str:
        """Generate default response for unrecognized input"""
        return """I'm here to help you with your fitness journey! I can assist you with:

🏋️ **Workout Plans & Routines**
- Beginner to advanced programs
- Home and gym workouts
- Strength training and cardio

🥗 **Nutrition Guidance**
- Meal planning tips
- Protein and macro advice
- Healthy eating strategies

📈 **Progress Tracking**
- Setting and monitoring goals
- Measuring improvements
- Staying motivated

💪 **Exercise Guidance**
- Proper form and technique
- Exercise variations
- Injury prevention

**Just ask me about:**
- "Create a beginner workout plan"
- "What should I eat for muscle gain?"
- "How do I track my progress?"
- "Give me some motivation"

What would you like to focus on today?"""