Update app.py

app.py

@@ -4,677 +4,416 @@ import numpy as np
 import matplotlib.pyplot as plt
 import os
 import datetime
+import json
 from sklearn.linear_model import LinearRegression
 from sklearn.preprocessing import StandardScaler
 import joblib
 import warnings
 warnings.filterwarnings('ignore')
 
-# Initialize data directory and file
+# Initialize data directory and files
 os.makedirs('data', exist_ok=True)
 DATA_FILE = 'data/weight_journal.csv'
+GOAL_FILE = 'data/goal.json'
 MODEL_FILE = 'data/weight_prediction_model.pkl'
 SCALER_FILE = 'data/weight_prediction_scaler.pkl'
+ACHIEVEMENTS_FILE = 'data/achievements.json'
 
-# Initialize or load dataframe
+# Load or initialize dataframe
 if os.path.exists(DATA_FILE):
     df = pd.read_csv(DATA_FILE)
-    df['date'] = pd.to_datetime(df['date'])  # Ensure date is datetime
+    df['date'] = pd.to_datetime(df['date'])
 else:
     df = pd.DataFrame(columns=['date', 'weight', 'calories_consumed', 'calories_burned',
                                'water_intake', 'sleep_hours', 'stress_level', 'mood',
                                'exercise_minutes', 'notes'])
     df.to_csv(DATA_FILE, index=False)
 
+# Load or initialize goals
+if os.path.exists(GOAL_FILE):
+    with open(GOAL_FILE, 'r') as f:
+        goal = json.load(f)
+else:
+    goal = {'target_weight': None, 'target_date': None}
+
+# Load or initialize achievements
+if os.path.exists(ACHIEVEMENTS_FILE):
+    with open(ACHIEVEMENTS_FILE, 'r') as f:
+        achievements = json.load(f)
+else:
+    achievements = []
+
+# Load Indian food dataset with robust column handling
+try:
+    from datasets import load_dataset
+    ds = load_dataset("Anupam007/nutarian-Indianfood")
+    food_df = pd.DataFrame(ds['train'])
+    print(f"Successfully loaded Indian food dataset with {len(food_df)} items")
+    print("Columns in dataset:", food_df.columns.tolist())
+    # Rename potential column names to 'name' for consistency
+    if 'name' not in food_df.columns:
+        if 'food_name' in food_df.columns:
+            food_df = food_df.rename(columns={'food_name': 'name'})
+        elif 'item' in food_df.columns:
+            food_df = food_df.rename(columns={'item': 'name'})
+        else:
+            raise ValueError("No suitable 'name' column found in dataset")
+    # Ensure 'calories' column exists
+    if 'calories' not in food_df.columns and 'calorie_count' in food_df.columns:
+        food_df = food_df.rename(columns={'calorie_count': 'calories'})
+    elif 'calories' not in food_df.columns:
+        raise ValueError("No 'calories' column found in dataset")
+except Exception as e:
+    print(f"Failed to load dataset or process columns: {e}. Using fallback data.")
+    food_df = pd.DataFrame({
+        'name': ['Rice', 'Dal', 'Roti', 'Chicken Curry'],
+        'calories': [130, 150, 80, 200]
+    })
+
+# Core Functions
 def add_entry(date, weight, calories_consumed, calories_burned, water_intake, sleep_hours,
               stress_level, mood, exercise_minutes, notes):
-    """Add a new entry to the journal"""
     global df
-
-    # Validate required fields
     if not date or not weight:
         return "❌ Date and weight are required fields."
-
     try:
-        # Convert date to datetime
         entry_date = pd.to_datetime(date)
-
-        # Check if an entry with this date already exists
         if entry_date in df['date'].values:
-            return f"❌ An entry for {date} already exists. Use the Update tab to modify it."
-
-        # Create new entry
+            return f"❌ An entry for {date} already exists."
         new_entry = {
             'date': entry_date,
-            'weight': weight,
-            'calories_consumed': calories_consumed if calories_consumed is not None else 0,
-            'calories_burned': calories_burned if calories_burned is not None else 0,
-            'water_intake': water_intake if water_intake is not None else 0,
-            'sleep_hours': sleep_hours if sleep_hours is not None else 0,
-            'stress_level': stress_level if stress_level is not None else 5,
-            'mood': mood if mood else 'Neutral',
-            'exercise_minutes': exercise_minutes if exercise_minutes is not None else 0,
-            'notes': notes if notes else ''
+            'weight': float(weight),
+            'calories_consumed': float(calories_consumed or 0),
+            'calories_burned': float(calories_burned or 0),
+            'water_intake': float(water_intake or 0),
+            'sleep_hours': float(sleep_hours or 0),
+            'stress_level': int(stress_level or 5),
+            'mood': mood or 'Neutral',
+            'exercise_minutes': float(exercise_minutes or 0),
+            'notes': notes or ''
         }
-
-        # Add to dataframe
         df = pd.concat([df, pd.DataFrame([new_entry])], ignore_index=True)
-        df = df.sort_values('date', ascending=False)  # Sort by date descending
-
-        # Save to CSV
+        df = df.sort_values('date', ascending=False)
         df.to_csv(DATA_FILE, index=False)
-
-        # Run prediction update if we have enough data
-        if len(df) >= 7:  # Need at least a week of data for prediction
-            train_prediction_model()
-
+        update_achievements()
         return f"✅ Entry for {date} added successfully!"
-
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
 def view_entries(num_entries=10):
-    """View most recent entries in the journal"""
-    global df
-
     if len(df) == 0:
-        return pd.DataFrame(columns=['date', 'weight', 'calories_consumed', 'calories_burned',
-                                    'water_intake', 'sleep_hours', 'stress_level', 'mood',
-                                    'exercise_minutes', 'notes'])
-
-    # Sort by date and get most recent entries
-    sorted_df = df.sort_values('date', ascending=False)
-
-    # Format date for display
-    display_df = sorted_df.head(int(num_entries)).copy()
+        return pd.DataFrame(columns=df.columns)
+    display_df = df.sort_values('date', ascending=False).head(int(num_entries)).copy()
     display_df['date'] = display_df['date'].dt.strftime('%Y-%m-%d')
-
     return display_df
 
 def update_entry(date, weight, calories_consumed, calories_burned, water_intake, sleep_hours,
-                stress_level, mood, exercise_minutes, notes):
-    """Update an existing entry in the journal"""
+                 stress_level, mood, exercise_minutes, notes):
     global df
-
-    # Validate date
     if not date:
         return "❌ Date is required."
-
     try:
-        # Convert date to datetime
         entry_date = pd.to_datetime(date)
-
-        # Check if an entry with this date exists
         if entry_date not in df['date'].values:
             return f"❌ No entry found for {date}."
-
-        # Get the row index
         idx = df[df['date'] == entry_date].index[0]
-
-        # Update values if provided
-        if weight is not None:
-            df.at[idx, 'weight'] = weight
-        if calories_consumed is not None:
-            df.at[idx, 'calories_consumed'] = calories_consumed
-        if calories_burned is not None:
-            df.at[idx, 'calories_burned'] = calories_burned
-        if water_intake is not None:
-            df.at[idx, 'water_intake'] = water_intake
-        if sleep_hours is not None:
-            df.at[idx, 'sleep_hours'] = sleep_hours
-        if stress_level is not None:
-            df.at[idx, 'stress_level'] = stress_level
-        if mood:
-            df.at[idx, 'mood'] = mood
-        if exercise_minutes is not None:
-            df.at[idx, 'exercise_minutes'] = exercise_minutes
-        if notes is not None:
-            df.at[idx, 'notes'] = notes
-
-        # Save to CSV
+        if weight is not None: df.at[idx, 'weight'] = float(weight)
+        if calories_consumed is not None: df.at[idx, 'calories_consumed'] = float(calories_consumed)
+        if calories_burned is not None: df.at[idx, 'calories_burned'] = float(calories_burned)
+        if water_intake is not None: df.at[idx, 'water_intake'] = float(water_intake)
+        if sleep_hours is not None: df.at[idx, 'sleep_hours'] = float(sleep_hours)
+        if stress_level is not None: df.at[idx, 'stress_level'] = int(stress_level)
+        if mood: df.at[idx, 'mood'] = mood
+        if exercise_minutes is not None: df.at[idx, 'exercise_minutes'] = float(exercise_minutes)
+        if notes is not None: df.at[idx, 'notes'] = notes
         df.to_csv(DATA_FILE, index=False)
-
-        # Run prediction update if we have enough data
-        if len(df) >= 7:  # Need at least a week of data for prediction
-            train_prediction_model()
-
+        update_achievements()
         return f"✅ Entry for {date} updated successfully!"
-
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
 def delete_entry(date):
-    """Delete an entry from the journal"""
     global df
-
-    # Validate date
     if not date:
         return "❌ Date is required."
-
     try:
-        # Convert date to datetime
         entry_date = pd.to_datetime(date)
-
-        # Check if an entry with this date exists
         if entry_date not in df['date'].values:
             return f"❌ No entry found for {date}."
-
-        # Delete the entry
         df = df[df['date'] != entry_date]
-
-        # Save to CSV
         df.to_csv(DATA_FILE, index=False)
-
-        # Run prediction update if we have enough data
-        if len(df) >= 7:  # Need at least a week of data for prediction
-            train_prediction_model()
-
+        update_achievements()
         return f"✅ Entry for {date} deleted successfully!"
-
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
 def load_entry_by_date(date):
-    """Load an entry by date for viewing or editing"""
-    global df
-
-    # Validate date
     if not date:
-        return None, None, None, None, None, None, None, None, None, "❌ Date is required."
-
+        return [None] * 9 + ["❌ Date is required."]
     try:
-        # Convert date to datetime
         entry_date = pd.to_datetime(date)
-
-        # Check if an entry with this date exists
         if entry_date not in df['date'].values:
-            return None, None, None, None, None, None, None, None, None, f"❌ No entry found for {date}."
-
-        # Get the entry
+            return [None] * 9 + [f"❌ No entry found for {date}."]
         entry = df[df['date'] == entry_date].iloc[0]
-
-        # Return all fields
-        return (entry['weight'], entry['calories_consumed'], entry['calories_burned'],
-                entry['water_intake'], entry['sleep_hours'], entry['stress_level'],
-                entry['mood'], entry['exercise_minutes'], entry['notes'],
-                f"✅ Entry for {date} loaded successfully!")
-
+        return [entry[col] for col in ['weight', 'calories_consumed', 'calories_burned', 'water_intake',
+                                       'sleep_hours', 'stress_level', 'mood', 'exercise_minutes', 'notes']] + \
+               [f"✅ Entry for {date} loaded successfully!"]
     except Exception as e:
-        return None, None, None, None, None, None, None, None, None, f"❌ Error: {str(e)}"
+        return [None] * 9 + [f"❌ Error: {str(e)}"]
+
+# Visualization Functions
+def create_dashboard():
+    if len(df) < 3:
+        return "❌ Not enough data.", None
+    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
+    df.sort_values('date').plot(x='date', y='weight', ax=ax1, title="Weight Trend", marker='o', color='blue')
+    df.sort_values('date').plot(x='date', y=['calories_consumed', 'calories_burned'], ax=ax2, title="Calories", kind='bar')
+    df.sort_values('date').plot(x='date', y='water_intake', ax=ax3, title="Water Intake", marker='s', color='green')
+    for ax in [ax1, ax2, ax3]:
+        ax.grid(True, alpha=0.3)
+        ax.tick_params(axis='x', rotation=45)
+    plt.tight_layout()
+    return "✅ Dashboard ready!", fig
 
 def create_weight_plot():
-    """Create a plot showing weight over time"""
-    global df
-
-    if len(df) < 3:  # Need at least a few entries for a meaningful plot
-        return "❌ Not enough data to create a plot. Please add more entries.", None
-
-    # Create a copy of the dataframe for plotting
-    plot_df = df.copy()
-    plot_df = plot_df.sort_values('date')  # Sort by date for proper timeline
-
-    # Create the figure
+    if len(df) < 3:
+        return "❌ Not enough data.", None
+    plot_df = df.sort_values('date')
     plt.figure(figsize=(10, 6))
-    plt.plot(plot_df['date'], plot_df['weight'], marker='o', linestyle='-', color='blue')
+    plt.plot(plot_df['date'], plot_df['weight'], marker='o', linestyle='-', color='blue', label='Weight')
+    if goal['target_weight']:
+        plt.axhline(y=goal['target_weight'], color='green', linestyle='--', label='Goal')
     plt.title('Weight Over Time')
     plt.xlabel('Date')
     plt.ylabel('Weight')
+    plt.legend()
     plt.grid(True, alpha=0.3)
     plt.xticks(rotation=45)
-
-    # Add a trend line if we have enough data
-    if len(plot_df) >= 5:
-        x = np.arange(len(plot_df))
-        y = plot_df['weight'].values
-        z = np.polyfit(x, y, 1)
-        p = np.poly1d(z)
-        plt.plot(plot_df['date'], p(x), "r--", alpha=0.8, label=f"Trend: {z[0]:.2f} per day")
-        plt.legend()
-
-    # Save the figure to a temporary file
     temp_file = "temp_weight_plot.png"
     plt.tight_layout()
     plt.savefig(temp_file)
     plt.close()
+    return "✅ Plot generated!", temp_file
 
-    return "✅ Plot generated successfully!", temp_file
-
-def create_calories_plot():
-    """Create a plot showing calories consumed vs burned over time"""
-    global df
-
-    if len(df) < 3:  # Need at least a few entries for a meaningful plot
-        return "❌ Not enough data to create a plot. Please add more entries.", None
-
-    # Create a copy of the dataframe for plotting
-    plot_df = df.copy()
-    plot_df = plot_df.sort_values('date')  # Sort by date for proper timeline
-
-    # Calculate net calories (consumed - burned)
-    plot_df['net_calories'] = plot_df['calories_consumed'] - plot_df['calories_burned']
+# Goal Setting
+def set_goal(target_weight, target_date):
+    global goal
+    if not target_weight or not target_date:
+        return "❌ Target weight and date are required."
+    try:
+        goal = {'target_weight': float(target_weight), 'target_date': pd.to_datetime(target_date).strftime('%Y-%m-%d')}
+        with open(GOAL_FILE, 'w') as f:
+            json.dump(goal, f)
+        return "✅ Goal set successfully!"
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-    # Create the figure
+def view_goal():
+    if not goal['target_weight']:
+        return "No goal set yet."
+    return f"Target Weight: {goal['target_weight']} | Target Date: {goal['target_date']}\n" + \
+           f"Progress: {((df['weight'].iloc[-1] - goal['target_weight']) / (df['weight'].iloc[0] - goal['target_weight']) * 100):.1f}%"
+
+# Achievements
+def update_achievements():
+    global achievements
+    new_achievements = []
+    if len(df) >= 1 and "First Entry 🏅" not in achievements:
+        new_achievements.append("First Entry 🏅")
+    if len(df) >= 7 and df['date'].diff().mean().days <= 1 and "Consistency Star 🌟" not in achievements:
+        new_achievements.append("Consistency Star 🌟")
+    if len(df) >= 7 and df['water_intake'].tail(7).mean() >= 8 and "Water Warrior 💧" not in achievements:
+        new_achievements.append("Water Warrior 💧")
+    achievements.extend(new_achievements)
+    with open(ACHIEVEMENTS_FILE, 'w') as f:
+        json.dump(achievements, f)
+    return "\n".join(achievements) or "No achievements yet—keep going!"
+
+# Prediction
+def predict_weight_trajectory(days=30, calorie_adjustment=0, exercise_adjustment=0):
+    if len(df) < 7 or not os.path.exists(MODEL_FILE):
+        return "❌ Not enough data or model not trained.", None, ""
+    model = joblib.load(MODEL_FILE)
+    scaler = joblib.load(SCALER_FILE)
+    last_entry = df.sort_values('date', ascending=False).iloc[0]
+    last_week = df.sort_values('date', ascending=False).head(7)
+    avg_calories_consumed = last_week['calories_consumed'].mean() + calorie_adjustment
+    avg_calories_burned = last_week['calories_burned'].mean() + calorie_adjustment
+    avg_exercise = last_week['exercise_minutes'].mean() + exercise_adjustment
+    predict_data = pd.DataFrame({
+        'date': [last_entry['date'] + datetime.timedelta(days=i) for i in range(1, days+1)],
+        'calories_consumed': [avg_calories_consumed] * days,
+        'calories_burned': [avg_calories_burned] * days,
+        'water_intake': [last_week['water_intake'].mean()] * days,
+        'sleep_hours': [last_week['sleep_hours'].mean()] * days,
+        'stress_level': [last_week['stress_level'].mean()] * days,
+        'exercise_minutes': [avg_exercise] * days
+    })
+    X_pred = predict_data[['calories_consumed', 'calories_burned', 'water_intake', 'sleep_hours', 'stress_level', 'exercise_minutes']]
+    X_pred_scaled = scaler.transform(X_pred)
+    predict_data['weight'] = model.predict(X_pred_scaled)
+    
     plt.figure(figsize=(10, 6))
-    plt.bar(plot_df['date'], plot_df['calories_consumed'], alpha=0.7, color='blue', label='Consumed')
-    plt.bar(plot_df['date'], -plot_df['calories_burned'], alpha=0.7, color='red', label='Burned')
-    plt.plot(plot_df['date'], plot_df['net_calories'], marker='o', linestyle='-', color='green', label='Net Calories')
-
-    plt.title('Calories Consumed vs. Burned')
+    plt.plot(df['date'], df['weight'], 'o-', color='blue', label='Historical')
+    plt.plot(predict_data['date'], predict_data['weight'], 'o--', color='red', label='Predicted')
+    if goal['target_weight']:
+        plt.axhline(y=goal['target_weight'], color='green', linestyle='--', label='Goal')
+    plt.title('Weight Trajectory Prediction')
     plt.xlabel('Date')
-    plt.ylabel('Calories')
+    plt.ylabel('Weight')
     plt.grid(True, alpha=0.3)
     plt.xticks(rotation=45)
-    plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
     plt.legend()
-
-    # Save the figure to a temporary file
-    temp_file = "temp_calories_plot.png"
-    plt.tight_layout()
-    plt.savefig(temp_file)
-    plt.close()
-
-    return "✅ Plot generated successfully!", temp_file
-
-def create_water_sleep_plot():
-    """Create a plot showing water intake vs sleep hours over time"""
-    global df
-
-    if len(df) < 3:  # Need at least a few entries for a meaningful plot
-        return "❌ Not enough data to create a plot. Please add more entries.", None
-
-    # Create a copy of the dataframe for plotting
-    plot_df = df.copy()
-    plot_df = plot_df.sort_values('date')  # Sort by date for proper timeline
-
-    # Create a figure with dual y-axis
-    fig, ax1 = plt.subplots(figsize=(10, 6))
-
-    # Plot water intake on left y-axis
-    color = 'tab:blue'
-    ax1.set_xlabel('Date')
-    ax1.set_ylabel('Water Intake (cups)', color=color)
-    ax1.plot(plot_df['date'], plot_df['water_intake'], color=color, marker='o', label='Water Intake')
-    ax1.tick_params(axis='y', labelcolor=color)
-
-    # Create second y-axis for sleep hours
-    ax2 = ax1.twinx()
-    color = 'tab:red'
-    ax2.set_ylabel('Sleep Hours', color=color)
-    ax2.plot(plot_df['date'], plot_df['sleep_hours'], color=color, marker='s', label='Sleep Hours')
-    ax2.tick_params(axis='y', labelcolor=color)
-
-    # Rotate date labels for better readability
-    fig.autofmt_xdate()
-
-    # Add title and grid
-    plt.title('Water Intake vs Sleep Hours Over Time')
-    ax1.grid(True, alpha=0.3)
-
-    # Add a legend
-    lines1, labels1 = ax1.get_legend_handles_labels()
-    lines2, labels2 = ax2.get_legend_handles_labels()
-    ax1.legend(lines1 + lines2, labels1 + labels2, loc='best')
-
-    # Save the figure to a temporary file
-    temp_file = "temp_water_sleep_plot.png"
-    plt.tight_layout()
-    plt.savefig(temp_file)
-    plt.close()
-
-    return "✅ Plot generated successfully!", temp_file
+    
+    start_weight = df['weight'].iloc[-1]
+    end_weight = predict_data['weight'].iloc[-1]
+    report = f"Starting weight: {start_weight:.1f}\nPredicted weight after {days} days: {end_weight:.1f}\n" + \
+             f"Change: {end_weight - start_weight:.1f}"
+    recommendations = "Keep tracking consistently!" if end_weight < start_weight else "Consider reducing calories."
+    return report, plt, recommendations
 
 def train_prediction_model():
-    """Train a machine learning model to predict weight based on other factors"""
-    global df
-
-    if len(df) < 7:  # Need at least a week of data
-        return "❌ Not enough data to train model. Please add at least 7 entries."
-
-    try:
-        # Create a copy and sort by date
-        model_df = df.copy()
-        model_df = model_df.sort_values('date')
-
-        # Create features
-        features = ['calories_consumed', 'calories_burned', 'water_intake',
-                   'sleep_hours', 'stress_level', 'exercise_minutes']
-        X = model_df[features]
-        y = model_df['weight']
-
-        # Check for missing values and fill with medians
-        for col in X.columns:
-            if X[col].isnull().any():
-                X[col] = X[col].fillna(X[col].median())
-
-        # Scale features
-        scaler = StandardScaler()
-        X_scaled = scaler.fit_transform(X)
-
-        # Train model
-        model = LinearRegression()
-        model.fit(X_scaled, y)
-
-        # Save model and scaler
-        joblib.dump(model, MODEL_FILE)
-        joblib.dump(scaler, SCALER_FILE)
-
-        # Calculate model performance
-        y_pred = model.predict(X_scaled)
-        mse = np.mean((y - y_pred) ** 2)
-        rmse = np.sqrt(mse)
-
-        # Calculate feature importance
-        importance = pd.DataFrame({
-            'Feature': features,
-            'Importance': np.abs(model.coef_)
-        }).sort_values('Importance', ascending=False)
-
-        # Generate report
-        report = f"✅ Model trained successfully!\n\n"
-        report += f"Model performance: RMSE = {rmse:.2f}\n\n"
-        report += "Feature Importance:\n"
-        for _, row in importance.iterrows():
-            report += f"- {row['Feature']}: {row['Importance']:.2f}\n"
-
-        return report
-
-    except Exception as e:
-        return f"❌ Error training model: {str(e)}"
-
-def predict_weight_trajectory(days=30, calorie_adjustment=0, water_adjustment=0,
-                              sleep_adjustment=0, stress_adjustment=0, exercise_adjustment=0):
-    """Predict weight trajectory for the next N days based on current trends and adjustments"""
-    global df
-
-    if len(df) < 7:  # Need at least a week of data
-        return "❌ Not enough data for prediction. Please add at least 7 entries.", None, ""
-
-    if not os.path.exists(MODEL_FILE) or not os.path.exists(SCALER_FILE):
-        return "❌ Prediction model not trained. Please train the model first.", None, ""
-
-    try:
-        # Load model and scaler
-        model = joblib.load(MODEL_FILE)
-        scaler = joblib.load(SCALER_FILE)
-
-        # Get the most recent entry as baseline
-        last_entry = df.sort_values('date', ascending=False).iloc[0]
-
-        # Get average values from the last week for prediction
-        last_week = df.sort_values('date', ascending=False).head(7)
-        avg_calories_consumed = last_week['calories_consumed'].mean() + calorie_adjustment
-        avg_calories_burned = last_week['calories_burned'].mean() + calorie_adjustment  # We apply same adjustment
-        avg_water = last_week['water_intake'].mean() + water_adjustment
-        avg_sleep = last_week['sleep_hours'].mean() + sleep_adjustment
-        avg_stress = last_week['stress_level'].mean() + stress_adjustment
-        avg_exercise = last_week['exercise_minutes'].mean() + exercise_adjustment
-
-        # Create prediction data
-        future_dates = [last_entry['date'] + datetime.timedelta(days=i) for i in range(1, days+1)]
-        predict_data = pd.DataFrame({
-            'date': future_dates,
-            'calories_consumed': [avg_calories_consumed] * days,
-            'calories_burned': [avg_calories_burned] * days,
-            'water_intake': [avg_water] * days,
-            'sleep_hours': [avg_sleep] * days,
-            'stress_level': [avg_stress] * days,
-            'exercise_minutes': [avg_exercise] * days
-        })
-
-        # Scale features for prediction
-        features = ['calories_consumed', 'calories_burned', 'water_intake',
-                   'sleep_hours', 'stress_level', 'exercise_minutes']
-        X_pred = predict_data[features]
-        X_pred_scaled = scaler.transform(X_pred)
-
-        # Predict weights
-        predicted_weights = model.predict(X_pred_scaled)
-        predict_data['weight'] = predicted_weights
-
-        # Create plot
-        plt.figure(figsize=(10, 6))
-
-        # Plot historical data
-        hist_data = df.copy().sort_values('date')
-        plt.plot(hist_data['date'], hist_data['weight'], 'o-', color='blue', label='Historical')
-
-        # Plot prediction
-        plt.plot(predict_data['date'], predict_data['weight'], 'o--', color='red', label='Predicted')
-
-        # Add details
-        plt.title('Weight Trajectory Prediction')
-        plt.xlabel('Date')
-        plt.ylabel('Weight')
-        plt.grid(True, alpha=0.3)
-        plt.xticks(rotation=45)
-        plt.legend()
-
-        # Calculate metrics
-        start_weight = hist_data['weight'].iloc[-1]
-        end_weight = predict_data['weight'].iloc[-1]
-        weight_change = end_weight - start_weight
-
-        # Generate report
-        report = f"✅ Prediction completed!\n\n"
-        report += f"Starting weight: {start_weight:.1f}\n"
-        report += f"Predicted weight after {days} days: {end_weight:.1f}\n"
-        report += f"Projected change: {weight_change:.1f} ({weight_change/start_weight*100:.1f}%)\n"
-
-        # Generate recommendations
-        if weight_change > 0:
-            recommendations = "## 📊 Recommendations for Weight Loss:\n\n"
-            recommendations += "Based on the prediction model, here are personalized recommendations:\n\n"
-
-            if calorie_adjustment >= 0:
-                recommendations += "1. **Reduce calorie intake** by 300-500 calories per day\n"
-            if avg_exercise < 30:
-                recommendations += "2. **Increase exercise** to at least 30 minutes per day\n"
-            if avg_water < 8:
-                recommendations += "3. **Drink more water**, aim for 8+ cups daily\n"
-            if avg_sleep < 7:
-                recommendations += "4. **Improve sleep quality** to 7-8 hours per night\n"
-            if avg_stress > 5:
-                recommendations += "5. **Implement stress management techniques** like meditation\n"
-        else:
-            recommendations = "## 📊 Recommendations to Maintain Progress:\n\n"
-            recommendations += "Based on the prediction model, you're on track! Here are tips to maintain progress:\n\n"
-            recommendations += "1. **Keep consistent** with your current habits\n"
-            recommendations += "2. **Add variety** to your exercise routine to stay engaged\n"
-            recommendations += "3. **Continue tracking** your metrics to monitor trends\n"
-
-        return report, plt, recommendations
-
-    except Exception as e:
-        return f"❌ Error generating prediction: {str(e)}", None, ""
-
-def create_sample_data():
-    """Create sample data for demonstration purposes"""
-    # Start date (30 days ago)
-    start_date = datetime.datetime.now() - datetime.timedelta(days=30)
-
-    # Initialize weight and other parameters
-    initial_weight = 180  # Example starting weight
-
-    # Create sample dataframe
-    sample_data = []
-
-    for i in range(30):
-        # Current date
-        current_date = start_date + datetime.timedelta(days=i)
-
-        # Weight trend (gradually decreasing with some fluctuation)
-        # Add some randomness for realism
-        weight_change = -0.1 * i / 30  # Gradual decrease
-        daily_fluctuation = np.random.normal(0, 0.3)  # Random daily fluctuation
-        current_weight = initial_weight + (weight_change * initial_weight) + daily_fluctuation
-
-        # Other parameters (with realistic values and some correlation to weight loss)
-        calories_consumed = np.random.randint(1800, 2300)
-        calories_burned = np.random.randint(2000, 2500)
-        water_intake = np.random.randint(5, 10)
-        sleep_hours = np.random.normal(7, 0.5)
-        stress_level = np.random.randint(3, 8)
-        exercise_minutes = np.random.randint(20, 60)
-
-        # Mood (correlated somewhat with other factors)
-        mood_options = ['Great', 'Good', 'Neutral', 'Poor']
-        mood_probs = [0.2, 0.5, 0.2, 0.1]  # Probability distribution
-        mood = np.random.choice(mood_options, p=mood_probs)
-
-        # Notes
-        notes = ''
-
-        # Add to sample data
-        sample_data.append({
-            'date': current_date,
-            'weight': round(current_weight, 1),
-            'calories_consumed': calories_consumed,
-            'calories_burned': calories_burned,
-            'water_intake': water_intake,
-            'sleep_hours': round(sleep_hours, 1),
-            'stress_level': stress_level,
-            'mood': mood,
-            'exercise_minutes': exercise_minutes,
-            'notes': notes
-        })
-
-    return pd.DataFrame(sample_data)
+    if len(df) < 7:
+        return "❌ Not enough data."
+    model_df = df.sort_values('date')
+    features = ['calories_consumed', 'calories_burned', 'water_intake', 'sleep_hours', 'stress_level', 'exercise_minutes']
+    X = model_df[features].fillna(model_df[features].median())
+    y = model_df['weight']
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+    model = LinearRegression()
+    model.fit(X_scaled, y)
+    joblib.dump(model, MODEL_FILE)
+    joblib.dump(scaler, SCALER_FILE)
+    return "✅ Model trained!"
+
+# Food Log
+def log_food(food_name, quantity):
+    if food_name not in food_df['name'].values:
+        return "❌ Food not found."
+    calories = food_df[food_df['name'] == food_name]['calories'].iloc[0] * quantity
+    return f"✅ Logged {quantity} of {food_name} ({calories} calories). Add to your entry!"
 
 # Gradio Interface
-with gr.Blocks(title="Weight Loss Journal", theme=gr.themes.Soft()) as iface:
-    gr.Markdown("# 🏋️‍♀️ Weight Loss Journal")
+with gr.Blocks(title="FitJourney", theme=gr.themes.Soft(primary_hue="blue")) as iface:
+    gr.Markdown("# 🏋️‍♀️ FitJourney - Your Weight Loss Companion")
+
+    with gr.Tab("Dashboard"):
+        dashboard_button = gr.Button("Show Dashboard", variant="primary")
+        dashboard_text = gr.Markdown()
+        dashboard_plot = gr.Plot()
+        dashboard_button.click(create_dashboard, outputs=[dashboard_text, dashboard_plot])
 
     with gr.Tab("Add Entry"):
         with gr.Row():
             with gr.Column():
                 date_input = gr.Textbox(label="Date (YYYY-MM-DD)")
-                weight_input = gr.Number(label="Weight")
+                weight_input = gr.Number(label="Weight (lbs)")
                 calories_consumed_input = gr.Number(label="Calories Consumed")
                 calories_burned_input = gr.Number(label="Calories Burned")
                 water_intake_input = gr.Number(label="Water Intake (cups)")
                 sleep_hours_input = gr.Number(label="Sleep Hours")
-                stress_level_input = gr.Slider(minimum=1, maximum=10, step=1, label="Stress Level (1-10)")
-                mood_input = gr.Dropdown(choices=['Great', 'Good', 'Neutral', 'Poor'], label="Mood")
+                stress_level_input = gr.Slider(1, 10, step=1, label="Stress Level")
+                mood_input = gr.Dropdown(['Great', 'Good', 'Neutral', 'Poor'], label="Mood")
                 exercise_minutes_input = gr.Number(label="Exercise Minutes")
                 notes_input = gr.Textbox(label="Notes")
         add_button = gr.Button("Add Entry", variant="primary")
         add_output = gr.Markdown()
-        add_button.click(add_entry,
-                         inputs=[date_input, weight_input, calories_consumed_input, calories_burned_input,
-                                 water_intake_input, sleep_hours_input, stress_level_input, mood_input,
-                                 exercise_minutes_input, notes_input],
-                         outputs=add_output)
+        add_button.click(add_entry, inputs=[date_input, weight_input, calories_consumed_input, calories_burned_input,
+                                            water_intake_input, sleep_hours_input, stress_level_input, mood_input,
+                                            exercise_minutes_input, notes_input], outputs=add_output)
 
     with gr.Tab("View Entries"):
-        num_entries_view = gr.Slider(minimum=5, maximum=30, step=5, value=10, label="Number of Entries to View")
-        view_button = gr.Button("View Entries", variant="secondary")
+        num_entries_view = gr.Slider(5, 30, step=5, value=10, label="Entries to View")
+        view_button = gr.Button("View", variant="secondary")
         view_output = gr.DataFrame()
         view_button.click(view_entries, inputs=num_entries_view, outputs=view_output)
 
     with gr.Tab("Update Entry"):
-        date_update_input = gr.Textbox(label="Date to Update (YYYY-MM-DD)")
+        date_update_input = gr.Textbox(label="Date (YYYY-MM-DD)")
         with gr.Row():
             with gr.Column():
-                weight_update_input = gr.Number(label="Weight")
+                weight_update_input = gr.Number(label="Weight (lbs)")
                 calories_consumed_update_input = gr.Number(label="Calories Consumed")
                 calories_burned_update_input = gr.Number(label="Calories Burned")
                 water_intake_update_input = gr.Number(label="Water Intake (cups)")
                 sleep_hours_update_input = gr.Number(label="Sleep Hours")
-                stress_level_update_input = gr.Slider(minimum=1, maximum=10, step=1, label="Stress Level (1-10)")
-                mood_update_input = gr.Dropdown(choices=['Great', 'Good', 'Neutral', 'Poor'], label="Mood")
+                stress_level_update_input = gr.Slider(1, 10, step=1, label="Stress Level")
+                mood_update_input = gr.Dropdown(['Great', 'Good', 'Neutral', 'Poor'], label="Mood")
                 exercise_minutes_update_input = gr.Number(label="Exercise Minutes")
                 notes_update_input = gr.Textbox(label="Notes")
-        update_button = gr.Button("Update Entry", variant="primary")
+        update_button = gr.Button("Update", variant="primary")
         update_output = gr.Markdown()
-        update_button.click(update_entry,
-                            inputs=[date_update_input, weight_update_input, calories_consumed_update_input,
-                                    calories_burned_update_input, water_intake_update_input, sleep_hours_update_input,
-                                    stress_level_update_input, mood_update_input, exercise_minutes_update_input,
-                                    notes_update_input],
-                            outputs=update_output)
-
-    with gr.Tab("Delete Entry"):
-        date_delete_input = gr.Textbox(label="Date to Delete (YYYY-MM-DD)")
-        delete_button = gr.Button("Delete Entry", variant="secondary")
-        delete_output = gr.Markdown()
-        delete_button.click(delete_entry, inputs=date_delete_input, outputs=delete_output)
-
-    with gr.Tab("Load Entry"):
-        date_load_input = gr.Textbox(label="Date to Load (YYYY-MM-DD)")
-        load_button = gr.Button("Load Entry", variant="secondary")
-        with gr.Row():
-             with gr.Column():
-                weight_load_output = gr.Number(label="Weight")
-                calories_consumed_load_output = gr.Number(label="Calories Consumed")
-                calories_burned_load_output = gr.Number(label="Calories Burned")
-                water_intake_load_output = gr.Number(label="Water Intake (cups)")
-                sleep_hours_load_output = gr.Number(label="Sleep Hours")
-                stress_level_load_output = gr.Slider(minimum=1, maximum=10, step=1, label="Stress Level (1-10)")
-                mood_load_output = gr.Dropdown(choices=['Great', 'Good', 'Neutral', 'Poor'], label="Mood")
-                exercise_minutes_load_output = gr.Number(label="Exercise Minutes")
-                notes_load_output = gr.Textbox(label="Notes")
-        load_output = gr.Markdown()
-        load_button.click(load_entry_by_date, inputs=date_load_input, outputs=[weight_load_output, calories_consumed_load_output, calories_burned_load_output, water_intake_load_output, sleep_hours_load_output, stress_level_load_output, mood_load_output, exercise_minutes_load_output, notes_load_output, load_output])
+        update_button.click(update_entry, inputs=[date_update_input, weight_update_input, calories_consumed_update_input,
+                                                  calories_burned_update_input, water_intake_update_input, sleep_hours_update_input,
+                                                  stress_level_update_input, mood_update_input, exercise_minutes_update_input,
+                                                  notes_update_input], outputs=update_output)
+
+    with gr.Tab("Goals"):
+        target_weight_input = gr.Number(label="Target Weight (lbs)")
+        target_date_input = gr.Textbox(label="Target Date (YYYY-MM-DD)")
+        goal_button = gr.Button("Set Goal", variant="primary")
+        goal_output = gr.Markdown()
+        goal_view_button = gr.Button("View Goal Progress", variant="secondary")
+        goal_view_output = gr.Markdown()
+        goal_button.click(set_goal, inputs=[target_weight_input, target_date_input], outputs=goal_output)
+        goal_view_button.click(view_goal, outputs=goal_view_output)
+
+    with gr.Tab("Achievements"):
+        achievements_output = gr.Markdown(value=update_achievements())
+        gr.Button("Refresh Achievements").click(update_achievements, outputs=achievements_output)
 
     with gr.Tab("Analytics"):
-        with gr.Row():
-            with gr.Column():
-                weight_plot_button = gr.Button("Weight Over Time", variant="secondary")
-                weight_plot_output_text = gr.Markdown()
-                weight_plot_output = gr.Image()
-            with gr.Column():
-                calories_plot_button = gr.Button("Calories Consumed vs. Burned", variant="secondary")
-                calories_plot_output_text = gr.Markdown()
-                calories_plot_output = gr.Image()
-            with gr.Column():
-                water_sleep_plot_button = gr.Button("Water Intake vs. Sleep Hours", variant="secondary")
-                water_sleep_plot_output_text = gr.Markdown()
-                water_sleep_plot_output = gr.Image()
-
-        weight_plot_button.click(create_weight_plot, inputs=[], outputs=[weight_plot_output_text, weight_plot_output])
-        calories_plot_button.click(create_calories_plot, inputs=[], outputs=[calories_plot_output_text, calories_plot_output])
-        water_sleep_plot_button.click(create_water_sleep_plot, inputs=[], outputs=[water_sleep_plot_output_text, water_sleep_plot_output])
+        weight_plot_button = gr.Button("Weight Over Time", variant="secondary")
+        weight_plot_output_text = gr.Markdown()
+        weight_plot_output = gr.Image()
+        weight_plot_button.click(create_weight_plot, outputs=[weight_plot_output_text, weight_plot_output])
 
     with gr.Tab("Prediction"):
-        with gr.Row():
-            with gr.Column():
-                days_input = gr.Slider(minimum=7, maximum=90, step=7, value=30, label="Days to Predict")
-                calorie_adjustment_input = gr.Number(label="Calorie Deficit Adjustment")
-                water_adjustment_input = gr.Number(label="Water Intake Adjustment")
-                sleep_adjustment_input = gr.Number(label="Sleep Hours Adjustment")
-                stress_adjustment_input = gr.Number(label="Stress Level Adjustment")
-                exercise_adjustment_input = gr.Number(label="Exercise Minutes Adjustment")
-                predict_button = gr.Button("Predict Weight Trajectory", variant="primary")
+        days_input = gr.Slider(7, 90, step=7, value=30, label="Days to Predict")
+        calorie_adjustment_input = gr.Number(label="Calorie Adjustment")
+        exercise_adjustment_input = gr.Number(label="Exercise Adjustment")
+        predict_button = gr.Button("Predict", variant="primary")
         prediction_output_text = gr.Markdown()
         prediction_plot_output = gr.Plot()
         recommendation_output = gr.Markdown()
-        predict_button.click(predict_weight_trajectory,
-                             inputs=[days_input, calorie_adjustment_input, water_adjustment_input,
-                                     sleep_adjustment_input, stress_adjustment_input, exercise_adjustment_input],
+        predict_button.click(predict_weight_trajectory, inputs=[days_input, calorie_adjustment_input, exercise_adjustment_input],
                              outputs=[prediction_output_text, prediction_plot_output, recommendation_output])
 
     with gr.Tab("Train Model"):
-        train_button = gr.Button("Train Prediction Model", variant="primary")
+        train_button = gr.Button("Train Model", variant="primary")
         train_output = gr.Markdown()
-        train_button.click(train_prediction_model, inputs=[], outputs=train_output)
+        train_button.click(train_prediction_model, outputs=train_output)
 
-    with gr.Tab("Sample Data"):
-        sample_button = gr.Button("Generate and Load Sample Data", variant="secondary")
-        sample_output = gr.Markdown()
+    with gr.Tab("Food Log"):
+        food_name_input = gr.Dropdown(choices=food_df['name'].tolist(), label="Food Item")
+        quantity_input = gr.Number(label="Quantity", minimum=1, value=1)
+        food_log_button = gr.Button("Log Food", variant="secondary")
+        food_log_output = gr.Markdown()
+        food_log_button.click(log_food, inputs=[food_name_input, quantity_input], outputs=food_log_output)
 
+    with gr.Tab("Sample Data"):
         def load_sample_data():
-            """Load sample data into the dataframe"""
             global df
-            sample_df = create_sample_data()
-            df = pd.concat([df, sample_df], ignore_index=True)
-            df['date'] = pd.to_datetime(df['date'])  # Ensure date is datetime
-            df = df.sort_values('date', ascending=False)  # Sort by date descending
-            df.to_csv('data/weight_journal.csv', index=False)
-
-            # Run prediction update
-            if len(df) >= 7:  # Need at least a week of data for prediction
-                train_prediction_model()
-            return "✅ Sample data loaded successfully! Please refresh the other tabs for results."
+            start_date = datetime.datetime.now() - datetime.timedelta(days=30)
+            sample_data = [{'date': start_date + datetime.timedelta(days=i),
+                            'weight': 180 - (0.1 * i) + np.random.normal(0, 0.3),
+                            'calories_consumed': np.random.randint(1800, 2300),
+                            'calories_burned': np.random.randint(2000, 2500),
+                            'water_intake': np.random.randint(5, 10),
+                            'sleep_hours': round(np.random.normal(7, 0.5), 1),
+                            'stress_level': np.random.randint(3, 8),
+                            'mood': np.random.choice(['Great', 'Good', 'Neutral', 'Poor']),
+                            'exercise_minutes': np.random.randint(20, 60),
+                            'notes': ''} for i in range(30)]
+            df = pd.concat([df, pd.DataFrame(sample_data)], ignore_index=True)
+            df['date'] = pd.to_datetime(df['date'])
+            df = df.sort_values('date', ascending=False)
+            df.to_csv(DATA_FILE, index=False)
+            update_achievements()
+            return "✅ Sample data loaded!"
+        sample_button = gr.Button("Load Sample Data", variant="secondary")
+        sample_output = gr.Markdown()
+        sample_button.click(load_sample_data, outputs=sample_output)
 
-        sample_button.click(load_sample_data, inputs=[], outputs=sample_output)
 iface.launch(debug=False)