Upload 52 files

OLD/Chatbot.py

@@ -0,0 +1,52 @@
+import streamlit as st
+import pandas as pd
+import requests
+
+# ---- Load sample data ----
+@st.cache_data
+def load_data():
+    return pd.read_csv("data.csv")
+
+df = load_data()
+
+# ---- Sidebar ----
+st.sidebar.title("Controls")
+task = st.sidebar.selectbox("Choose task", ["Chat with Bot (via n8n)", "Analyze Data"])
+
+# ---- Main UI ----
+st.title("💬 Data Analysis Assistant (Streamlit + n8n + Ollama)")
+
+if task == "Analyze Data":
+    st.subheader("📊 Sales Data")
+    st.dataframe(df)
+
+    st.write("### Total Sales:")
+    st.metric("💵 Amount", f"${df['amount'].sum():,.2f}")
+
+    top_customer = df.groupby("customer")["amount"].sum().idxmax()
+    st.write(f"**Top Customer:** {top_customer}")
+
+elif task == "Chat with Bot (via n8n)":
+    st.subheader("🤖 Ask Questions")
+    user_input = st.text_area("Your question:", placeholder="e.g. Who spent the most?")
+
+    if st.button("Ask Bot") and user_input:
+        # Send request to n8n webhook
+        payload = {
+            "question": user_input,
+            "data": df.to_dict(orient="records")
+        }
+
+        try:
+            response = requests.post(
+                "http://localhost:5678/webhook/chatbot",
+                json=payload,
+                timeout=60
+            )
+            if response.ok:
+                answer = response.json().get("answer", response.text)
+                st.success(answer)
+            else:
+                st.error(f"n8n Error: {response.status_code}")
+        except Exception as e:
+            st.error(f"Connection failed: {e}")

OLD/Main.py

@@ -0,0 +1,244 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+def analyze_sales_data(data1, data2):
+    """
+    Analyze sales data to identify targets for mantri communication and village focus
+    """
+    
+    # Convert date column if needed
+    data1['Date'] = pd.to_datetime(data1['Date'])
+    
+    # Clean and preprocess data2
+    data2['Date'] = pd.to_datetime(data2['Date'])
+    
+    # Calculate key metrics from Data1 (village level)
+    data1['Conversion_Rate'] = (data1['Contact_In_Group'] / data1['Sabhasad'] * 100).round(2)
+    data1['Conversion_Rate'] = data1['Conversion_Rate'].replace([np.inf, -np.inf], 0).fillna(0)
+    data1['Untapped_Potential'] = data1['Sabhasad'] - data1['Contact_In_Group']
+    data1['Sales_Per_Contact'] = (data1['Total_L'] / data1['Contact_In_Group']).round(2)
+    data1['Sales_Per_Contact'] = data1['Sales_Per_Contact'].replace([np.inf, -np.inf], 0).fillna(0)
+    
+    # Calculate priority score for villages
+    data1['Priority_Score'] = (
+        (data1['Untapped_Potential'] / data1['Untapped_Potential'].max() * 50) +
+        ((100 - data1['Conversion_Rate']) / 100 * 50)
+    ).round(2)
+    
+    # Analyze recent sales from Data2 (customer level)
+    # Since we don't have customer contact info, we'll analyze at village level
+    recent_sales = data2.groupby('Village').agg({
+        'Total_L': ['sum', 'count'],
+        'Date': 'max'
+    }).reset_index()
+    
+    # Flatten the column names
+    recent_sales.columns = ['Village', 'Recent_Sales_L', 'Recent_Customers', 'Last_Sale_Date']
+    
+    # Calculate days since last sale
+    recent_sales['Days_Since_Last_Sale'] = (datetime.now() - recent_sales['Last_Sale_Date']).dt.days
+    
+    # Merge with Data1
+    analysis_df = data1.merge(recent_sales, on='Village', how='left')
+    analysis_df['Recent_Sales_L'] = analysis_df['Recent_Sales_L'].fillna(0)
+    analysis_df['Recent_Customers'] = analysis_df['Recent_Customers'].fillna(0)
+    analysis_df['Days_Since_Last_Sale'] = analysis_df['Days_Since_Last_Sale'].fillna(999)
+    
+    # Generate recommendations for mantris
+    recommendations = []
+    
+    for _, row in analysis_df.iterrows():
+        village = row['Village']
+        mantri = row['Mantri_Name']
+        mobile = row['Mantri_Mobile']
+        taluka = row['Taluka']
+        district = row['District']
+        
+        # Recommendation logic
+        if row['Conversion_Rate'] < 20:
+            recommendations.append({
+                'Village': village,
+                'Taluka': taluka,
+                'District': district,
+                'Mantri': mantri,
+                'Mobile': mobile,
+                'Action': 'Send Marketing Team',
+                'Reason': f'Low conversion rate ({row["Conversion_Rate"]:.1f}%) - Only {row["Contact_In_Group"]} of {row["Sabhasad"]} sabhasad contacted',
+                'Priority': 'High',
+                'Score': row['Priority_Score']
+            })
+        elif row['Untapped_Potential'] > 30:
+            recommendations.append({
+                'Village': village,
+                'Taluka': taluka,
+                'District': district,
+                'Mantri': mantri,
+                'Mobile': mobile,
+                'Action': 'Call Mantri for Follow-up',
+                'Reason': f'High untapped potential ({row["Untapped_Potential"]} sabhasad not contacted)',
+                'Priority': 'High',
+                'Score': row['Priority_Score']
+            })
+        elif row['Days_Since_Last_Sale'] > 30:
+            recommendations.append({
+                'Village': village,
+                'Taluka': taluka,
+                'District': district,
+                'Mantri': mantri,
+                'Mobile': mobile,
+                'Action': 'Check on Mantri',
+                'Reason': f'No recent sales ({row["Days_Since_Last_Sale"]} days since last sale)',
+                'Priority': 'Medium',
+                'Score': row['Priority_Score']
+            })
+        elif row['Sales_Per_Contact'] > 10:
+            recommendations.append({
+                'Village': village,
+                'Taluka': taluka,
+                'District': district,
+                'Mantri': mantri,
+                'Mobile': mobile,
+                'Action': 'Provide More Stock',
+                'Reason': f'High sales per contact ({row["Sales_Per_Contact"]}L per contact)',
+                'Priority': 'Medium',
+                'Score': row['Priority_Score']
+            })
+        else:
+            recommendations.append({
+                'Village': village,
+                'Taluka': taluka,
+                'District': district,
+                'Mantri': mantri,
+                'Mobile': mobile,
+                'Action': 'Regular Follow-up',
+                'Reason': 'Steady performance - maintain relationship',
+                'Priority': 'Low',
+                'Score': row['Priority_Score']
+            })
+    
+    return pd.DataFrame(recommendations), analysis_df
+
+def generate_mantri_messages(recommendations):
+    """
+    Generate personalized WhatsApp messages for mantris based on recommendations
+    """
+    messages = []
+    
+    for _, row in recommendations.iterrows():
+        if row['Action'] == 'Send Marketing Team':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Aapke kshetra {row['Village']} mein humare calcium supplement ki conversion rate kam hai. 
+Humari marketing team aapke yaha demo dene aayegi. 
+Kripya taiyaari rakhein aur sabhi dudh utpadakon ko soochit karein.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        elif row['Action'] == 'Call Mantri for Follow-up':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Aapke kshetra {row['Village']} mein bahut se aise farmers hain jo abhi tak humare product se anabhijit hain. 
+Kripya unse sampark karein aur unhe product ke fayde batayein. 
+Aapke liye special commission offer hai agle 10 customers ke liye.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        elif row['Action'] == 'Check on Mantri':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Humne dekha ki aapke kshetra {row['Village']} mein kuch samay se sales nahi hue hain.
+Kya koi samasya hai? Kya hum aapki kisi tarah madad kar sakte hain?
+
+Kripya hame batayein.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        elif row['Action'] == 'Provide More Stock':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Badhai ho! Aapke kshetra {row['Village']} mein humare product ki demand badh rahi hai.
+Kya aapko aur stock ki zaroorat hai? Hum jald se jald aapko extra stock bhej denge.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        else:
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Aapke kshetra {row['Village']} mein humare product ki sales theek chal rahi hain.
+Kripya aise hi continue rakhein aur koi bhi sujhav ho toh hame batayein.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        
+        messages.append({
+            'Mantri': row['Mantri'],
+            'Mobile': row['Mobile'],
+            'Village': row['Village'],
+            'Action': row['Action'],
+            'Message': message,
+            'Priority': row['Priority']
+        })
+    
+    return pd.DataFrame(messages)
+
+def identify_demo_locations(analysis_df, top_n=5):
+    """
+    Identify the best locations for demos based on various factors
+    """
+    # Calculate a demo score based on multiple factors
+    analysis_df['Demo_Score'] = (
+        (analysis_df['Untapped_Potential'] / analysis_df['Untapped_Potential'].max() * 40) +
+        ((100 - analysis_df['Conversion_Rate']) / 100 * 30) +
+        (analysis_df['Recent_Sales_L'] / analysis_df['Recent_Sales_L'].max() * 30)
+    ).round(2)
+    
+    # Get top locations for demos
+    demo_locations = analysis_df.nlargest(top_n, 'Demo_Score')[
+        ['Village', 'Taluka', 'District', 'Mantri_Name', 'Mantri_Mobile', 
+         'Conversion_Rate', 'Untapped_Potential', 'Demo_Score']
+    ]
+    
+    return demo_locations
+
+# Example usage with sample data structure
+def main():
+    # Sample data based on your new structure
+    data2=pd.read_excel("sampletesting.xlsx",sheet_name="Sheet1")
+    data1=pd.read_excel("sampletesting.xlsx",sheet_name="Sheet2")
+    
+    # Generate recommendations
+    recommendations, analysis = analyze_sales_data(data1, data2)
+    
+    print("RECOMMENDED ACTIONS:")
+    print(recommendations.sort_values('Score', ascending=False).to_string(index=False))
+    
+    # Generate messages for mantris
+    mantri_messages = generate_mantri_messages(recommendations)
+    
+    print("\nMANTRI MESSAGES:")
+    for _, msg in mantri_messages.iterrows():
+        print(f"\nTo: {msg['Mantri']} ({msg['Mobile']}) - {msg['Village']}")
+        print(f"Action: {msg['Action']}")
+        print(f"Message: {msg['Message']}")
+    
+    # Identify demo locations
+    demo_locations = identify_demo_locations(analysis)
+    
+    print("\nTOP DEMO LOCATIONS:")
+    print(demo_locations.to_string(index=False))
+    
+    return recommendations, mantri_messages, demo_locations
+
+if __name__ == "__main__":
+    recommendations, mantri_messages, demo_locations = main()

OLD/__dbmlsystem.py

@@ -0,0 +1,596 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import KMeans
+import warnings
+warnings.filterwarnings('ignore')
+
+# Set page configuration
+st.set_page_config(
+    page_title="Calcium Supplement Sales Automation",
+    page_icon="🐄",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# App title
+st.title("🐄 Calcium Supplement Sales Automation Dashboard")
+st.markdown("---")
+
+# Your exact ML functions
+def enhanced_analyze_sales_data(data1, data2):
+    """
+    Enhanced analysis with ML components for better predictions
+    """
+    
+    data1['Date'] = pd.to_datetime(data1['Date'])
+    data2['Date'] = pd.to_datetime(data2['Date'])
+    
+    # Calculate basic metrics
+    data1['Conversion_Rate'] = (data1['Contact_In_Group'] / data1['Sabhasad'] * 100).round(2)
+    data1['Conversion_Rate'] = data1['Conversion_Rate'].replace([np.inf, -np.inf], 0).fillna(0)
+    data1['Untapped_Potential'] = data1['Sabhasad'] - data1['Contact_In_Group']
+    data1['Sales_Per_Contact'] = (data1['Total_L'] / data1['Contact_In_Group']).round(2)
+    data1['Sales_Per_Contact'] = data1['Sales_Per_Contact'].replace([np.inf, -np.inf], 0).fillna(0)
+    
+    # Analyze recent sales
+    recent_sales = data2.groupby('Village').agg({
+        'Total_L': ['sum', 'count'],
+        'Date': 'max'
+    }).reset_index()
+    
+    recent_sales.columns = ['Village', 'Recent_Sales_L', 'Recent_Customers', 'Last_Sale_Date']
+    recent_sales['Days_Since_Last_Sale'] = (datetime.now() - recent_sales['Last_Sale_Date']).dt.days
+    
+    # Merge data
+    analysis_df = data1.merge(recent_sales, on='Village', how='left')
+    analysis_df['Recent_Sales_L'] = analysis_df['Recent_Sales_L'].fillna(0)
+    analysis_df['Recent_Customers'] = analysis_df['Recent_Customers'].fillna(0)
+    analysis_df['Days_Since_Last_Sale'] = analysis_df['Days_Since_Last_Sale'].fillna(999)
+    
+    # ML Component 1: Village Clustering for Segmentation
+    analysis_df = apply_village_clustering(analysis_df)
+    
+    # ML Component 2: Predict Sales Potential
+    analysis_df = predict_sales_potential(analysis_df)
+    
+    # ML Component 3: Action Recommendation Classifier
+    analysis_df = predict_recommended_actions(analysis_df)
+    
+    # Generate recommendations based on ML predictions
+    recommendations = generate_ml_recommendations(analysis_df)
+    
+    return recommendations, analysis_df
+
+def apply_village_clustering(analysis_df):
+    """
+    Use K-Means clustering to segment villages into groups
+    """
+    # Prepare features for clustering
+    cluster_features = analysis_df[[
+        'Conversion_Rate', 'Untapped_Potential', 'Sales_Per_Contact', 
+        'Recent_Sales_L', 'Days_Since_Last_Sale'
+    ]].fillna(0)
+    
+    # Standardize features
+    scaler = StandardScaler()
+    scaled_features = scaler.fit_transform(cluster_features)
+    
+    # Apply K-Means clustering
+    kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
+    clusters = kmeans.fit_predict(scaled_features)
+    
+    # Add clusters to dataframe
+    analysis_df['Cluster'] = clusters
+    
+    # Name the clusters based on characteristics
+    cluster_names = {
+        0: 'High Potential - Low Engagement',
+        1: 'Steady Performers', 
+        2: 'Underperforming',
+        3: 'New/Developing'
+    }
+    
+    analysis_df['Segment'] = analysis_df['Cluster'].map(cluster_names)
+    
+    return analysis_df
+
+def predict_sales_potential(analysis_df):
+    """
+    Predict sales potential for each village using Random Forest
+    """
+    # Prepare features for prediction
+    prediction_features = analysis_df[[
+        'Sabhasad', 'Contact_In_Group', 'Conversion_Rate', 
+        'Untapped_Potential', 'Recent_Sales_L', 'Days_Since_Last_Sale'
+    ]].fillna(0)
+    
+    # Target variable: Total_L (current sales)
+    target = analysis_df['Total_L'].fillna(0)
+    
+    # Only train if we have enough data
+    if len(prediction_features) > 10:
+        # Split data
+        X_train, X_test, y_train, y_test = train_test_split(
+            prediction_features, target, test_size=0.2, random_state=42
+        )
+        
+        # Train model
+        model = RandomForestRegressor(n_estimators=100, random_state=42)
+        model.fit(X_train, y_train)
+        
+        # Make predictions
+        predictions = model.predict(prediction_features)
+        
+        # Calculate feature importance
+        feature_importance = pd.DataFrame({
+            'feature': prediction_features.columns,
+            'importance': model.feature_importances_
+        }).sort_values('importance', ascending=False)
+        
+        # Add predictions to dataframe
+        analysis_df['Predicted_Sales'] = predictions
+        analysis_df['Sales_Gap'] = analysis_df['Predicted_Sales'] - analysis_df['Total_L']
+    else:
+        # Fallback if not enough data
+        analysis_df['Predicted_Sales'] = analysis_df['Total_L']
+        analysis_df['Sales_Gap'] = 0
+    
+    return analysis_df
+
+def predict_recommended_actions(analysis_df):
+    """
+    Use ML to predict the best action for each village
+    """
+    # Define actions based on rules (for training data)
+    analysis_df['Action_Label'] = np.where(
+        analysis_df['Conversion_Rate'] < 20, 'Send Marketing Team',
+        np.where(
+            analysis_df['Untapped_Potential'] > 30, 'Call Mantri for Follow-up',
+            np.where(
+                analysis_df['Days_Since_Last_Sale'] > 30, 'Check on Mantri',
+                np.where(
+                    analysis_df['Sales_Per_Contact'] > 10, 'Provide More Stock',
+                    'Regular Follow-up'
+                )
+            )
+        )
+    )
+    
+    # Prepare features for classification
+    classification_features = analysis_df[[
+        'Conversion_Rate', 'Untapped_Potential', 'Sales_Per_Contact',
+        'Recent_Sales_L', 'Days_Since_Last_Sale', 'Sales_Gap'
+    ]].fillna(0)
+    
+    # Target variable: Action_Label
+    target = analysis_df['Action_Label']
+    
+    # Only train if we have enough data
+    if len(classification_features) > 10 and len(target.unique()) > 1:
+        # Split data
+        X_train, X_test, y_train, y_test = train_test_split(
+            classification_features, target, test_size=0.2, random_state=42, stratify=target
+        )
+        
+        # Train classifier
+        clf = RandomForestClassifier(n_estimators=100, random_state=42)
+        clf.fit(X_train, y_train)
+        
+        # Make predictions
+        predictions = clf.predict(classification_features)
+        prediction_proba = clf.predict_proba(classification_features)
+        
+        # Add predictions to dataframe
+        analysis_df['ML_Recommended_Action'] = predictions
+        analysis_df['Action_Confidence'] = np.max(prediction_proba, axis=1)
+    else:
+        # Fallback to rule-based if not enough data
+        analysis_df['ML_Recommended_Action'] = analysis_df['Action_Label']
+        analysis_df['Action_Confidence'] = 1.0
+    
+    return analysis_df
+
+def generate_ml_recommendations(analysis_df):
+    """
+    Generate recommendations based on ML predictions
+    """
+    recommendations = []
+    
+    for _, row in analysis_df.iterrows():
+        village = row['Village']
+        mantri = row['Mantri_Name']
+        mobile = row['Mantri_Mobile']
+        taluka = row['Taluka']
+        district = row['District']
+        segment = row['Segment']
+        action = row['ML_Recommended_Action']
+        confidence = row['Action_Confidence']
+        
+        # Generate reason based on ML prediction
+        if action == 'Send Marketing Team':
+            reason = f"ML predicts marketing team needed (Confidence: {confidence:.2f}). Segment: {segment}"
+            priority = 'High'
+        elif action == 'Call Mantri for Follow-up':
+            reason = f"ML predicts mantri follow-up needed (Confidence: {confidence:.2f}). Segment: {segment}"
+            priority = 'High'
+        elif action == 'Check on Mantri':
+            reason = f"ML suggests checking on mantri (Confidence: {confidence:.2f}). Segment: {segment}"
+            priority = 'Medium'
+        elif action == 'Provide More Stock':
+            reason = f"ML predicts stock increase needed (Confidence: {confidence:.2f}). Segment: {segment}"
+            priority = 'Medium'
+        else:
+            reason = f"ML recommends regular follow-up (Confidence: {confidence:.2f}). Segment: {segment}"
+            priority = 'Low'
+        
+        recommendations.append({
+            'Village': village,
+            'Taluka': taluka,
+            'District': district,
+            'Mantri': mantri,
+            'Mobile': mobile,
+            'Action': action,
+            'Reason': reason,
+            'Priority': priority,
+            'Confidence': confidence,
+            'Segment': segment,
+            'Sales_Gap': row.get('Sales_Gap', 0)
+        })
+    
+    return pd.DataFrame(recommendations)
+
+def generate_ml_mantri_messages(recommendations):
+    """
+    Generate personalized messages based on ML recommendations
+    """
+    messages = []
+    
+    for _, row in recommendations.iterrows():
+        if row['Action'] == 'Send Marketing Team':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Our AI system has identified that your village {row['Village']} has high potential for growth. 
+We're sending our marketing team to conduct demo sessions and help you reach more customers.
+
+Based on our analysis:
+- Segment: {row['Segment']}
+- Confidence: {row['Confidence']*100:.1f}%
+
+Please prepare for their visit and notify potential customers.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        elif row['Action'] == 'Call Mantri for Follow-up':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Our AI analysis shows significant untapped potential in {row['Village']}. 
+We recommend focusing on follow-up with these customers:
+
+- Segment: {row['Segment']}
+- Confidence: {row['Confidence']*100:.1f}%
+
+A special commission offer is available for your next 10 customers.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        elif row['Action'] == 'Check on Mantri':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Our system shows reduced activity in {row['Village']}. 
+Is everything alright? Do you need any support from our team?
+
+- Segment: {row['Segment']}
+- Confidence: {row['Confidence']*100:.1f}%
+
+Please let us know how we can help.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        elif row['Action'] == 'Provide More Stock':
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Great news! Our AI predicts increased demand in {row['Village']}. 
+Would you like us to send additional stock?
+
+- Segment: {row['Segment']}
+- Confidence: {row['Confidence']*100:.1f}%
+- Predicted Sales Gap: {row['Sales_Gap']:.1f}L
+
+Please confirm your additional requirements.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        else:
+            message = f"""
+Namaste {row['Mantri']} Ji!
+
+Our system shows steady performance in {row['Village']}. 
+Keep up the good work!
+
+- Segment: {row['Segment']}
+- Confidence: {row['Confidence']*100:.1f}%
+
+As always, let us know if you need any support.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+        
+        messages.append({
+            'Mantri': row['Mantri'],
+            'Mobile': row['Mobile'],
+            'Village': row['Village'],
+            'Action': row['Action'],
+            'Message': message,
+            'Priority': row['Priority'],
+            'Confidence': row['Confidence']
+        })
+    
+    return pd.DataFrame(messages)
+
+# Visualization functions
+def plot_village_performance(analysis_df):
+    """Create performance visualization for villages"""
+    fig = px.scatter(analysis_df, 
+                     x='Conversion_Rate', 
+                     y='Untapped_Potential',
+                     size='Total_L',
+                     color='Segment',
+                     hover_name='Village',
+                     title='Village Performance Analysis',
+                     labels={'Conversion_Rate': 'Conversion Rate (%)',
+                             'Untapped_Potential': 'Untapped Potential'})
+    
+    fig.update_layout(height=500)
+    return fig
+
+def plot_sales_trends(analysis_df):
+    """Create sales trends visualization"""
+    fig = px.bar(analysis_df, 
+                 x='Village', 
+                 y='Total_L',
+                 color='Segment',
+                 title='Total Sales by Village',
+                 labels={'Total_L': 'Total Sales (L)', 'Village': 'Village'})
+    
+    fig.update_layout(height=400, xaxis_tickangle=-45)
+    return fig
+
+def plot_priority_matrix(recommendations):
+    """Create priority matrix visualization"""
+    priority_order = {'High': 3, 'Medium': 2, 'Low': 1}
+    recommendations['Priority_Value'] = recommendations['Priority'].map(priority_order)
+    
+    fig = px.treemap(recommendations, 
+                     path=['Priority', 'Village'],
+                     values='Priority_Value',
+                     color='Priority_Value',
+                     color_continuous_scale='RdYlGn_r',
+                     title='Action Priority Matrix')
+    
+    fig.update_layout(height=500)
+    return fig
+
+def display_key_metrics(analysis_df):
+    """Display key performance metrics"""
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Total Villages", len(analysis_df))
+    with col2:
+        avg_conversion = analysis_df['Conversion_Rate'].mean()
+        st.metric("Avg Conversion Rate", f"{avg_conversion:.1f}%")
+    with col3:
+        total_untapped = analysis_df['Untapped_Potential'].sum()
+        st.metric("Total Untapped Potential", f"{total_untapped}")
+    with col4:
+        total_sales = analysis_df['Total_L'].sum()
+        st.metric("Total Sales (L)", f"{total_sales}")
+
+# Initialize session state
+if 'data1' not in st.session_state:
+    st.session_state.data1 = None
+if 'data2' not in st.session_state:
+    st.session_state.data2 = None
+if 'analysis_df' not in st.session_state:
+    st.session_state.analysis_df = None
+if 'recommendations' not in st.session_state:
+    st.session_state.recommendations = None
+if 'ml_messages' not in st.session_state:
+    st.session_state.ml_messages = None
+
+# Sidebar
+with st.sidebar:
+    st.header("Data Input")
+    
+    # File uploaders
+    st.subheader("Upload Village Data (Data1)")
+    uploaded_data1 = st.file_uploader("CSV or Excel file", type=["csv", "xlsx"], key="data1")
+    
+    st.subheader("Upload Sales Data (Data2)")
+    uploaded_data2 = st.file_uploader("CSV or Excel file", type=["csv", "xlsx"], key="data2")
+    
+    if st.button("Load Data and Run ML Analysis"):
+        if uploaded_data1 and uploaded_data2:
+            try:
+                # Load data
+                if uploaded_data1.name.endswith('.csv'):
+                    data1 = pd.read_csv(uploaded_data1)
+                else:
+                    data1 = pd.read_excel(uploaded_data1)
+                
+                if uploaded_data2.name.endswith('.csv'):
+                    data2 = pd.read_csv(uploaded_data2)
+                else:
+                    data2 = pd.read_excel(uploaded_data2)
+                
+                # Store in session state
+                st.session_state.data1 = data1
+                st.session_state.data2 = data2
+                
+                # Run ML analysis
+                with st.spinner("Running ML analysis..."):
+                    recommendations, analysis_df = enhanced_analyze_sales_data(data1, data2)
+                    st.session_state.analysis_df = analysis_df
+                    st.session_state.recommendations = recommendations
+                    
+                    ml_messages = generate_ml_mantri_messages(recommendations)
+                    st.session_state.ml_messages = ml_messages
+                
+                st.success("ML analysis completed successfully!")
+                
+            except Exception as e:
+                st.error(f"Error processing data: {str(e)}")
+        else:
+            st.error("Please upload both files to proceed")
+
+# Main content
+if st.session_state.analysis_df is not None and st.session_state.recommendations is not None:
+    # Display dashboard
+    tab1, tab2, tab3, tab4 = st.tabs(["Dashboard", "Village Analysis", "Actions & Messages", "Team Dispatch"])
+    
+    with tab1:
+        st.header("ML-Powered Performance Dashboard")
+        display_key_metrics(st.session_state.analysis_df)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.plotly_chart(plot_village_performance(st.session_state.analysis_df), use_container_width=True)
+        
+        with col2:
+            st.plotly_chart(plot_priority_matrix(st.session_state.recommendations), use_container_width=True)
+        
+        st.plotly_chart(plot_sales_trends(st.session_state.analysis_df), use_container_width=True)
+    
+    with tab2:
+        st.header("Village Analysis with ML Segmentation")
+        
+        selected_village = st.selectbox("Select Village", st.session_state.analysis_df['Village'].unique())
+        village_data = st.session_state.analysis_df[st.session_state.analysis_df['Village'] == selected_village].iloc[0]
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Village Details")
+            st.write(f"**Village:** {village_data['Village']}")
+            st.write(f"**Taluka:** {village_data['Taluka']}")
+            st.write(f"**District:** {village_data['District']}")
+            st.write(f"**Mantri:** {village_data['Mantri_Name']}")
+            st.write(f"**Mantri Mobile:** {village_data['Mantri_Mobile']}")
+            st.write(f"**Segment:** {village_data.get('Segment', 'N/A')}")
+            st.write(f"**ML Recommended Action:** {village_data.get('ML_Recommended_Action', 'N/A')}")
+            st.write(f"**Action Confidence:** {village_data.get('Action_Confidence', 'N/A'):.2f}")
+        
+        with col2:
+            st.subheader("Performance Metrics")
+            st.write(f"**Sabhasad:** {village_data['Sabhasad']}")
+            st.write(f"**Contacted:** {village_data['Contact_In_Group']}")
+            st.write(f"**Conversion Rate:** {village_data['Conversion_Rate']}%")
+            st.write(f"**Untapped Potential:** {village_data['Untapped_Potential']}")
+            st.write(f"**Total Sales:** {village_data['Total_L']}L")
+            st.write(f"**Sales per Contact:** {village_data['Sales_Per_Contact']}L")
+            st.write(f"**Predicted Sales:** {village_data.get('Predicted_Sales', 'N/A'):.1f}L")
+            st.write(f"**Sales Gap:** {village_data.get('Sales_Gap', 'N/A'):.1f}L")
+    
+    with tab3:
+        st.header("ML-Based Actions & Messages")
+        
+        st.subheader("ML-Generated Recommendations")
+        st.dataframe(st.session_state.recommendations)
+        
+        # Download recommendations
+        csv_data = st.session_state.recommendations.to_csv(index=False)
+        st.download_button(
+            label="Download Recommendations as CSV",
+            data=csv_data,
+            file_name="ml_sales_recommendations.csv",
+            mime="text/csv"
+        )
+        
+        st.subheader("Generate ML-Powered Messages")
+        selected_mantri = st.selectbox("Select Mantri", st.session_state.recommendations['Mantri'].unique())
+        mantri_data = st.session_state.recommendations[
+            st.session_state.recommendations['Mantri'] == selected_mantri].iloc[0]
+        
+        message_df = st.session_state.ml_messages[
+            st.session_state.ml_messages['Mantri'] == selected_mantri]
+        
+        if not message_df.empty:
+            message = message_df.iloc[0]['Message']
+            st.text_area("ML-Generated Message", message, height=300)
+            
+            if st.button("Send Message"):
+                st.success(f"Message sent to {mantri_data['Mantri']} at {mantri_data['Mobile']}")
+        
+        st.subheader("Bulk Message Sender")
+        if st.button("Generate All ML Messages"):
+            st.session_state.all_messages = st.session_state.ml_messages
+        
+        if 'all_messages' in st.session_state:
+            st.dataframe(st.session_state.all_messages[['Mantri', 'Village', 'Action', 'Priority', 'Confidence']])
+            
+            if st.button("Send All ML Messages"):
+                progress_bar = st.progress(0)
+                for i, row in st.session_state.all_messages.iterrows():
+                    # Simulate sending message
+                    progress_bar.progress((i + 1) / len(st.session_state.all_messages))
+                st.success("All ML-powered messages sent successfully!")
+    
+    with tab4:
+        st.header("Marketing Team Dispatch with ML Insights")
+        
+        st.subheader("Villages Needing Team Visit (ML Identified)")
+        high_priority = st.session_state.recommendations[
+            st.session_state.recommendations['Action'] == 'Send Marketing Team']
+        
+        if not high_priority.empty:
+            for _, row in high_priority.iterrows():
+                with st.expander(f"{row['Village']} - {row['Mantri']} (Confidence: {row['Confidence']:.2f})"):
+                    st.write(f"**Reason:** {row['Reason']}")
+                    st.write(f"**Segment:** {row['Segment']}")
+                    st.write(f"**Sales Gap:** {row['Sales_Gap']:.1f}L")
+                    
+                    dispatch_date = st.date_input("Dispatch Date", key=f"date_{row['Village']}")
+                    team_size = st.slider("Team Size", 1, 5, 2, key=f"size_{row['Village']}")
+                    
+                    if st.button("Schedule Dispatch", key=f"dispatch_{row['Village']}"):
+                        st.success(f"Team dispatch scheduled for {row['Village']} on {dispatch_date}")
+        else:
+            st.info("No villages currently require immediate team dispatch based on ML analysis.")
+        
+        st.subheader("ML Performance Insights")
+        st.write("Based on our machine learning analysis, here are key insights:")
+        
+        # Show segment distribution
+        segment_counts = st.session_state.analysis_df['Segment'].value_counts()
+        fig = px.pie(values=segment_counts.values, names=segment_counts.index, 
+                     title="Village Segment Distribution")
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Show confidence distribution
+        fig = px.histogram(st.session_state.recommendations, x='Confidence',
+                          title='Confidence Distribution of ML Recommendations')
+        st.plotly_chart(fig, use_container_width=True)
+
+else:
+    st.info("Please upload your data files using the sidebar and click 'Load Data and Run ML Analysis' to get started.")
+
+# Footer
+st.markdown("---")
+st.markdown("**ML-Powered Calcium Supplement Sales Automation System** | For internal use only")

OLD/sampleDashboard.py

@@ -0,0 +1,350 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import time
+
+# Set page configuration
+st.set_page_config(
+    page_title="Calcium Supplement Sales Dashboard",
+    page_icon="🐄",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Sample data (replace with your actual data loading)
+@st.cache_data
+def load_data():
+    # Sales data with customer information
+    sales_data = pd.DataFrame({
+        'Date': ['2025-06-01', '2025-06-01', '2025-06-10', '2025-06-11', '2025-06-12', 
+                '2025-07-30', '2025-07-30', '2025-07-31', '2025-07-31', '2025-07-31'],
+        'Customer': ['Gopalbhai', 'Ramprasad Khatik', 'Vikramsinh', 'Prahladbhai -Mantry', 'V S Stud Farm',
+                    'Hemendrabhai Parmar', 'Sundarbhai', 'Kamleshbhai Vasava -Mantry', 'Kiranbhai -Mantry', 'Kiritbhai'],
+        'Village': ['Shilly', 'Rajasthan', 'Mithapura', 'Bhalod Dairy', 'Waghodia',
+                   'Panchdevla', 'Siyali', 'Moran', 'Talodara', 'Sindhrot'],
+        'Total_L': [35.0, 400.0, 30.0, 7.0, 400.0, 50.0, 13.0, 1.0, 1.0, 30.0]
+    })
+    
+    # Mantri data with village information
+    mantri_data = pd.DataFrame({
+        'DATE': ['2024-03-08', '2025-06-03', '2025-02-23', '2025-05-28', '2025-05-02',
+                '2024-09-21', '2024-10-26', '2024-03-19', '2025-01-30', '2025-07-18'],
+        'VILLAGE': ['JILOD', 'MANJIPURA', 'GOTHADA', 'UNTKHARI', 'VEMAR',
+                   'KANODA', 'KOTAMBI', 'RASNOL', 'JITPURA', 'BHATPURA'],
+        'MANTRY_NAME': ['AJAYBHAI PATEL', 'AJAYBHAI PATEL', 'AJGAR KHAN', 'AMBALAL CHAUHAN', 'AMBALAL GOHIL',
+                       'VINUBHAI SOLANKI', 'VISHNUBHAI', 'VITHTHALBHAI', 'YOGESHBHAI', 'YUVRAJSINH'],
+        'MOBILE_NO': [7984136988, 9737910554, 9724831903, 9313860902, 9978081739,
+                     9998756469, 9909550170, 9924590017, 7990383811, 6353209447],
+        'sabhasad': [38, 21, 3, 0, 2, 0, 14, 1183, 8, 6],
+        'contact_in_group': [38.0, 16.0, 2.0, 0.0, 0.0, 0.0, 14.0, 268.0, 5.0, 4.0],
+        'TOTAL_L': [99.0, 120.0, 19.0, 87.0, 32.0, 60.0, 54.0, 82.0, 25.0, 11.0]
+    })
+    
+    # Convert dates to datetime
+    sales_data['Date'] = pd.to_datetime(sales_data['Date'])
+    mantri_data['DATE'] = pd.to_datetime(mantri_data['DATE'], errors='coerce')
+    
+    return sales_data, mantri_data
+
+# Analysis functions
+def analyze_mantri_performance(mantri_data, sales_data):
+    mantri_data = mantri_data.copy()
+    
+    # Calculate performance metrics
+    mantri_data['Conversion_Rate'] = (mantri_data['contact_in_group'] / mantri_data['sabhasad'] * 100).round(2)
+    mantri_data['Conversion_Rate'] = mantri_data['Conversion_Rate'].replace([np.inf, -np.inf], 0).fillna(0)
+    mantri_data['Untapped_Potential'] = mantri_data['sabhasad'] - mantri_data['contact_in_group']
+    mantri_data['Sales_Efficiency'] = (mantri_data['TOTAL_L'] / mantri_data['contact_in_group']).round(2)
+    mantri_data['Sales_Efficiency'] = mantri_data['Sales_Efficiency'].replace([np.inf, -np.inf], 0).fillna(0)
+    
+    # Priority score calculation
+    mantri_data['Priority_Score'] = (
+        (mantri_data['Untapped_Potential'] / mantri_data['Untapped_Potential'].max() * 50) +
+        ((100 - mantri_data['Conversion_Rate']) / 100 * 50)
+    ).round(2)
+    
+    # Add recent sales data
+    recent_sales = sales_data.groupby('Village').agg({
+        'Total_L': 'sum',
+        'Customer': 'count'
+    }).reset_index()
+    recent_sales.columns = ['VILLAGE', 'Recent_Sales', 'Recent_Customers']
+    
+    mantri_data = mantri_data.merge(recent_sales, on='VILLAGE', how='left')
+    mantri_data['Recent_Sales'] = mantri_data['Recent_Sales'].fillna(0)
+    mantri_data['Recent_Customers'] = mantri_data['Recent_Customers'].fillna(0)
+    
+    return mantri_data
+
+def analyze_village_performance(sales_data, mantri_data):
+    # Group sales by village
+    village_sales = sales_data.groupby('Village').agg({
+        'Total_L': 'sum',
+        'Customer': 'count',
+        'Date': 'max'
+    }).reset_index()
+    village_sales.columns = ['Village', 'Total_Sales', 'Customer_Count', 'Last_Sale_Date']
+    
+    # Calculate days since last sale
+    village_sales['Days_Since_Last_Sale'] = (datetime.now() - village_sales['Last_Sale_Date']).dt.days
+    
+    # Merge with mantri data
+    mantri_summary = mantri_data[['VILLAGE', 'MANTRY_NAME', 'MOBILE_NO', 'sabhasad', 'contact_in_group']]
+    mantri_summary.columns = ['Village', 'Mantri_Name', 'Mantri_Mobile', 'Sabhasad', 'Contacts']
+    
+    village_performance = village_sales.merge(mantri_summary, on='Village', how='left')
+    
+    # Calculate performance metrics
+    village_performance['Conversion_Rate'] = (village_performance['Contacts'] / village_performance['Sabhasad'] * 100).round(2)
+    village_performance['Conversion_Rate'] = village_performance['Conversion_Rate'].replace([np.inf, -np.inf], 0).fillna(0)
+    village_performance['Untapped_Potential'] = village_performance['Sabhasad'] - village_performance['Contacts']
+    
+    return village_performance
+
+# Message templates
+def get_mantri_message_template(mantri_name, village, reason, performance_data):
+    templates = {
+        'Low Conversion': f"""
+Namaste {mantri_name} Ji!
+
+Aapke kshetra {village} mein humare calcium supplement ki conversion rate kam hai ({performance_data['Conversion_Rate']}%). 
+Humari marketing team aapke yaha demo dene aayegi. 
+Kripya taiyaari rakhein aur sabhi dudh utpadakon ko soochit karein.
+
+Aapke paas abhi bhi {int(performance_data['Untapped_Potential'])} aise farmers hain jo product nahi use kar rahe hain.
+
+Dhanyavaad,
+Calcium Supplement Team
+""",
+        'High Potential': f"""
+Namaste {mantri_name} Ji!
+
+Aapke kshetra {village} mein {int(performance_data['Untapped_Potential'])} aise farmers hain jo abhi tak humare product se anabhijit hain. 
+Kripya unse sampark karein aur unhe product ke fayde batayein. 
+Aapke liye special commission offer hai agle 10 naye customers ke liye.
+
+Dhanyavaad,
+Calcium Supplement Team
+""",
+        'Good Performance': f"""
+Namaste {mantri_name} Ji!
+
+Aapke kshetra {village} mein humare product ki demand badh rahi hai. 
+Aapki conversion rate {performance_data['Conversion_Rate']}% hai jo bahut achchi hai.
+
+Kripya farmers ko yaad dilaein ki pregnancy ke 3-9 mahine aur delivery ke baad calcium supplement zaroori hai.
+
+Dhanyavaad,
+Calcium Supplement Team
+"""
+    }
+    
+    return templates.get(reason, "Custom message based on analysis")
+
+# Load data
+sales_data, mantri_data = load_data()
+mantri_performance = analyze_mantri_performance(mantri_data, sales_data)
+village_performance = analyze_village_performance(sales_data, mantri_data)
+
+# Streamlit app
+st.title("🐄 Calcium Supplement Sales Automation Dashboard")
+st.markdown("---")
+
+# Sidebar
+st.sidebar.header("Navigation")
+section = st.sidebar.radio("Go to", ["Dashboard", "Mantri Performance", "Village Analysis", "Message Center", "Team Dispatch"])
+
+# Dashboard
+if section == "Dashboard":
+    st.header("Sales Performance Overview")
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Total Villages Covered", len(mantri_performance))
+    with col2:
+        st.metric("Total Mantris", len(mantri_performance['MANTRY_NAME'].unique()))
+    with col3:
+        st.metric("Total Sales (Liters)", mantri_performance['TOTAL_L'].sum())
+    with col4:
+        avg_conversion = mantri_performance['Conversion_Rate'].mean()
+        st.metric("Avg Conversion Rate", f"{avg_conversion:.2f}%")
+    
+    st.subheader("Top Priority Mantris")
+    priority_mantris = mantri_performance.nlargest(5, 'Priority_Score')[['MANTRY_NAME', 'VILLAGE', 'Conversion_Rate', 'Untapped_Potential', 'Priority_Score']]
+    st.dataframe(priority_mantris)
+    
+    st.subheader("Sales Distribution by Village")
+    fig = px.bar(mantri_performance, x='VILLAGE', y='TOTAL_L', title='Total Sales by Village')
+    st.plotly_chart(fig, use_container_width=True)
+    
+    st.subheader("Conversion Rate vs Untapped Potential")
+    fig = px.scatter(mantri_performance, x='Conversion_Rate', y='Untapped_Potential', 
+                    size='TOTAL_L', color='VILLAGE', hover_name='MANTRY_NAME',
+                    title='Mantri Performance Analysis')
+    st.plotly_chart(fig, use_container_width=True)
+
+# Mantri Performance
+elif section == "Mantri Performance":
+    st.header("Mantri Performance Analysis")
+    
+    selected_mantri = st.selectbox("Select Mantri", mantri_performance['MANTRY_NAME'].unique())
+    mantri_data = mantri_performance[mantri_performance['MANTRY_NAME'] == selected_mantri].iloc[0]
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Mantri", mantri_data['MANTRY_NAME'])
+    with col2:
+        st.metric("Village", mantri_data['VILLAGE'])
+    with col3:
+        st.metric("Conversion Rate", f"{mantri_data['Conversion_Rate']}%")
+    with col4:
+        st.metric("Untapped Potential", int(mantri_data['Untapped_Potential']))
+    
+    st.subheader("Mantri Details")
+    st.dataframe(mantri_data)
+    
+    st.subheader("Action Recommendations")
+    if mantri_data['Conversion_Rate'] < 20:
+        st.error(f"**Send Marketing Team**: Conversion rate is low ({mantri_data['Conversion_Rate']}%). Need demos and awareness campaigns.")
+    if mantri_data['Untapped_Potential'] > 10:
+        st.warning(f"**Call Mantri**: {int(mantri_data['Untapped_Potential'])} farmers still not converted. Push Mantri to contact them.")
+    if mantri_data['Conversion_Rate'] > 50:
+        st.success(f"**Expand Success**: This mantri is performing well. Consider replicating their strategies.")
+
+# Village Analysis
+elif section == "Village Analysis":
+    st.header("Village Performance Analysis")
+    
+    selected_village = st.selectbox("Select Village", village_performance['Village'].unique())
+    village_data = village_performance[village_performance['Village'] == selected_village].iloc[0]
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Village", village_data['Village'])
+    with col2:
+        st.metric("Mantri", village_data['Mantri_Name'])
+    with col3:
+        st.metric("Total Sales (L)", village_data['Total_Sales'])
+    with col4:
+        st.metric("Days Since Last Sale", village_data['Days_Since_Last_Sale'])
+    
+    st.subheader("Village Details")
+    st.dataframe(village_data)
+    
+    st.subheader("Action Recommendations")
+    if village_data['Days_Since_Last_Sale'] > 30:
+        st.error(f"**Send Marketing Team**: No sales in {village_data['Days_Since_Last_Sale']} days. Need immediate attention.")
+    if village_data['Conversion_Rate'] < 25:
+        st.warning(f"**Low Conversion**: Only {village_data['Conversion_Rate']}% of potential customers are converted.")
+    if village_data['Total_Sales'] > 100:
+        st.success(f"**High Performer**: This village has high sales volume. Consider expanding product range.")
+
+# Message Center
+elif section == "Message Center":
+    st.header("Message Center")
+    
+    st.subheader("Mantri Communication")
+    selected_mantri = st.selectbox("Select Mantri", mantri_performance['MANTRY_NAME'].unique())
+    mantri_data = mantri_performance[mantri_performance['MANTRY_NAME'] == selected_mantri].iloc[0]
+    
+    st.write(f"**Village:** {mantri_data['VILLAGE']}")
+    st.write(f"**Conversion Rate:** {mantri_data['Conversion_Rate']}%")
+    st.write(f"**Untapped Potential:** {int(mantri_data['Untapped_Potential'])} farmers")
+    
+    if mantri_data['Conversion_Rate'] < 20:
+        reason = "Low Conversion"
+    elif mantri_data['Untapped_Potential'] > 10:
+        reason = "High Potential"
+    else:
+        reason = "Good Performance"
+        
+    message = get_mantri_message_template(
+        mantri_data['MANTRY_NAME'], 
+        mantri_data['VILLAGE'], 
+        reason,
+        mantri_data
+    )
+    
+    st.text_area("Generated Message", message, height=200)
+    
+    if st.button("Send to Mantri"):
+        st.success(f"Message sent to {mantri_data['MANTRY_NAME']} at {mantri_data['MOBILE_NO']}")
+        # Here you would integrate with WhatsApp API
+    
+    st.subheader("Bulk Message Sender")
+    st.write("Send messages to multiple mantris at once")
+    
+    options = st.multiselect("Select Mantris", mantri_performance['MANTRY_NAME'].unique())
+    message_template = st.text_area("Message Template", height=100)
+    
+    if st.button("Send to Selected Mantris"):
+        progress_bar = st.progress(0)
+        for i, mantri in enumerate(options):
+            # Simulate sending
+            time.sleep(0.5)
+            progress_bar.progress((i + 1) / len(options))
+        st.success(f"Messages sent to {len(options)} mantris")
+
+# Team Dispatch
+elif section == "Team Dispatch":
+    st.header("Marketing Team Dispatch Planner")
+    
+    st.subheader("Villages Needing Immediate Attention")
+    
+    # Find villages with no recent sales or low conversion
+    high_priority = village_performance[
+        (village_performance['Days_Since_Last_Sale'] > 30) | 
+        (village_performance['Conversion_Rate'] < 20)
+    ]
+    
+    if not high_priority.empty:
+        for _, village in high_priority.iterrows():
+            with st.expander(f"{village['Village']} (Last sale: {village['Days_Since_Last_Sale']} days ago)"):
+                st.write(f"**Mantri:** {village['Mantri_Name']} ({village['Mantri_Mobile']})")
+                st.write(f"**Conversion Rate:** {village['Conversion_Rate']}%")
+                st.write(f"**Recommended Action:** Conduct demo sessions and awareness campaign")
+                
+                if st.button(f"Dispatch Team to {village['Village']}", key=f"dispatch_{village['Village']}"):
+                    st.success(f"Team dispatched to {village['Village']}. Mantri {village['Mantri_Name']} has been notified.")
+    else:
+        st.info("No villages currently require immediate team dispatch.")
+    
+    st.subheader("Create New Dispatch Plan")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        selected_village = st.selectbox("Select Village for Dispatch", village_performance['Village'].unique())
+        village_data = village_performance[village_performance['Village'] == selected_village].iloc[0]
+        
+        st.write(f"**Mantri:** {village_data['Mantri_Name']}")
+        st.write(f"**Last Sale:** {village_data['Days_Since_Last_Sale']} days ago")
+        st.write(f"**Conversion Rate:** {village_data['Conversion_Rate']}%")
+    
+    with col2:
+        dispatch_date = st.date_input("Dispatch Date", datetime.now() + timedelta(days=1))
+        team_size = st.slider("Team Size", 1, 5, 2)
+        duration = st.selectbox("Duration", ["1 day", "2 days", "3 days", "1 week"])
+        
+        objectives = st.text_area("Objectives", "Conduct demo sessions, educate farmers about benefits, collect feedback")
+    
+    if st.button("Schedule Dispatch"):
+        st.success(f"Dispatch to {selected_village} scheduled for {dispatch_date}")
+        st.json({
+            "village": selected_village,
+            "mantri": village_data['Mantri_Name'],
+            "date": str(dispatch_date),
+            "team_size": team_size,
+            "duration": duration,
+            "objectives": objectives
+        })
+
+# Footer
+st.markdown("---")
+st.markdown("**Calcium Supplement Sales Automation System** | For internal use only")

pages/customers.py

@@ -0,0 +1,449 @@
+# pages/customers.py
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from datetime import datetime, timedelta
+
+def show_customers_page(db, whatsapp_manager=None):
+    """Show customer analytics, segmentation, and action planning page"""
+    st.title("👥 Customer Intelligence Center")
+    
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+    
+    # Tabs for different customer functions
+    tab1, tab2, tab3, tab4 = st.tabs(["📊 Dashboard", "🎯 Segmentation", "📞 Action Center", "🔍 Customer Directory"])
+    
+    with tab1:
+        show_customer_dashboard_tab(db)
+    
+    with tab2:
+        show_customer_segmentation_tab(db)
+    
+    with tab3:
+        show_action_center_tab(db, whatsapp_manager)
+    
+    with tab4:
+        show_customer_directory_tab(db)
+
+def show_customer_dashboard_tab(db):
+    """Show customer analytics dashboard"""
+    st.subheader("📊 Customer Analytics Dashboard")
+    
+    try:
+        # Get comprehensive customer data
+        customers_data = get_customer_analytics_data(db)
+        
+        if customers_data.empty:
+            st.info("No customer data available yet.")
+            return
+        
+        # Key Metrics
+        st.subheader("🎯 Key Metrics")
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_customers = len(customers_data)
+            st.metric("Total Customers", total_customers)
+        
+        with col2:
+            active_customers = len(customers_data[customers_data['total_purchases'] > 0])
+            st.metric("Active Customers", active_customers)
+        
+        with col3:
+            avg_purchase_value = customers_data[customers_data['total_spent'] > 0]['total_spent'].mean()
+            st.metric("Avg Purchase Value", f"₹{avg_purchase_value:,.0f}" if not pd.isna(avg_purchase_value) else "₹0")
+        
+        with col4:
+            repeat_customers = len(customers_data[customers_data['total_purchases'] > 1])
+            st.metric("Repeat Customers", repeat_customers)
+        
+        # Village-wise Analysis
+        st.subheader("🗺️ Geographic Distribution")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            village_stats = customers_data.groupby('village').agg({
+                'customer_id': 'count',
+                'total_spent': 'sum',
+                'total_purchases': 'sum'
+            }).reset_index()
+            village_stats.columns = ['Village', 'Customers', 'Total Revenue', 'Total Purchases']
+            village_stats = village_stats.sort_values('Customers', ascending=False)
+            
+            if not village_stats.empty:
+                fig = px.bar(village_stats.head(10), x='Village', y='Customers',
+                           title='Top 10 Villages by Customer Count',
+                           color='Customers')
+                st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            if not village_stats.empty:
+                fig = px.pie(village_stats.head(8), values='Customers', names='Village',
+                           title='Customer Distribution by Village')
+                st.plotly_chart(fig, use_container_width=True)
+        
+        # Purchase Behavior
+        st.subheader("💰 Purchase Behavior Analysis")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Customer lifetime value distribution
+            spending_brackets = customers_data[customers_data['total_spent'] > 0]['total_spent']
+            if not spending_brackets.empty:
+                fig = px.histogram(spending_brackets, nbins=10,
+                                 title='Customer Spending Distribution',
+                                 labels={'value': 'Total Spent (₹)', 'count': 'Number of Customers'})
+                st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            # Recency analysis
+            if 'last_purchase_date' in customers_data.columns:
+                recent_customers = customers_data[customers_data['last_purchase_date'].notna()]
+                if not recent_customers.empty:
+                    recent_customers['days_since_purchase'] = (datetime.now() - pd.to_datetime(recent_customers['last_purchase_date'])).dt.days
+                    fig = px.histogram(recent_customers, x='days_since_purchase', nbins=10,
+                                     title='Days Since Last Purchase',
+                                     labels={'days_since_purchase': 'Days', 'count': 'Customers'})
+                    st.plotly_chart(fig, use_container_width=True)
+    
+    except Exception as e:
+        st.error(f"Error loading customer analytics: {e}")
+
+def show_customer_segmentation_tab(db):
+    """Show customer segmentation and targeting"""
+    st.subheader("🎯 Customer Segmentation")
+    
+    try:
+        customers_data = get_customer_analytics_data(db)
+        
+        if customers_data.empty:
+            st.info("No customer data available for segmentation.")
+            return
+        
+        # Segmentation criteria
+        st.subheader("🔍 Define Segments")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            segment_by = st.selectbox("Segment By", 
+                                    ["Purchase Behavior", "Geographic", "Demographic", "Custom"])
+            
+            if segment_by == "Purchase Behavior":
+                min_purchases = st.slider("Minimum Purchases", 0, 20, 1)
+                min_spent = st.number_input("Minimum Amount Spent (₹)", 0, 100000, 1000)
+                
+                segment_customers = customers_data[
+                    (customers_data['total_purchases'] >= min_purchases) &
+                    (customers_data['total_spent'] >= min_spent)
+                ]
+            
+            elif segment_by == "Geographic":
+                selected_villages = st.multiselect("Select Villages", 
+                                                 customers_data['village'].unique())
+                if selected_villages:
+                    segment_customers = customers_data[customers_data['village'].isin(selected_villages)]
+                else:
+                    segment_customers = customers_data
+            
+            elif segment_by == "Demographic":
+                # Add demographic filters here
+                segment_customers = customers_data
+        
+        with col2:
+            st.write("**Segment Actions**")
+            segment_size = len(segment_customers)
+            st.metric("Segment Size", segment_size)
+            
+            if segment_size > 0:
+                avg_segment_value = segment_customers['total_spent'].mean()
+                st.metric("Avg Customer Value", f"₹{avg_segment_value:,.0f}")
+                
+                # Quick actions for segment
+                if st.button("📱 Send Bulk WhatsApp", key="segment_whatsapp"):
+                    st.info(f"Ready to send message to {segment_size} customers")
+                
+                if st.button("📍 Plan Field Visit", key="segment_visit"):
+                    villages = segment_customers['village'].value_counts().head(5)
+                    st.success(f"Top villages to visit: {', '.join(villages.index.tolist())}")
+        
+        # Show segment details
+        if not segment_customers.empty:
+            st.subheader("👥 Segment Details")
+            
+            # Segment characteristics
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                top_village = segment_customers['village'].mode()[0] if not segment_customers['village'].mode().empty else "N/A"
+                st.metric("Most Common Village", top_village)
+            
+            with col2:
+                avg_purchases = segment_customers['total_purchases'].mean()
+                st.metric("Avg Purchases/Customer", f"{avg_purchases:.1f}")
+            
+            with col3:
+                total_potential = segment_customers['total_spent'].sum()
+                st.metric("Segment Total Value", f"₹{total_potential:,.0f}")
+            
+            # Customer list in segment
+            st.dataframe(segment_customers[['name', 'village', 'mobile', 'total_purchases', 'total_spent']].head(20), 
+                        use_container_width=True)
+    
+    except Exception as e:
+        st.error(f"Error in customer segmentation: {e}")
+
+def show_action_center_tab(db, whatsapp_manager):
+    """Show action planning and communication center"""
+    st.subheader("📞 Customer Action Center")
+    
+    try:
+        customers_data = get_customer_analytics_data(db)
+        
+        if customers_data.empty:
+            st.info("No customer data available for actions.")
+            return
+        
+        # Action categories
+        action_type = st.selectbox("Action Type", 
+                                 ["Follow-up Calls", "Demo Follow-ups", "Payment Reminders", 
+                                  "New Product Announcements", "Customer Feedback"])
+        
+        if action_type == "Follow-up Calls":
+            show_followup_calls_section(db, customers_data)
+        
+        elif action_type == "Demo Follow-ups":
+            show_demo_followups_section(db, customers_data)
+        
+        elif action_type == "Payment Reminders":
+            show_payment_reminders_section(db, customers_data, whatsapp_manager)
+        
+        elif action_type == "New Product Announcements":
+            show_product_announcements_section(db, customers_data, whatsapp_manager)
+        
+        elif action_type == "Customer Feedback":
+            show_feedback_section(db, customers_data, whatsapp_manager)
+    
+    except Exception as e:
+        st.error(f"Error in action center: {e}")
+
+def show_followup_calls_section(db, customers_data):
+    """Show customers needing follow-up calls"""
+    st.write("### 📞 Customers Needing Follow-up")
+    
+    # Identify customers for follow-up
+    follow_up_criteria = st.multiselect("Follow-up Criteria",
+                                      ["No Purchase in 30 days", "High Value Customers", 
+                                       "Single Purchase Only", "Specific Villages"])
+    
+    target_customers = customers_data.copy()
+    
+    if "No Purchase in 30 days" in follow_up_criteria:
+        # This would require last_purchase_date in your data
+        st.info("Last purchase date tracking needed for this feature")
+    
+    if "High Value Customers" in follow_up_criteria:
+        high_value_threshold = st.number_input("High Value Threshold (₹)", 1000, 10000, 5000)
+        target_customers = target_customers[target_customers['total_spent'] >= high_value_threshold]
+    
+    if "Single Purchase Only" in follow_up_criteria:
+        target_customers = target_customers[target_customers['total_purchases'] == 1]
+    
+    if not target_customers.empty:
+        st.write(f"**{len(target_customers)} customers identified for follow-up**")
+        
+        # Village concentration
+        village_concentration = target_customers['village'].value_counts().head(5)
+        st.write("**Top villages for field visits:**")
+        for village, count in village_concentration.items():
+            st.write(f"- {village}: {count} customers")
+        
+        # Display customer list
+        st.dataframe(target_customers[['name', 'village', 'mobile', 'total_purchases', 'total_spent']], 
+                    use_container_width=True)
+
+def show_demo_followups_section(db, customers_data):
+    """Show demo conversion tracking"""
+    st.write("### 🎯 Demo Conversion Tracking")
+    
+    try:
+        # Get demo data
+        demo_data = db.get_dataframe('demos', '''
+        SELECT d.*, c.name as customer_name, c.village, c.mobile, p.product_name
+        FROM demos d
+        LEFT JOIN customers c ON d.customer_id = c.customer_id
+        LEFT JOIN products p ON d.product_id = p.product_id
+        ORDER BY d.demo_date DESC
+        ''')
+        
+        if not demo_data.empty:
+            # Demo conversion stats
+            total_demos = len(demo_data)
+            converted_demos = len(demo_data[demo_data['conversion_status'] == 'Converted'])
+            conversion_rate = (converted_demos / total_demos) * 100 if total_demos > 0 else 0
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total Demos", total_demos)
+            with col2:
+                st.metric("Converted", converted_demos)
+            with col3:
+                st.metric("Conversion Rate", f"{conversion_rate:.1f}%")
+            
+            # Pending follow-ups
+            pending_followups = demo_data[
+                (demo_data['conversion_status'] == 'Not Converted') &
+                (pd.to_datetime(demo_data['follow_up_date']) <= datetime.now())
+            ]
+            
+            if not pending_followups.empty:
+                st.warning(f"🚨 {len(pending_followups)} demos need immediate follow-up!")
+                st.dataframe(pending_followups[['customer_name', 'village', 'product_name', 'demo_date', 'follow_up_date']],
+                           use_container_width=True)
+            
+            # All demo records
+            st.write("**All Demo Records**")
+            st.dataframe(demo_data[['customer_name', 'village', 'product_name', 'demo_date', 'conversion_status']],
+                       use_container_width=True)
+        else:
+            st.info("No demo records found.")
+    
+    except Exception as e:
+        st.error(f"Error loading demo data: {e}")
+
+def show_payment_reminders_section(db, customers_data, whatsapp_manager):
+    """Show payment reminder system"""
+    st.write("### 💰 Payment Reminders")
+    
+    try:
+        # Get pending payments
+        pending_payments = db.get_pending_payments()
+        
+        if not pending_payments.empty:
+            total_pending = pending_payments['pending_amount'].sum()
+            st.metric("Total Pending Amount", f"₹{total_pending:,.2f}")
+            
+            # Group by customer
+            customer_pending = pending_payments.groupby('customer_name').agg({
+                'pending_amount': 'sum',
+                'invoice_no': 'count'
+            }).reset_index()
+            customer_pending.columns = ['Customer', 'Total Pending', 'Pending Invoices']
+            customer_pending = customer_pending.sort_values('Total Pending', ascending=False)
+            
+            st.dataframe(customer_pending, use_container_width=True)
+            
+            # Bulk WhatsApp reminders
+            st.write("**Bulk Payment Reminders**")
+            if st.button("📱 Send Payment Reminders to All", type="primary") and whatsapp_manager:
+                st.info("This would send payment reminders to all customers with pending payments")
+        else:
+            st.success("🎉 All payments are cleared! No pending payments.")
+    
+    except Exception as e:
+        st.error(f"Error loading payment data: {e}")
+
+def show_product_announcements_section(db, customers_data, whatsapp_manager):
+    """Show new product announcement system"""
+    st.write("### 🆕 New Product Announcements")
+    
+    # Target segments for new products
+    segment = st.selectbox("Target Segment", 
+                         ["All Customers", "High Value Customers", "Specific Village", "Previous Product Buyers"])
+    
+    message_template = st.text_area("Announcement Message", 
+                                  height=100,
+                                  value="Hello {name}! We have exciting new products available. Reply YES for details!")
+    
+    if st.button("📢 Send Announcement", type="primary") and whatsapp_manager:
+        st.success("Ready to send announcement to selected segment!")
+
+def show_feedback_section(db, customers_data, whatsapp_manager):
+    """Show customer feedback collection system"""
+    st.write("### 💬 Customer Feedback Collection")
+    
+    feedback_segment = st.selectbox("Request Feedback From",
+                                  ["Recent Customers", "High Value Customers", "Inactive Customers"])
+    
+    feedback_message = st.text_area("Feedback Request Message",
+                                  height=100,
+                                  value="Hello {name}! We value your feedback. How was your experience with us?")
+    
+    if st.button("📝 Request Feedback", type="primary") and whatsapp_manager:
+        st.info("Feedback requests ready to send!")
+
+def show_customer_directory_tab(db):
+    """Show comprehensive customer directory"""
+    st.subheader("🔍 Customer Directory")
+    
+    try:
+        customers_data = get_customer_analytics_data(db)
+        
+        if customers_data.empty:
+            st.info("No customers found in the database.")
+            return
+        
+        # Filters
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            village_filter = st.multiselect("Filter by Village", customers_data['village'].unique())
+        
+        with col2:
+            purchase_filter = st.selectbox("Filter by Purchase History", 
+                                         ["All", "Has Purchases", "No Purchases", "Multiple Purchases"])
+        
+        with col3:
+            search_term = st.text_input("Search by Name/Mobile")
+        
+        # Apply filters
+        filtered_customers = customers_data.copy()
+        
+        if village_filter:
+            filtered_customers = filtered_customers[filtered_customers['village'].isin(village_filter)]
+        
+        if purchase_filter == "Has Purchases":
+            filtered_customers = filtered_customers[filtered_customers['total_purchases'] > 0]
+        elif purchase_filter == "No Purchases":
+            filtered_customers = filtered_customers[filtered_customers['total_purchases'] == 0]
+        elif purchase_filter == "Multiple Purchases":
+            filtered_customers = filtered_customers[filtered_customers['total_purchases'] > 1]
+        
+        if search_term:
+            filtered_customers = filtered_customers[
+                filtered_customers['name'].str.contains(search_term, case=False, na=False) |
+                filtered_customers['mobile'].str.contains(search_term, na=False)
+            ]
+        
+        # Display results
+        st.write(f"**Found {len(filtered_customers)} customers**")
+        
+        display_columns = ['name', 'village', 'mobile', 'total_purchases', 'total_spent']
+        display_df = filtered_customers[display_columns]
+        display_df.columns = ['Name', 'Village', 'Mobile', 'Total Purchases', 'Total Spent (₹)']
+        display_df['Total Spent (₹)'] = display_df['Total Spent (₹)'].apply(lambda x: f"₹{x:,.0f}")
+        
+        st.dataframe(display_df, use_container_width=True)
+    
+    except Exception as e:
+        st.error(f"Error loading customer directory: {e}")
+
+def get_customer_analytics_data(db):
+    """Get comprehensive customer data with analytics"""
+    try:
+        customers = db.get_dataframe('customers', '''
+        SELECT c.*, 
+               COUNT(s.sale_id) as total_purchases,
+               COALESCE(SUM(s.total_amount), 0) as total_spent,
+               MAX(s.sale_date) as last_purchase_date
+        FROM customers c
+        LEFT JOIN sales s ON c.customer_id = s.customer_id
+        GROUP BY c.customer_id
+        ORDER BY total_spent DESC
+        ''')
+        return customers
+    except Exception as e:
+        st.error(f"Error loading customer analytics data: {e}")
+        return pd.DataFrame()

pages/dashboard.py

@@ -0,0 +1,12 @@
+import streamlit as st
+import streamlit.components.v1 as components
+
+def create_dashboard(db=None, analytics=None):
+    # DO NOT call st.set_page_config here
+    st.markdown("<h1 class='main-header'>📊 Power BI Dashboard</h1>", unsafe_allow_html=True)
+    components.iframe(
+        src="https://app.powerbi.com/view?r=eyJrIjoiM2VmZDQxNTUtMGEyYS00NDNiLWEyMDMtZWY5MGFkYTlmYjU2IiwidCI6ImFmYTM1MTRhLTFlNDItNDBjOS04ZjExLWIzODNlNmRhYTM3NiIsImMiOjN9",
+        width=1200,
+        height=800,
+        scrolling=True
+    )

pages/data_import.py

@@ -0,0 +1,104 @@
+# pages/data_import.py
+import streamlit as st
+import os
+import glob
+from datetime import datetime
+
+def show_data_import_page(db, data_processor):
+    """Show data import page"""
+    st.title("📤 Data Import & Processing")
+    
+    if not data_processor:
+        st.error("Data processor not available. Please check initialization.")
+        return
+    
+    data_dir = "data"
+    if os.path.exists(data_dir):
+        excel_files = glob.glob(os.path.join(data_dir, "*.xlsx")) + glob.glob(os.path.join(data_dir, "*.xls"))
+        
+        if excel_files:
+            st.subheader("📁 Existing Files in Data Folder")
+            
+            for file_path in excel_files:
+                file_name = os.path.basename(file_path)
+                file_size = os.path.getsize(file_path) / 1024
+                file_mtime = datetime.fromtimestamp(os.path.getmtime(file_path))
+                
+                col1, col2, col3 = st.columns([3, 2, 1])
+                with col1:
+                    st.write(f"**{file_name}**")
+                    st.write(f"Size: {file_size:.1f} KB | Modified: {file_mtime.strftime('%Y-%m-%d %H:%M')}")
+                with col2:
+                    if st.button(f"🔄 Process", key=f"process_{file_name}"):
+                        try:
+                            if data_processor.process_excel_file(file_path):
+                                st.success(f"✅ Processed: {file_name}")
+                                st.rerun()
+                            else:
+                                st.warning(f"⚠️ No data processed from: {file_name}")
+                        except Exception as e:
+                            st.error(f"❌ Error processing {file_name}: {str(e)}")
+                with col3:
+                    if st.button(f"🗑️ Delete", key=f"delete_{file_name}"):
+                        try:
+                            os.remove(file_path)
+                            st.success(f"✅ Deleted: {file_name}")
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"Error deleting file: {e}")
+            
+            if st.button("🔄 Process All Files", type="primary"):
+                success_count = 0
+                for file_path in excel_files:
+                    try:
+                        if data_processor.process_excel_file(file_path):
+                            success_count += 1
+                    except Exception as e:
+                        st.error(f"Error processing {os.path.basename(file_path)}: {str(e)}")
+                st.success(f"✅ Processed {success_count}/{len(excel_files)} files successfully!")
+                if success_count > 0:
+                    st.rerun()
+        else:
+            st.info("No Excel files found in the data folder.")
+    else:
+        os.makedirs(data_dir, exist_ok=True)
+        st.info("Data folder created. Upload Excel files to get started.")
+    
+    st.subheader("📤 Upload New Excel File")
+    uploaded_file = st.file_uploader("Choose Excel file", type=['xlsx', 'xls'])
+    
+    if uploaded_file:
+        file_path = os.path.join("data", uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        
+        st.success(f"✅ File saved: {uploaded_file.name}")
+        
+        if st.button(f"🔄 Process {uploaded_file.name}"):
+            try:
+                if data_processor.process_excel_file(file_path):
+                    st.success(f"✅ Processed: {uploaded_file.name}")
+                    
+                    # Show data preview
+                    st.subheader("📊 Imported Data Preview")
+                    try:
+                        customers = db.get_dataframe('customers')
+                        sales = db.get_dataframe('sales')
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.metric("Customers", len(customers))
+                            if not customers.empty:
+                                st.dataframe(customers.tail(3), use_container_width=True)
+                        with col2:
+                            st.metric("Sales", len(sales))
+                            if not sales.empty:
+                                st.dataframe(sales.tail(3), use_container_width=True)
+                    except Exception as e:
+                        st.error(f"Error loading preview data: {e}")
+                    
+                    st.rerun()
+                else:
+                    st.warning(f"⚠️ No data processed from: {uploaded_file.name}")
+            except Exception as e:
+                st.error(f"❌ Error processing {uploaded_file.name}: {str(e)}")

pages/demos.py

@@ -0,0 +1,824 @@
+# pages/demos.py
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from datetime import datetime, timedelta
+import time
+
+
+def show_demos_page(db, whatsapp_manager=None):
+    """Show demo management and tracking page"""
+    st.title("🎯 Demo Management Center")
+
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+
+    # Tabs for different demo functions
+    tab1, tab2, tab3, tab4 = st.tabs(
+        ["➕ Schedule Demo", "📋 Demo Calendar", "📊 Demo Analytics", "🔄 Follow-ups"]
+    )
+
+    with tab1:
+        show_schedule_demo_tab(db, whatsapp_manager)
+
+    with tab2:
+        show_demo_calendar_tab(db)
+
+    with tab3:
+        show_demo_analytics_tab(db)
+
+    with tab4:
+        show_follow_ups_tab(db, whatsapp_manager)
+
+
+def show_schedule_demo_tab(db, whatsapp_manager):
+    """Show form to schedule new demos"""
+    st.subheader("➕ Schedule New Demo")
+
+    # Show demo summary if we just created one
+    if "last_demo_id" in st.session_state and st.session_state.last_demo_id:
+        show_demo_summary(db, st.session_state.last_demo_id)
+        st.session_state.last_demo_id = None  # Clear after showing
+        st.divider()
+
+    with st.form("schedule_demo_form"):
+        st.markdown("### 👥 Demo Information")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            # Customer selection
+            customers = db.get_dataframe(
+                "customers", "SELECT customer_id, name, village FROM customers"
+            )
+            if not customers.empty:
+                customer_options = {
+                    f"{row['name']} ({row['village']})": row["customer_id"]
+                    for _, row in customers.iterrows()
+                }
+                selected_customer = st.selectbox(
+                    "Select Customer*", options=list(customer_options.keys())
+                )
+                customer_id = (
+                    customer_options[selected_customer] if selected_customer else None
+                )
+            else:
+                st.warning("No customers found. Please add customers first.")
+                customer_id = None
+
+            # Distributor selection
+            distributors = db.get_dataframe(
+                "distributors", "SELECT distributor_id, name, village FROM distributors"
+            )
+            if not distributors.empty:
+                distributor_options = {
+                    f"{row['name']} ({row['village']})": row["distributor_id"]
+                    for _, row in distributors.iterrows()
+                }
+                selected_distributor = st.selectbox(
+                    "Assign Distributor",
+                    options=[""] + list(distributor_options.keys()),
+                )
+                distributor_id = (
+                    distributor_options[selected_distributor]
+                    if selected_distributor
+                    else None
+                )
+            else:
+                distributor_id = None
+
+        with col2:
+            # Product selection
+            products = db.get_dataframe(
+                "products",
+                "SELECT product_id, product_name FROM products WHERE is_active = 1",
+            )
+            if not products.empty:
+                product_options = {
+                    row["product_name"]: row["product_id"]
+                    for _, row in products.iterrows()
+                }
+                selected_product = st.selectbox(
+                    "Product to Demo*", options=list(product_options.keys())
+                )
+                product_id = (
+                    product_options[selected_product] if selected_product else None
+                )
+            else:
+                st.warning("No products found. Please add products first.")
+                product_id = None
+
+            # Demo details
+            demo_date = st.date_input("Demo Date*", datetime.now().date())
+            demo_time = st.time_input("Demo Time", datetime.now().time())
+
+        st.markdown("### 📝 Demo Details")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            quantity_provided = st.number_input(
+                "Quantity Provided",
+                min_value=0,
+                value=1,
+                help="Number of units provided for demo",
+            )
+            demo_location = st.selectbox(
+                "Demo Location",
+                ["Customer Home", "Distributor Office", "Public Place", "Other"],
+            )
+
+        with col2:
+            follow_up_date = st.date_input(
+                "Follow-up Date", datetime.now().date() + timedelta(days=7)
+            )
+            conversion_status = st.selectbox(
+                "Initial Status", ["Scheduled", "Completed", "Cancelled"]
+            )
+
+        notes = st.text_area(
+            "Demo Notes",
+            placeholder="Any special instructions, customer requirements, or observations...",
+        )
+
+        # Submit button
+        submitted = st.form_submit_button(
+            "🎯 Schedule Demo",
+            type="primary",
+        )
+
+    # Handle form submission OUTSIDE the form to prevent resubmission
+    if submitted:
+        # Create unique submission ID to prevent duplicates
+        submission_id = f"{customer_id}_{product_id}_{demo_date}_{demo_time}_{int(time.time())}"
+        
+        # Initialize submission tracking if not exists
+        if "processed_submissions" not in st.session_state:
+            st.session_state.processed_submissions = set()
+        
+        # Check if this exact submission was already processed in this session
+        if submission_id in st.session_state.processed_submissions:
+            st.warning("⚠️ This demo was already submitted. Showing previously created demo.")
+            # Don't rerun, just show the existing demo
+        else:
+            # Validation
+            errors = []
+            if not customer_id:
+                errors.append("Customer selection is required")
+            if not product_id:
+                errors.append("Product selection is required")
+            if not demo_date:
+                errors.append("Demo date is required")
+
+            if errors:
+                for error in errors:
+                    st.error(f"❌ {error}")
+            else:
+                # Check if a similar demo already exists in database (within last 5 minutes)
+                try:
+                    recent_demos = db.get_dataframe(
+                        "demos",
+                        """
+                        SELECT demo_id FROM demos 
+                        WHERE customer_id = ? 
+                        AND product_id = ? 
+                        AND demo_date = ?
+                        AND created_date >= datetime('now', '-5 minutes')
+                        ORDER BY demo_id DESC LIMIT 1
+                        """,
+                        params=(customer_id, product_id, demo_date)
+                    )
+                    
+                    if not recent_demos.empty:
+                        existing_demo_id = recent_demos.iloc[0]['demo_id']
+                        st.warning(f"⚠️ A similar demo (ID: {existing_demo_id}) was already created recently. Showing that demo instead.")
+                        st.session_state.last_demo_id = existing_demo_id
+                        st.session_state.processed_submissions.add(submission_id)
+                        st.rerun()
+                        return
+                except Exception as check_error:
+                    st.warning(f"Could not check for existing demos: {check_error}")
+                
+                try:
+                    # Ensure demo_date is a single date object (not tuple)
+                    if isinstance(demo_date, tuple):
+                        demo_date = demo_date[0] if demo_date else datetime.now().date()
+                    
+                    # Ensure follow_up_date is a single date object
+                    if isinstance(follow_up_date, tuple):
+                        follow_up_date = follow_up_date[0] if follow_up_date else datetime.now().date() + timedelta(days=7)
+
+                    # Combine date and time for notification
+                    demo_datetime = datetime.combine(demo_date, demo_time)
+
+                    # Add demo to database
+                    demo_id = add_demo_to_database(
+                        db,
+                        {
+                            "customer_id": customer_id,
+                            "distributor_id": distributor_id,
+                            "product_id": product_id,
+                            "demo_date": demo_date,
+                            "demo_time": demo_time,
+                            "quantity_provided": quantity_provided,
+                            "follow_up_date": follow_up_date,
+                            "conversion_status": conversion_status,
+                            "notes": notes,
+                            "demo_location": demo_location,
+                        },
+                    )
+
+                    if demo_id and demo_id > 0:
+                        # Mark this submission as processed
+                        st.session_state.processed_submissions.add(submission_id)
+                        
+                        st.success(
+                            f"✅ Demo scheduled successfully! Demo ID: {demo_id}"
+                        )
+
+                        # Send notification if WhatsApp available
+                        if whatsapp_manager and customer_id:
+                            send_demo_notification(
+                                whatsapp_manager,
+                                db,
+                                customer_id,
+                                demo_datetime,
+                                product_id,
+                            )
+
+                        # Store demo_id in session state to show summary outside form
+                        st.session_state.last_demo_id = demo_id
+
+                        # Set flag for dashboard notification
+                        st.session_state.demo_created_notification = demo_id
+
+                        # Update refresh time to ensure dashboard shows latest demos
+                        st.session_state.demo_refresh_time = time.time()
+
+                        # Rerun to show summary
+                        st.rerun()
+
+                    else:
+                        st.error("❌ Failed to schedule demo. Please try again.")
+
+                except Exception as e:
+                    st.error(f"❌ Error scheduling demo: {e}")
+                    import traceback
+                    st.code(traceback.format_exc())
+
+
+def add_demo_to_database(db, demo_data):
+    """Add demo record to database"""
+    try:
+        # Insert the demo - execute_query returns [(lastrowid,)] for INSERT
+        result = db.execute_query(
+            """
+        INSERT INTO demos (customer_id, distributor_id, product_id, demo_date, demo_time,
+                          quantity_provided, follow_up_date, conversion_status, notes, demo_location)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+            (
+                demo_data["customer_id"],
+                demo_data["distributor_id"],
+                demo_data["product_id"],
+                demo_data["demo_date"],
+                demo_data["demo_time"].strftime("%H:%M:%S")
+                if demo_data.get("demo_time")
+                else None,
+                demo_data["quantity_provided"],
+                demo_data["follow_up_date"],
+                demo_data["conversion_status"],
+                demo_data["notes"],
+                demo_data["demo_location"],
+            ),
+            log_action=False,
+        )
+        
+        # The execute_query method returns [(lastrowid,)] for INSERT queries
+        demo_id = result[0][0] if result and len(result) > 0 and result[0][0] else None
+        
+        if demo_id:
+            return demo_id
+        else:
+            st.error("❌ Failed to get demo_id after insertion")
+            return -1
+
+    except Exception as e:
+        st.error(f"Database error: {e}")
+        import traceback
+        st.code(traceback.format_exc())
+        return -1
+
+
+def send_demo_notification(
+    whatsapp_manager, db, customer_id, demo_datetime, product_id
+):
+    """Send demo notification to customer"""
+    try:
+        # Get customer and product details
+        customer = db.get_dataframe(
+            "customers", f"SELECT * FROM customers WHERE customer_id = {customer_id}"
+        )
+        product = db.get_dataframe(
+            "products", f"SELECT * FROM products WHERE product_id = {product_id}"
+        )
+
+        if not customer.empty and not product.empty:
+            customer_data = customer.iloc[0]
+            product_data = product.iloc[0]
+
+            if customer_data.get("mobile"):
+                # Format time safely
+                time_str = demo_datetime.strftime("%I:%M %p")
+                
+                message = f"""Hello {customer_data["name"]}! 🎉
+
+We're excited to confirm your product demo!
+
+📅 Date: {demo_datetime.strftime("%d %b %Y")}
+⏰ Time: {time_str}
+📦 Product: {product_data["product_name"]}
+
+Our team will demonstrate the product features and answer any questions you may have.
+
+We look forward to meeting you!
+
+Best regards,
+Sales Team"""
+
+                success = whatsapp_manager.send_message(
+                    customer_data["mobile"], message
+                )
+                if success:
+                    st.success("📱 Demo notification sent to customer!")
+                else:
+                    st.warning("⚠️ Could not send demo notification")
+
+    except Exception as e:
+        st.warning(f"Could not send demo notification: {e}")
+
+
+def show_demo_summary(db, demo_id):
+    """Show summary of scheduled demo"""
+    try:
+        demo_data = db.get_dataframe(
+            "demos",
+            f"""
+        SELECT d.*, c.name as customer_name, c.village, p.product_name,
+               dist.name as distributor_name
+        FROM demos d
+        LEFT JOIN customers c ON d.customer_id = c.customer_id
+        LEFT JOIN products p ON d.product_id = p.product_id
+        LEFT JOIN distributors dist ON d.distributor_id = dist.distributor_id
+        WHERE d.demo_id = {demo_id}
+        """,
+        )
+
+        if not demo_data.empty:
+            demo = demo_data.iloc[0]
+
+            st.markdown("## 🎉 Demo Scheduled Successfully!")
+
+            col1, col2 = st.columns(2)
+
+            with col1:
+                st.subheader("👥 Demo Details")
+                st.write(f"**Demo ID:** {demo_id}")
+                st.write(f"**Customer:** {demo['customer_name']}")
+                st.write(f"**Village:** {demo['village']}")
+                st.write(f"**Product:** {demo['product_name']}")
+                if demo.get("distributor_name"):
+                    st.write(f"**Distributor:** {demo['distributor_name']}")
+
+            with col2:
+                st.subheader("📅 Schedule")
+                st.write(f"**Demo Date:** {demo['demo_date']}")
+                if demo.get("demo_time"):
+                    st.write(f"**Demo Time:** {demo['demo_time']}")
+                st.write(f"**Follow-up Date:** {demo['follow_up_date']}")
+                st.write(f"**Status:** {demo['conversion_status']}")
+
+            # Quick actions
+            st.markdown("### ⚡ Quick Actions")
+            col1, col2, col3, col4 = st.columns(4)
+
+            with col1:
+                if st.button("🏠 Go to Dashboard"):
+                    st.session_state.current_page = "dashboard"
+                    st.rerun()
+
+            with col2:
+                if st.button("📋 View All Demos"):
+                    st.session_state.current_tab = "📋 Demo Calendar"
+                    st.rerun()
+
+            with col3:
+                if st.button("➕ Schedule Another"):
+                    st.rerun()
+
+            with col4:
+                if st.button("📊 View Analytics"):
+                    st.session_state.current_tab = "📊 Demo Analytics"
+                    st.rerun()
+
+    except Exception as e:
+        st.error(f"Error displaying demo summary: {e}")
+
+
+def show_demo_calendar_tab(db):
+    """Show demo calendar and upcoming demos"""
+    st.subheader("📋 Demo Calendar & Schedule")
+
+    try:
+        # Date range filter
+        col1, col2 = st.columns(2)
+        with col1:
+            start_date = st.date_input("Start Date", datetime.now().date())
+        with col2:
+            end_date = st.date_input("End Date", datetime.now().date() + timedelta(days=30))
+
+        # Status filter
+        status_filter = st.multiselect(
+            "Filter by Status",
+            ["Scheduled", "Completed", "Cancelled", "Converted", "Not Converted"],
+            default=["Scheduled", "Completed"],
+        )
+
+        # Get demos data
+        demos_data = get_demos_data(db, start_date, end_date, status_filter)
+
+        if not demos_data.empty:
+            # Convert demo_date to datetime for comparison
+            demos_data["demo_date"] = pd.to_datetime(demos_data["demo_date"]).dt.date
+
+            st.write(f"**📅 Showing {len(demos_data)} demos**")
+
+            # Upcoming demos (next 7 days)
+            upcoming_demos = demos_data[
+                (demos_data["demo_date"] <= datetime.now().date() + timedelta(days=7))
+                & (demos_data["conversion_status"] == "Scheduled")
+            ]
+
+            if not upcoming_demos.empty:
+                st.subheader("🚀 Upcoming Demos (Next 7 Days)")
+                display_upcoming = upcoming_demos[
+                    [
+                        "demo_date",
+                        "customer_name",
+                        "village",
+                        "product_name",
+                        "distributor_name",
+                    ]
+                ].copy()
+                display_upcoming.columns = [
+                    "Date",
+                    "Customer",
+                    "Village",
+                    "Product",
+                    "Distributor",
+                ]
+                st.dataframe(display_upcoming, use_container_width=True)
+
+            # All demos in date range
+            st.subheader("📋 All Demos")
+            display_all = demos_data[
+                [
+                    "demo_date",
+                    "customer_name",
+                    "village",
+                    "product_name",
+                    "conversion_status",
+                    "distributor_name",
+                ]
+            ].copy()
+            display_all.columns = [
+                "Date",
+                "Customer",
+                "Village",
+                "Product",
+                "Status",
+                "Distributor",
+            ]
+            display_all = display_all.sort_values("Date", ascending=False)
+            st.dataframe(display_all, use_container_width=True)
+
+            # Demo statistics
+            st.subheader("📊 Demo Statistics")
+            col1, col2, col3, col4 = st.columns(4)
+
+            with col1:
+                total_demos = len(demos_data)
+                st.metric("Total Demos", total_demos)
+
+            with col2:
+                scheduled = len(
+                    demos_data[demos_data["conversion_status"] == "Scheduled"]
+                )
+                st.metric("Scheduled", scheduled)
+
+            with col3:
+                completed = len(
+                    demos_data[demos_data["conversion_status"] == "Completed"]
+                )
+                st.metric("Completed", completed)
+
+            with col4:
+                converted = len(
+                    demos_data[demos_data["conversion_status"] == "Converted"]
+                )
+                st.metric("Converted", converted)
+
+        else:
+            st.info("No demos found for the selected criteria.")
+
+    except Exception as e:
+        st.error(f"Error loading demo calendar: {e}")
+        import traceback
+        st.code(traceback.format_exc())
+
+
+def get_demos_data(db, start_date, end_date, status_filter):
+    """Get demos data with filters"""
+    try:
+        query = """
+        SELECT d.*, c.name as customer_name, c.village, c.mobile,
+               p.product_name, dist.name as distributor_name
+        FROM demos d
+        LEFT JOIN customers c ON d.customer_id = c.customer_id
+        LEFT JOIN products p ON d.product_id = p.product_id
+        LEFT JOIN distributors dist ON d.distributor_id = dist.distributor_id
+        WHERE d.demo_date BETWEEN ? AND ?
+        """
+
+        params = [start_date, end_date]
+
+        if status_filter:
+            placeholders = ",".join(["?" for _ in status_filter])
+            query += f" AND d.conversion_status IN ({placeholders})"
+            params.extend(status_filter)
+
+        query += " ORDER BY d.demo_date, d.demo_time"
+
+        return db.get_dataframe("demos", query, params=params)
+
+    except Exception as e:
+        st.error(f"Error getting demos data: {e}")
+        return pd.DataFrame()
+
+
+def show_demo_analytics_tab(db):
+    """Show demo analytics and conversion rates"""
+    st.subheader("📊 Demo Analytics")
+
+    try:
+        # Get demo conversion data
+        demos_data = db.get_dataframe(
+            "demos",
+            """
+        SELECT d.*, c.name as customer_name, c.village,
+               p.product_name, dist.name as distributor_name
+        FROM demos d
+        LEFT JOIN customers c ON d.customer_id = c.customer_id
+        LEFT JOIN products p ON d.product_id = p.product_id
+        LEFT JOIN distributors dist ON d.distributor_id = dist.distributor_id
+        ORDER BY d.demo_date DESC
+        """,
+        )
+
+        if not demos_data.empty:
+            # Convert demo_date to datetime for proper handling
+            demos_data["demo_date"] = pd.to_datetime(demos_data["demo_date"])
+
+            # Conversion statistics
+            st.subheader("🎯 Conversion Analytics")
+
+            col1, col2, col3, col4 = st.columns(4)
+
+            with col1:
+                total_demos = len(demos_data)
+                st.metric("Total Demos", total_demos)
+
+            with col2:
+                converted = len(
+                    demos_data[demos_data["conversion_status"] == "Converted"]
+                )
+                st.metric("Converted", converted)
+
+            with col3:
+                not_converted = len(
+                    demos_data[demos_data["conversion_status"] == "Not Converted"]
+                )
+                st.metric("Not Converted", not_converted)
+
+            with col4:
+                conversion_rate = (
+                    (converted / total_demos * 100) if total_demos > 0 else 0
+                )
+                st.metric("Conversion Rate", f"{conversion_rate:.1f}%")
+
+            # Product-wise conversion
+            st.subheader("📦 Product Performance")
+            if "product_name" in demos_data.columns:
+                product_stats = (
+                    demos_data.groupby("product_name")
+                    .agg(
+                        {
+                            "demo_id": "count",
+                            "conversion_status": lambda x: (x == "Converted").sum(),
+                        }
+                    )
+                    .reset_index()
+                )
+                product_stats.columns = ["Product", "Total Demos", "Converted"]
+                product_stats["Conversion Rate"] = (
+                    product_stats["Converted"] / product_stats["Total Demos"] * 100
+                ).round(1)
+                product_stats = product_stats.sort_values(
+                    "Total Demos", ascending=False
+                )
+
+                st.dataframe(product_stats, use_container_width=True)
+
+            # Monthly trend
+            st.subheader("📈 Monthly Demo Trend")
+            try:
+                demos_data["demo_date"] = pd.to_datetime(demos_data["demo_date"])
+                monthly_trend = demos_data.groupby(
+                    demos_data["demo_date"].dt.to_period("M")
+                ).size()
+                monthly_trend.index = monthly_trend.index.astype(str)
+
+                if not monthly_trend.empty:
+                    fig = px.line(
+                        x=monthly_trend.index,
+                        y=monthly_trend.values,
+                        title="Monthly Demo Trend",
+                        labels={"x": "Month", "y": "Number of Demos"},
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+            except:
+                st.info("Could not generate monthly trend chart")
+
+        else:
+            st.info("No demo data available for analytics.")
+
+    except Exception as e:
+        st.error(f"Error loading demo analytics: {e}")
+
+
+def show_follow_ups_tab(db, whatsapp_manager):
+    """Show demo follow-ups and conversion tracking"""
+    st.subheader("🔄 Demo Follow-ups")
+
+    try:
+        # Get demos needing follow-up
+        follow_up_data = db.get_dataframe(
+            "demos",
+            """
+        SELECT d.*, c.name as customer_name, c.mobile, c.village,
+               p.product_name, dist.name as distributor_name
+        FROM demos d
+        LEFT JOIN customers c ON d.customer_id = c.customer_id
+        LEFT JOIN products p ON d.product_id = p.product_id
+        LEFT JOIN distributors dist ON d.distributor_id = dist.distributor_id
+        WHERE d.follow_up_date <= date('now', '+7 days')
+        AND d.conversion_status IN ('Completed', 'Not Converted')
+        ORDER BY d.follow_up_date ASC
+        """,
+        )
+
+        if not follow_up_data.empty:
+            # Convert dates to datetime for comparison
+            follow_up_data["follow_up_date"] = pd.to_datetime(
+                follow_up_data["follow_up_date"]
+            ).dt.date
+
+            # Overdue follow-ups
+            overdue = follow_up_data[
+                follow_up_data["follow_up_date"] < datetime.now().date()
+            ]
+            if not overdue.empty:
+                st.warning(f"🚨 {len(overdue)} Overdue Follow-ups!")
+                display_overdue = overdue[
+                    [
+                        "follow_up_date",
+                        "customer_name",
+                        "village",
+                        "product_name",
+                        "conversion_status",
+                    ]
+                ].copy()
+                display_overdue.columns = [
+                    "Due Date",
+                    "Customer",
+                    "Village",
+                    "Product",
+                    "Status",
+                ]
+                st.dataframe(display_overdue, use_container_width=True)
+
+            # Upcoming follow-ups
+            upcoming = follow_up_data[
+                follow_up_data["follow_up_date"] >= datetime.now().date()
+            ]
+            if not upcoming.empty:
+                st.subheader("📅 Upcoming Follow-ups")
+                display_upcoming = upcoming[
+                    [
+                        "follow_up_date",
+                        "customer_name",
+                        "village",
+                        "product_name",
+                        "conversion_status",
+                    ]
+                ].copy()
+                display_upcoming.columns = [
+                    "Due Date",
+                    "Customer",
+                    "Village",
+                    "Product",
+                    "Status",
+                ]
+                st.dataframe(display_upcoming, use_container_width=True)
+
+            # Follow-up actions
+            st.subheader("🔄 Follow-up Actions")
+            selected_demo = st.selectbox(
+                "Select Demo for Follow-up",
+                options=[
+                    f"{row['customer_name']} - {row['product_name']} ({row['follow_up_date']})"
+                    for _, row in follow_up_data.iterrows()
+                ],
+            )
+
+            if selected_demo:
+                demo_index = [
+                    f"{row['customer_name']} - {row['product_name']} ({row['follow_up_date']})"
+                    for _, row in follow_up_data.iterrows()
+                ].index(selected_demo)
+                selected_demo_data = follow_up_data.iloc[demo_index]
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    new_status = st.selectbox(
+                        "Update Conversion Status",
+                        ["Converted", "Not Converted", "Follow-up Required", "Lost"],
+                    )
+
+                    if st.button("🔄 Update Status"):
+                        update_demo_status(
+                            db, selected_demo_data["demo_id"], new_status
+                        )
+                        st.success("✅ Status updated successfully!")
+                        st.rerun()
+
+                with col2:
+                    if whatsapp_manager and st.button("📱 Send Follow-up Message"):
+                        send_follow_up_message(whatsapp_manager, selected_demo_data)
+                        st.success("✅ Follow-up message sent!")
+
+        else:
+            st.success("🎉 No pending follow-ups! All demos are up to date.")
+
+    except Exception as e:
+        st.error(f"Error loading follow-ups: {e}")
+
+
+def update_demo_status(db, demo_id, new_status):
+    """Update demo conversion status"""
+    try:
+        db.execute_query(
+            """
+        UPDATE demos SET conversion_status = ?, updated_date = CURRENT_TIMESTAMP
+        WHERE demo_id = ?
+        """,
+            (new_status, demo_id),
+            log_action=False,
+        )
+    except Exception as e:
+        st.error(f"Error updating demo status: {e}")
+
+
+def send_follow_up_message(whatsapp_manager, demo_data):
+    """Send follow-up message for demo"""
+    try:
+        if demo_data.get("mobile"):
+            message = f"""Hello {demo_data["customer_name"]}! 👋
+
+Following up on your {demo_data["product_name"]} demo from {demo_data["demo_date"]}.
+
+We'd love to hear about your experience and answer any questions you may have.
+
+Would you be interested in placing an order or scheduling another demo?
+
+Best regards,
+Sales Team"""
+
+            success = whatsapp_manager.send_message(demo_data["mobile"], message)
+            return success
+        return False
+    except Exception as e:
+        st.error(f"Error sending follow-up message: {e}")
+        return False

pages/distributors.py

@@ -0,0 +1,971 @@
+# pages/distributors.py
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import numpy as np
+# pages/distributors.py
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import numpy as np
+
+def show_distributors_page(db, whatsapp_manager=None):
+    """Show intelligent distributors network optimization hub"""
+    st.title("🤝 Distributor Network Intelligence")
+    
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+    
+    # Tabs for different distributor functions
+    tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(["🏆 Performance Dashboard", "➕ Add New Distributor", 
+                                           "🗺️ Territory Analysis", "📈 Growth Opportunities", 
+                                           "👥 Team Management", "🔍 Distributor Directory"])
+    
+    with tab1:
+        show_performance_dashboard_tab(db)
+    
+    with tab2:
+        show_add_distributor_tab(db, whatsapp_manager)
+    
+    with tab3:
+        show_territory_analysis_tab(db)
+    
+    with tab4:
+        show_growth_opportunities_tab(db)
+    
+    with tab5:
+        show_team_management_tab(db, whatsapp_manager)
+    
+    with tab6:
+        show_distributor_directory_tab(db)
+
+def show_add_distributor_tab(db, whatsapp_manager):
+    """Show form to add new distributors with comprehensive data collection"""
+    st.subheader("➕ Add New Distributor")
+    
+    with st.form("add_distributor_form", clear_on_submit=True):
+        st.markdown("### 📋 Basic Information")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            distributor_name = st.text_input("Distributor Name*", placeholder="Enter distributor name")
+            village = st.text_input("Village*", placeholder="Enter village name")
+            taluka = st.text_input("Taluka*", placeholder="Enter taluka name")
+            district = st.text_input("District", placeholder="Enter district name")
+        
+        with col2:
+            mantri_name = st.text_input("Mantri Name*", placeholder="Enter mantri name")
+            mantri_mobile = st.text_input("Mantri Mobile*", placeholder="Enter 10-digit mobile number")
+            # Remove status for now since your function doesn't have it
+            # status = st.selectbox("Status", ["Active", "Inactive", "Prospective"], index=0)
+        
+        st.markdown("### 📊 Network Information")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            sabhasad_count = st.number_input("Current Sabhasad Count", min_value=0, value=0)
+            contact_in_group = st.number_input("Contacts in WhatsApp Group", min_value=0, value=0)
+        
+        with col2:
+            potential_sabhasad = st.number_input("Potential Sabhasad (6 months)", min_value=0, value=0)
+            market_coverage = st.slider("Market Coverage (%)", 0, 100, 50)
+        
+        # Quick duplicate check
+        if distributor_name and village and taluka:
+            if db.distributor_exists(distributor_name, village, taluka):
+                st.warning("⚠️ A distributor with this name already exists in this location!")
+        
+        # Submit button
+        submitted = st.form_submit_button("🚀 Add Distributor to Network", type="primary")
+        
+        if submitted:
+            # Validation
+            errors = []
+            if not distributor_name:
+                errors.append("Distributor name is required")
+            if not village:
+                errors.append("Village is required")
+            if not taluka:
+                errors.append("Taluka is required")
+            if not mantri_name:
+                errors.append("Mantri name is required")
+            if not mantri_mobile or len(mantri_mobile) < 10:
+                errors.append("Valid mobile number is required (10 digits)")
+            
+            if errors:
+                for error in errors:
+                    st.error(f"❌ {error}")
+            else:
+                try:
+                    # Add distributor to database - WITHOUT status parameter
+                    distributor_id = db.add_distributor(
+                        name=distributor_name,
+                        village=village,
+                        taluka=taluka,
+                        district=district,
+                        mantri_name=mantri_name,
+                        mantri_mobile=mantri_mobile,
+                        sabhasad_count=sabhasad_count,
+                        contact_in_group=contact_in_group
+                        # status=status  # Remove this line since your function doesn't have it
+                    )
+                    
+                    if distributor_id and distributor_id > 0:
+                        st.success(f"✅ Distributor '{distributor_name}' added successfully!")
+                        
+                        # Store additional metrics
+                        save_distributor_metrics(db, distributor_id, {
+                            'potential_sabhasad': potential_sabhasad,
+                            'market_coverage': market_coverage,
+                            'notes': "Added via distributor form"
+                        })
+                        
+                        # Show success summary
+                        show_distributor_summary(db, distributor_id)
+                        
+                        # Send welcome message
+                        if whatsapp_manager and mantri_mobile:
+                            send_welcome_message(whatsapp_manager, mantri_mobile, distributor_name)
+                    
+                    else:
+                        st.error("❌ Failed to add distributor. Please try again.")
+                        
+                except Exception as e:
+                    st.error(f"❌ Error adding distributor: {e}")
+
+def calculate_potential_score(sabhasad_count, contact_in_group, potential_sabhasad,
+                            market_coverage, leadership_quality, community_influence,
+                            business_experience, has_vehicle, digital_literacy):
+    """Calculate distributor potential score (0-100)"""
+    score = 0
+    
+    # Network factors (40%)
+    score += min(sabhasad_count * 2, 20)  # Max 20 points for current sabhasad
+    score += min(contact_in_group * 0.2, 10)  # Max 10 points for contacts
+    score += min(potential_sabhasad * 1.5, 10)  # Max 10 points for potential
+    
+    # Market factors (20%)
+    score += market_coverage * 0.2  # 20 points for coverage
+    
+    # Personal factors (25%)
+    leadership_scores = {"Low": 0, "Medium": 5, "High": 8, "Very High": 10}
+    score += leadership_scores.get(leadership_quality, 0)
+    
+    influence_scores = {"Low": 0, "Medium": 5, "High": 8, "Very High": 10}
+    score += influence_scores.get(community_influence, 0)
+    
+    experience_scores = {"None": 0, "1-2 years": 2, "3-5 years": 3, "5+ years": 5}
+    score += experience_scores.get(business_experience, 0)
+    
+    # Infrastructure factors (15%)
+    if has_vehicle:
+        score += 5
+    digital_scores = {"Basic": 2, "Intermediate": 4, "Advanced": 6}
+    score += digital_scores.get(digital_literacy, 0)
+    
+    return min(score, 100)
+
+def save_distributor_metrics(db, distributor_id, metrics):
+    """Save additional distributor metrics"""
+    try:
+        # Create metrics table if not exists
+        db.execute_query('''
+        CREATE TABLE IF NOT EXISTS distributor_metrics (
+            metric_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            distributor_id INTEGER,
+            potential_sabhasad INTEGER,
+            market_coverage INTEGER,
+            monthly_target REAL,
+            current_business_value REAL,
+            has_vehicle BOOLEAN,
+            vehicle_type TEXT,
+            storage_capacity TEXT,
+            whatsapp_active BOOLEAN,
+            digital_literacy TEXT,
+            uses_app BOOLEAN,
+            business_experience TEXT,
+            sales_background BOOLEAN,
+            leadership_quality TEXT,
+            community_influence TEXT,
+            known_in_village BOOLEAN,
+            reference_source TEXT,
+            potential_score REAL,
+            notes TEXT,
+            created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (distributor_id) REFERENCES distributors (distributor_id) ON DELETE CASCADE
+        )
+        ''', log_action=False)
+        
+        # Insert metrics
+        db.execute_query('''
+        INSERT INTO distributor_metrics (
+            distributor_id, potential_sabhasad, market_coverage, monthly_target,
+            current_business_value, has_vehicle, vehicle_type, storage_capacity,
+            whatsapp_active, digital_literacy, uses_app, business_experience,
+            sales_background, leadership_quality, community_influence, known_in_village,
+            reference_source, potential_score, notes
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            distributor_id, metrics['potential_sabhasad'], metrics['market_coverage'],
+            metrics['monthly_target'], metrics['current_business_value'],
+            metrics['has_vehicle'], metrics['vehicle_type'], metrics['storage_capacity'],
+            metrics['whatsapp_active'], metrics['digital_literacy'], metrics['uses_app'],
+            metrics['business_experience'], metrics['sales_background'],
+            metrics['leadership_quality'], metrics['community_influence'],
+            metrics['known_in_village'], metrics['reference_source'],
+            metrics['potential_score'], metrics['notes']
+        ), log_action=False)
+        
+    except Exception as e:
+        st.warning(f"Could not save additional metrics: {e}")
+
+def show_distributor_summary(name, village, taluka, mantri_name, sabhasad_count, 
+                           contact_in_group, potential_sabhasad, potential_score, monthly_target):
+    """Show summary of newly added distributor"""
+    st.markdown("## 🎉 Distributor Added Successfully!")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("👤 Basic Information")
+        st.write(f"**Name:** {name}")
+        st.write(f"**Village:** {village}")
+        st.write(f"**Taluka:** {taluka}")
+        st.write(f"**Mantri:** {mantri_name}")
+    
+    with col2:
+        st.subheader("📊 Network Metrics")
+        st.write(f"**Current Sabhasad:** {sabhasad_count}")
+        st.write(f"**WhatsApp Contacts:** {contact_in_group}")
+        st.write(f"**Potential Sabhasad:** {potential_sabhasad}")
+        st.write(f"**Monthly Target:** ₹{monthly_target:,.0f}")
+    
+    st.subheader("🎯 Potential Assessment")
+    
+    # Potential score visualization
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        # Create gauge chart for potential score
+        fig = go.Figure(go.Indicator(
+            mode = "gauge+number+delta",
+            value = potential_score,
+            domain = {'x': [0, 1], 'y': [0, 1]},
+            title = {'text': "Potential Score"},
+            delta = {'reference': 50},
+            gauge = {
+                'axis': {'range': [None, 100]},
+                'bar': {'color': "darkblue"},
+                'steps': [
+                    {'range': [0, 40], 'color': "lightgray"},
+                    {'range': [40, 70], 'color': "gray"},
+                    {'range': [70, 100], 'color': "lightblue"}
+                ],
+                'threshold': {
+                    'line': {'color': "red", 'width': 4},
+                    'thickness': 0.75,
+                    'value': 90
+                }
+            }
+        ))
+        
+        fig.update_layout(height=300)
+        st.plotly_chart(fig, use_container_width=True)
+    
+    # Action recommendations based on score
+    st.subheader("💡 Recommended Actions")
+    
+    if potential_score >= 80:
+        st.success("**🎯 High Potential Distributor**")
+        st.write("- Provide advanced training materials")
+        st.write("- Set ambitious growth targets")
+        st.write("- Consider for leadership role")
+        st.write("- Regular high-level engagement")
+    
+    elif potential_score >= 60:
+        st.info("**📈 Good Potential Distributor**")
+        st.write("- Standard training program")
+        st.write("- Moderate growth targets")
+        st.write("- Regular follow-ups")
+        st.write("- Support with marketing materials")
+    
+    elif potential_score >= 40:
+        st.warning("**🔄 Moderate Potential Distributor**")
+        st.write("- Basic training focus")
+        st.write("- Conservative targets")
+        st.write("- Close monitoring needed")
+        st.write("- Additional support required")
+    
+    else:
+        st.error("**⚠️ Needs Development**")
+        st.write("- Intensive training program")
+        st.write("- Small, achievable targets")
+        st.write("- Frequent check-ins")
+        st.write("- Consider mentorship")
+
+def send_welcome_message(whatsapp_manager, mobile, distributor_name):
+    """Send welcome message to new distributor"""
+    try:
+        message = f"""Welcome {distributor_name}! 🎉
+
+Thank you for joining our distributor network! 
+
+We're excited to have you on board and look forward to working together to grow your business.
+
+Our team will contact you shortly to discuss:
+• Training schedule
+• Product information  
+• Sales strategies
+• Support systems
+
+For any immediate queries, feel free to contact us.
+
+Best regards,
+Sales Team"""
+
+        success = whatsapp_manager.send_message(mobile, message)
+        if success:
+            st.success("📱 Welcome message sent to distributor!")
+        else:
+            st.warning("⚠️ Could not send welcome message")
+    
+    except Exception as e:
+        st.warning(f"Could not send welcome message: {e}")
+
+# Keep all your existing functions (show_performance_dashboard_tab, show_territory_analysis_tab, etc.)
+# ... [rest of your existing functions remain unchanged]
+
+def show_performance_dashboard_tab(db):
+    """Show distributor performance dashboard"""
+    st.subheader("🏆 Distributor Performance Dashboard")
+    
+    try:
+        distributors_data = get_distributor_analytics_data(db)
+        
+        if distributors_data.empty:
+            st.info("No distributor data available yet.")
+            return
+        
+    except:
+        pass
+def show_distributors_page(db, whatsapp_manager=None):
+    """Show intelligent distributors network optimization hub"""
+    st.title("🤝 Distributor Network Intelligence")
+    
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+    
+    # Tabs for different distributor functions
+    tab1, tab2, tab3, tab4, tab5 ,tab6= st.tabs(["🏆 Performance Dashboard", "🗺️ Territory Analysis", 
+                                           "📈 Growth Opportunities", "👥 Team Management", 
+                                           "🔍 Distributor Directory","➕Add new distributor"])
+    
+    with tab1:
+        show_performance_dashboard_tab(db)
+    
+    with tab2:
+        show_territory_analysis_tab(db)
+    
+    with tab3:
+        show_growth_opportunities_tab(db)
+    
+    with tab4:
+        show_team_management_tab(db, whatsapp_manager)
+    
+    with tab5:
+        show_distributor_directory_tab(db)
+    
+    with tab6:
+        show_add_distributor_tab(db)
+
+def show_performance_dashboard_tab(db):
+    """Show distributor performance dashboard"""
+    st.subheader("🏆 Distributor Performance Dashboard")
+    
+    try:
+        distributors_data = get_distributor_analytics_data(db)
+        
+        if distributors_data.empty:
+            st.info("No distributor data available yet.")
+            return
+        
+        # Key Performance Indicators
+        st.subheader("🎯 Key Performance Indicators")
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_distributors = len(distributors_data)
+            st.metric("Total Distributors", total_distributors)
+        
+        with col2:
+            active_distributors = len(distributors_data[distributors_data['total_customers'] > 0])
+            st.metric("Active Distributors", active_distributors)
+        
+        with col3:
+            avg_sabhasad_per_dist = distributors_data['sabhasad_count'].mean()
+            st.metric("Avg Sabhasad/Dist", f"{avg_sabhasad_per_dist:.1f}")
+        
+        with col4:
+            total_network_size = distributors_data['sabhasad_count'].sum() + total_distributors
+            st.metric("Total Network Size", total_network_size)
+        
+        # Performance Tiers
+        st.subheader("📊 Performance Tiers")
+        
+        # Define performance tiers based on sabhasad count
+        distributors_data['performance_tier'] = distributors_data['sabhasad_count'].apply(
+            lambda x: 'Platinum' if x >= 20 else 'Gold' if x >= 10 else 'Silver' if x >= 5 else 'Bronze'
+        )
+        
+        tier_stats = distributors_data['performance_tier'].value_counts()
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            fig = px.pie(values=tier_stats.values, names=tier_stats.index,
+                        title='Distributor Performance Tier Distribution',
+                        color=tier_stats.index,
+                        color_discrete_map={'Platinum': '#FFD700', 'Gold': '#C0C0C0', 
+                                          'Silver': '#CD7F32', 'Bronze': '#8C7853'})
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            # Top performers
+            top_performers = distributors_data.nlargest(5, 'sabhasad_count')[
+                ['name', 'village', 'sabhasad_count', 'contact_in_group']
+            ]
+            top_performers.columns = ['Distributor', 'Village', 'Sabhasad', 'Contacts']
+            
+            st.write("**🏅 Top 5 Performers**")
+            st.dataframe(top_performers, use_container_width=True)
+        
+        # Geographic Performance Heatmap
+        st.subheader("🗺️ Geographic Performance Distribution")
+        
+        village_performance = distributors_data.groupby('village').agg({
+            'distributor_id': 'count',
+            'sabhasad_count': 'sum',
+            'contact_in_group': 'sum'
+        }).reset_index()
+        village_performance.columns = ['Village', 'Distributors', 'Total Sabhasad', 'Total Contacts']
+        village_performance = village_performance.sort_values('Total Sabhasad', ascending=False)
+        
+        if not village_performance.empty:
+            fig = px.bar(village_performance.head(10), x='Village', y='Total Sabhasad',
+                       title='Top 10 Villages by Sabhasad Network Size',
+                       color='Total Sabhasad',
+                       labels={'Total Sabhasad': 'Sabhasad Count'})
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Performance Trends (if we had date data)
+        st.subheader("📈 Network Growth Potential")
+        
+        # Calculate network density score
+        distributors_data['network_score'] = (
+            distributors_data['sabhasad_count'] * 0.6 + 
+            distributors_data['contact_in_group'] * 0.4
+        )
+        
+        # Identify high-potential distributors
+        high_potential = distributors_data[
+            (distributors_data['sabhasad_count'] < 10) & 
+            (distributors_data['contact_in_group'] > 20)
+        ]
+        
+        if not high_potential.empty:
+            st.write(f"**💎 {len(high_potential)} High-Potential Distributors Identified**")
+            st.write("These distributors have good contact base but low sabhasad conversion")
+            st.dataframe(high_potential[['name', 'village', 'sabhasad_count', 'contact_in_group']], 
+                        use_container_width=True)
+    
+    except Exception as e:
+        st.error(f"Error loading performance dashboard: {e}")
+
+def show_territory_analysis_tab(db):
+    """Show territory coverage and gap analysis"""
+    st.subheader("🗺️ Territory Coverage Analysis")
+    
+    try:
+        distributors_data = get_distributor_analytics_data(db)
+        customers_data = get_customer_analytics_data(db)
+        
+        if distributors_data.empty or customers_data.empty:
+            st.info("Insufficient data for territory analysis.")
+            return
+        
+        # Territory Coverage Analysis
+        st.subheader("📍 Coverage Gap Analysis")
+        
+        # Get all villages with distributors vs all villages with customers
+        distributor_villages = set(distributors_data['village'].dropna().unique())
+        customer_villages = set(customers_data['village'].dropna().unique())
+        
+        # Coverage analysis
+        covered_villages = distributor_villages.intersection(customer_villages)
+        uncovered_villages = customer_villages - distributor_villages
+        distributor_only_villages = distributor_villages - customer_villages
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Covered Villages", len(covered_villages))
+        
+        with col2:
+            st.metric("Uncovered Villages", len(uncovered_villages))
+        
+        with col3:
+            st.metric("Distributor-Only Villages", len(distributor_only_villages))
+        
+        # Coverage visualization
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            coverage_data = {
+                'Category': ['Covered', 'Uncovered', 'Distributor Only'],
+                'Count': [len(covered_villages), len(uncovered_villages), len(distributor_only_villages)]
+            }
+            coverage_df = pd.DataFrame(coverage_data)
+            
+            fig = px.pie(coverage_df, values='Count', names='Category',
+                        title='Village Coverage Status',
+                        color='Category',
+                        color_discrete_map={'Covered': '#00FF00', 'Uncovered': '#FF0000', 
+                                          'Distributor Only': '#FFFF00'})
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            # Customer density in uncovered areas
+            if uncovered_villages:
+                uncovered_customers = customers_data[customers_data['village'].isin(uncovered_villages)]
+                village_customer_count = uncovered_customers['village'].value_counts().head(10)
+                
+                if not village_customer_count.empty:
+                    fig = px.bar(x=village_customer_count.index, y=village_customer_count.values,
+                               title='Top Uncovered Villages by Customer Count',
+                               labels={'x': 'Village', 'y': 'Customer Count'})
+                    st.plotly_chart(fig, use_container_width=True)
+        
+        # Strategic Expansion Recommendations
+        st.subheader("🎯 Strategic Expansion Recommendations")
+        
+        if uncovered_villages:
+            # Prioritize villages with most customers
+            expansion_priority = customers_data[customers_data['village'].isin(uncovered_villages)]
+            priority_villages = expansion_priority.groupby('village').agg({
+                'customer_id': 'count',
+                'total_spent': 'sum'
+            }).reset_index()
+            priority_villages = priority_villages.sort_values('customer_id', ascending=False)
+            
+            st.write("**🚀 High-Priority Expansion Targets**")
+            st.dataframe(priority_villages.head(10), use_container_width=True)
+            
+            # Expansion strategy
+            st.write("**📋 Recommended Expansion Strategy**")
+            
+            high_priority = priority_villages[priority_villages['customer_id'] >= 10]
+            medium_priority = priority_villages[(priority_villages['customer_id'] >= 5) & 
+                                              (priority_villages['customer_id'] < 10)]
+            
+            if not high_priority.empty:
+                st.success(f"**Immediate Action Needed:** {len(high_priority)} villages with 10+ customers need distributor coverage")
+            
+            if not medium_priority.empty:
+                st.warning(f"**Plan Expansion:** {len(medium_priority)} villages with 5-9 customers ready for coverage")
+        
+        # Territory Optimization
+        st.subheader("⚡ Territory Optimization")
+        
+        # Identify overcrowded territories
+        village_distributor_count = distributors_data['village'].value_counts()
+        overcrowded_villages = village_distributor_count[village_distributor_count > 2]
+        
+        if not overcrowded_villages.empty:
+            st.write("**🏙️ Overcrowded Territories**")
+            st.write("Consider redistributing some distributors from these villages:")
+            for village, count in overcrowded_villages.items():
+                st.write(f"- {village}: {count} distributors")
+    
+    except Exception as e:
+        st.error(f"Error in territory analysis: {e}")
+
+def show_growth_opportunities_tab(db):
+    """Show growth opportunities and network expansion"""
+    st.subheader("📈 Network Growth Opportunities")
+    
+    try:
+        distributors_data = get_distributor_analytics_data(db)
+        
+        if distributors_data.empty:
+            st.info("No distributor data available for growth analysis.")
+            return
+        
+        # Growth Levers Analysis
+        st.subheader("🎯 Growth Lever Analysis")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            # Sabhasad Conversion Opportunity
+            avg_conversion_rate = distributors_data['sabhasad_count'].sum() / distributors_data['contact_in_group'].sum() * 100
+            st.metric("Avg Contact to Sabhasad Rate", f"{avg_conversion_rate:.1f}%")
+        
+        with col2:
+            # Underperforming distributors
+            underperformers = len(distributors_data[distributors_data['sabhasad_count'] < 3])
+            st.metric("Distributors Needing Support", underperformers)
+        
+        with col3:
+            # Expansion potential
+            total_contacts = distributors_data['contact_in_group'].sum()
+            potential_sabhasad = total_contacts * 0.3  # Assuming 30% conversion potential
+            st.metric("Potential Sabhasad Growth", f"+{potential_sabhasad:.0f}")
+        
+        # Growth Initiatives
+        st.subheader("🚀 Growth Initiatives")
+        
+        initiative = st.selectbox("Select Growth Initiative",
+                                ["Sabhasad Conversion Drive", "New Distributor Recruitment", 
+                                 "Territory Expansion", "Performance Improvement Program"])
+        
+        if initiative == "Sabhasad Conversion Drive":
+            show_sabhasad_conversion_plan(db, distributors_data)
+        
+        elif initiative == "New Distributor Recruitment":
+            show_recruitment_plan(db, distributors_data)
+        
+        elif initiative == "Territory Expansion":
+            show_territory_expansion_plan(db)
+        
+        elif initiative == "Performance Improvement Program":
+            show_performance_improvement_plan(db, distributors_data)
+        
+        # Progress Tracking
+        st.subheader("📊 Initiative Progress Tracking")
+        
+        # Mock progress data - in real implementation, this would come from database
+        progress_data = {
+            'Initiative': ['Sabhasad Drive', 'Recruitment', 'Territory Expansion', 'Training'],
+            'Target': [50, 10, 5, 25],
+            'Achieved': [35, 7, 3, 20],
+            'Completion': [70, 70, 60, 80]
+        }
+        progress_df = pd.DataFrame(progress_data)
+        
+        fig = px.bar(progress_df, x='Initiative', y='Completion',
+                   title='Growth Initiative Progress',
+                   labels={'Completion': 'Completion %'},
+                   color='Completion')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    except Exception as e:
+        st.error(f"Error in growth opportunities analysis: {e}")
+
+def show_sabhasad_conversion_plan(db, distributors_data):
+    """Show sabhasad conversion growth plan"""
+    st.write("### 📈 Sabhasad Conversion Drive")
+    
+    # Identify best candidates for conversion
+    conversion_candidates = distributors_data[
+        (distributors_data['contact_in_group'] > distributors_data['sabhasad_count'] * 2) &
+        (distributors_data['contact_in_group'] >= 10)
+    ].sort_values('contact_in_group', ascending=False)
+    
+    if not conversion_candidates.empty:
+        st.write(f"**🎯 {len(conversion_candidates)} Distributors with High Conversion Potential**")
+        
+        for _, dist in conversion_candidates.head(5).iterrows():
+            conversion_potential = dist['contact_in_group'] - dist['sabhasad_count']
+            st.write(f"- **{dist['name']}** ({dist['village']}): {dist['sabhasad_count']} sabhasad, "
+                   f"{dist['contact_in_group']} contacts → **+{conversion_potential} potential**")
+        
+        # Action plan
+        st.write("**📋 Action Plan**")
+        st.write("1. Conduct conversion training sessions")
+        st.write("2. Provide conversion scripts and materials")
+        st.write("3. Set weekly conversion targets")
+        st.write("4. Implement incentive program for conversions")
+    else:
+        st.info("No high-potential conversion candidates identified.")
+
+def show_recruitment_plan(db, distributors_data):
+    """Show new distributor recruitment plan"""
+    st.write("### 👥 New Distributor Recruitment")
+    
+    # Analyze current distribution density
+    village_coverage = distributors_data['village'].value_counts()
+    low_coverage_villages = village_coverage[village_coverage == 1]
+    
+    if not low_coverage_villages.empty:
+        st.write("**📍 Villages Needing Additional Distributors**")
+        for village in low_coverage_villages.index[:5]:
+            st.write(f"- {village}")
+    
+    # Recruitment targets
+    st.write("**🎯 Recruitment Strategy**")
+    st.write("- Focus on high-customer-density uncovered villages")
+    st.write("- Target influential community members")
+    st.write("- Offer attractive onboarding incentives")
+    st.write("- Provide comprehensive training and support")
+
+def show_territory_expansion_plan(db):
+    """Show territory expansion strategy"""
+    st.write("### 🗺️ Territory Expansion Plan")
+    
+    # This would integrate with the territory analysis data
+    st.write("**🚀 Expansion Priority Areas**")
+    st.write("1. High customer density uncovered villages")
+    st.write("2. Adjacent territories to high-performing distributors")
+    st.write("3. Villages with existing brand awareness")
+    st.write("4. Areas with competitor weakness")
+
+def show_performance_improvement_plan(db, distributors_data):
+    """Show performance improvement program"""
+    st.write("### 📊 Performance Improvement Program")
+    
+    # Identify underperformers
+    underperformers = distributors_data[
+        (distributors_data['sabhasad_count'] < 5) &
+        (distributors_data['status'] == 'Active')
+    ]
+    
+    if not underperformers.empty:
+        st.write(f"**🔧 {len(underperformers)} Distributors Needing Performance Support**")
+        
+        for _, dist in underperformers.head(5).iterrows():
+            st.write(f"- **{dist['name']}** ({dist['village']}): {dist['sabhasad_count']} sabhasad")
+        
+        # Support plan
+        st.write("**🛠️ Support Initiatives**")
+        st.write("1. One-on-one coaching sessions")
+        st.write("2. Performance benchmarking")
+        st.write("3. Additional training resources")
+        st.write("4. Peer mentoring program")
+
+def show_team_management_tab(db, whatsapp_manager):
+    """Show team communication and management"""
+    st.subheader("👥 Team Management & Communication")
+    
+    try:
+        distributors_data = get_distributor_analytics_data(db)
+        
+        if distributors_data.empty:
+            st.info("No distributor data available for team management.")
+            return
+        
+        # Communication Center
+        st.subheader("📞 Communication Center")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            communication_type = st.selectbox("Communication Type",
+                                            ["Performance Update", "Training Announcement", 
+                                             "Incentive Program", "Urgent Meeting", "Custom Message"])
+        
+        with col2:
+            target_group = st.selectbox("Target Group",
+                                      ["All Distributors", "High Performers", "Underperformers",
+                                       "Specific Village", "Performance Tier"])
+        
+        # Message templates
+        message_templates = {
+            "Performance Update": "Hello {name}! Your current performance: {sabhasad_count} sabhasad. Keep up the great work! 🎯",
+            "Training Announcement": "Hello {name}! Training session this week. Learn new strategies to grow your network! 📚",
+            "Incentive Program": "Hello {name}! New incentive program launched. Earn more with higher conversions! 💰",
+            "Urgent Meeting": "Hello {name}! Urgent meeting tomorrow. Your attendance is important! ⏰",
+            "Custom Message": ""
+        }
+        
+        message = st.text_area("Message Content", 
+                             value=message_templates[communication_type],
+                             height=100)
+        
+        # Personalization options
+        st.write("**🎨 Personalization Options**")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            include_performance = st.checkbox("Include Performance Data", value=True)
+            include_village = st.checkbox("Include Village", value=True)
+        
+        with col2:
+            urgent_tag = st.checkbox("Mark as Urgent", value=False)
+            request_response = st.checkbox("Request Response", value=True)
+        
+        # Send communication
+        if st.button("📱 Send to Distributors", type="primary"):
+            # Filter target distributors
+            target_distributors = filter_distributors_by_criteria(distributors_data, target_group)
+            
+            if not target_distributors.empty:
+                st.success(f"✅ Ready to send message to {len(target_distributors)} distributors")
+                
+                # Show preview
+                sample_dist = target_distributors.iloc[0]
+                preview_message = personalize_message(message, sample_dist, include_performance, include_village)
+                st.write("**Preview:**", preview_message)
+            else:
+                st.warning("No distributors match the selected criteria")
+        
+        # Team Performance Alerts
+        st.subheader("🚨 Performance Alerts")
+        
+        # Low performers alert
+        low_performers = distributors_data[
+            (distributors_data['sabhasad_count'] < 3) &
+            (distributors_data['status'] == 'Active')
+        ]
+        
+        if not low_performers.empty:
+            st.warning(f"🚨 {len(low_performers)} distributors have less than 3 sabhasad")
+            if st.button("🔄 Schedule Support Calls"):
+                st.info("Support calls scheduled with underperforming distributors")
+        
+        # High performer recognition
+        high_performers = distributors_data[distributors_data['sabhasad_count'] >= 15]
+        if not high_performers.empty:
+            st.success(f"🏆 {len(high_performers)} elite performers with 15+ sabhasad")
+            if st.button("🎉 Send Recognition"):
+                st.info("Recognition messages sent to top performers")
+    
+    except Exception as e:
+        st.error(f"Error in team management: {e}")
+
+def show_distributor_directory_tab(db):
+    """Show comprehensive distributor directory"""
+    st.subheader("🔍 Distributor Directory")
+    
+    try:
+        distributors_data = get_distributor_analytics_data(db)
+        
+        if distributors_data.empty:
+            st.info("No distributors found in the database.")
+            return
+        
+        # Advanced filtering
+        st.subheader("🔍 Advanced Filters")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            village_filter = st.multiselect("Filter by Village", distributors_data['village'].unique())
+            performance_filter = st.selectbox("Performance Tier", 
+                                            ["All", "Platinum", "Gold", "Silver", "Bronze"])
+        
+        with col2:
+            sabhasad_min = st.number_input("Min Sabhasad", 0, 100, 0)
+            sabhasad_max = st.number_input("Max Sabhasad", 0, 100, 100)
+        
+        with col3:
+            status_filter = st.multiselect("Status", distributors_data['status'].unique(), 
+                                         default=['Active'])
+            search_term = st.text_input("Search by Name/Village")
+        
+        # Apply filters
+        filtered_data = distributors_data.copy()
+        
+        if village_filter:
+            filtered_data = filtered_data[filtered_data['village'].isin(village_filter)]
+        
+        if performance_filter != "All":
+            filtered_data = filtered_data[filtered_data['performance_tier'] == performance_filter]
+        
+        filtered_data = filtered_data[
+            (filtered_data['sabhasad_count'] >= sabhasad_min) &
+            (filtered_data['sabhasad_count'] <= sabhasad_max)
+        ]
+        
+        if status_filter:
+            filtered_data = filtered_data[filtered_data['status'].isin(status_filter)]
+        
+        if search_term:
+            filtered_data = filtered_data[
+                filtered_data['name'].str.contains(search_term, case=False, na=False) |
+                filtered_data['village'].str.contains(search_term, case=False, na=False)
+            ]
+        
+        # Display results
+        st.write(f"**Found {len(filtered_data)} distributors**")
+        
+        display_columns = ['name', 'village', 'taluka', 'mantri_name', 'sabhasad_count', 
+                         'contact_in_group', 'performance_tier', 'status']
+        display_df = filtered_data[display_columns]
+        display_df.columns = ['Name', 'Village', 'Taluka', 'Mantri', 'Sabhasad', 'Contacts', 'Tier', 'Status']
+        
+        st.dataframe(display_df, use_container_width=True)
+        
+        # Export options
+        if st.button("📥 Export Distributor Data"):
+            csv = filtered_data.to_csv(index=False)
+            st.download_button(
+                label="Download CSV",
+                data=csv,
+                file_name=f"distributors_export_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv"
+            )
+    
+    except Exception as e:
+        st.error(f"Error loading distributor directory: {e}")
+
+def get_distributor_analytics_data(db):
+    """Get comprehensive distributor data with analytics"""
+    try:
+        distributors = db.get_dataframe('distributors', '''
+        SELECT d.*,
+               COUNT(DISTINCT c.customer_id) as total_customers,
+               COALESCE(SUM(s.total_amount), 0) as territory_sales
+        FROM distributors d
+        LEFT JOIN customers c ON d.village = c.village AND d.taluka = c.taluka
+        LEFT JOIN sales s ON c.customer_id = s.customer_id
+        GROUP BY d.distributor_id
+        ORDER BY d.sabhasad_count DESC
+        ''')
+        return distributors
+    except Exception as e:
+        st.error(f"Error loading distributor analytics data: {e}")
+        return pd.DataFrame()
+
+def get_customer_analytics_data(db):
+    """Get customer data for territory analysis"""
+    try:
+        customers = db.get_dataframe('customers', "SELECT * FROM customers")
+        return customers
+    except Exception as e:
+        return pd.DataFrame()
+
+def filter_distributors_by_criteria(distributors_data, criteria):
+    """Filter distributors based on selection criteria"""
+    if criteria == "All Distributors":
+        return distributors_data
+    elif criteria == "High Performers":
+        return distributors_data[distributors_data['sabhasad_count'] >= 10]
+    elif criteria == "Underperformers":
+        return distributors_data[distributors_data['sabhasad_count'] < 5]
+    elif criteria == "Specific Village":
+        # This would need a village selection UI in real implementation
+        return distributors_data
+    elif criteria == "Performance Tier":
+        # This would need a tier selection UI
+        return distributors_data
+    return distributors_data
+
+def personalize_message(message, distributor, include_performance=True, include_village=True):
+    """Personalize message for distributor"""
+    personalized = message.replace('{name}', distributor['name'])
+    
+    if include_performance and '{sabhasad_count}' in message:
+        personalized = personalized.replace('{sabhasad_count}', str(distributor['sabhasad_count']))
+    
+    if include_village and '{village}' in message:
+        personalized = personalized.replace('{village}', distributor.get('village', ''))
+    
+    return personalized

pages/file_viewer.py

@@ -0,0 +1,382 @@
+# pages/file_viewer.py
+import streamlit as st
+import pandas as pd
+import os
+import glob
+import chardet
+from datetime import datetime
+import re
+
+try:
+    from deep_translator import GoogleTranslator
+    TRANSLATOR_AVAILABLE = True
+except ImportError:
+    TRANSLATOR_AVAILABLE = False
+
+def show_file_viewer_page(db=None, data_processor=None):
+    """Universal file viewer for any Excel/CSV file with advanced Gujarati to English conversion"""
+    st.title("🔍 Universal File Viewer")
+    st.markdown("View and analyze any Excel or CSV file, with advanced Gujarati to English conversion using AI translation")
+    
+    if not TRANSLATOR_AVAILABLE:
+        st.error("""
+        **Translation features require deep-translator**
+        Install with: `pip install deep-translator`
+        
+        Without this, only basic number conversion will work.
+        """)
+    
+    # File selection options
+    tab1, tab2 = st.tabs(["📁 Browse Data Folder", "📤 Upload New File"])
+    
+    with tab1:
+        show_data_folder_browser()
+    
+    with tab2:
+        show_file_uploader()
+
+def show_data_folder_browser():
+    """Browse and view files from the data folder"""
+    data_dir = "data"
+    
+    if not os.path.exists(data_dir):
+        os.makedirs(data_dir, exist_ok=True)
+        st.info("Data folder created. Upload files to get started.")
+        return
+    
+    # Get all supported files
+    excel_files = glob.glob(os.path.join(data_dir, "*.xlsx")) + glob.glob(os.path.join(data_dir, "*.xls"))
+    csv_files = glob.glob(os.path.join(data_dir, "*.csv"))
+    all_files = excel_files + csv_files
+    
+    if not all_files:
+        st.info("No Excel or CSV files found in the data folder.")
+        return
+    
+    # File selection
+    st.subheader("📂 Select File to View")
+    
+    file_options = {os.path.basename(f): f for f in all_files}
+    selected_file_name = st.selectbox("Choose a file", options=list(file_options.keys()))
+    
+    if selected_file_name:
+        file_path = file_options[selected_file_name]
+        display_file_content(file_path, selected_file_name)
+
+def show_file_uploader():
+    """Upload and view new files"""
+    st.subheader("📤 Upload New File")
+    
+    uploaded_file = st.file_uploader(
+        "Choose Excel or CSV file", 
+        type=['xlsx', 'xls', 'csv'],
+        help="Upload Excel (.xlsx, .xls) or CSV files for viewing"
+    )
+    
+    if uploaded_file:
+        # Save to data folder for processing
+        file_path = os.path.join("data", uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        
+        display_file_content(file_path, uploaded_file.name)
+
+def display_file_content(file_path, file_name):
+    """Display file content with conversion options"""
+    try:
+        # File info
+        file_size = os.path.getsize(file_path) / 1024
+        file_mtime = datetime.fromtimestamp(os.path.getmtime(file_path))
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("File", file_name)
+        with col2:
+            st.metric("Size", f"{file_size:.1f} KB")
+        with col3:
+            st.metric("Modified", file_mtime.strftime('%Y-%m-%d %H:%M'))
+        
+        # Conversion options
+        st.subheader("🔄 Conversion Options")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            convert_gujarati = st.checkbox("Convert Gujarati to English", value=True)
+        with col2:
+            use_ai_translation = st.checkbox("Use AI Translation", 
+                                           value=TRANSLATOR_AVAILABLE,
+                                           disabled=not TRANSLATOR_AVAILABLE)
+        
+        # Read file
+        if file_path.endswith('.csv'):
+            df = read_csv_file(file_path)
+        else:
+            df = read_excel_file(file_path)
+        
+        if df is None or df.empty:
+            st.warning("No data found in the file.")
+            return
+        
+        # Show original data
+        st.subheader("📝 Original Data")
+        display_dataframe_info(df, "Original")
+        
+        # Apply conversion if requested
+        if convert_gujarati:
+            with st.spinner("Converting Gujarati content..."):
+                df_converted = convert_gujarati_data_advanced(df, use_ai_translation)
+            
+            st.subheader("🔤 Converted Data (Gujarati → English)")
+            display_dataframe_info(df_converted, "Converted")
+            
+            # Show conversion summary
+            show_conversion_summary(df, df_converted)
+        
+        # Data analysis tools
+        st.subheader("🔧 Data Analysis Tools")
+        show_data_analysis_tools(df_converted if convert_gujarati else df)
+        
+    except Exception as e:
+        st.error(f"Error processing file: {str(e)}")
+
+def show_conversion_summary(original_df, converted_df):
+    """Show summary of Gujarati to English conversion"""
+    st.subheader("📊 Conversion Summary")
+    
+    changes_detected = False
+    conversion_examples = []
+    
+    # Check for changes
+    for i in range(min(3, len(original_df))):
+        for col in original_df.columns[:3]:
+            if i < len(original_df):
+                orig_val = str(original_df.iloc[i][col])
+                conv_val = str(converted_df.iloc[i][col])
+                if orig_val != conv_val and contains_gujarati(orig_val):
+                    changes_detected = True
+                    conversion_examples.append(f"`{orig_val}` → `{conv_val}`")
+                    break
+    
+    if changes_detected:
+        st.success("✅ Gujarati content was detected and converted to English")
+        if conversion_examples:
+            st.write("**Conversion Examples:**")
+            for example in conversion_examples:
+                st.write(example)
+    else:
+        st.info("ℹ️ No Gujarati content detected - data is already in English")
+
+# Helper functions for file reading and conversion
+def read_csv_file(file_path):
+    """Read CSV file with automatic encoding detection"""
+    try:
+        # Try reading with different encodings
+        for enc in ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']:
+            try:
+                return pd.read_csv(file_path, encoding=enc)
+            except:
+                continue
+        
+        # Last resort
+        return pd.read_csv(file_path, encoding='utf-8', errors='ignore')
+    except Exception as e:
+        st.error(f"Error reading CSV: {str(e)}")
+        return pd.DataFrame()
+
+def read_excel_file(file_path):
+    """Read Excel file with all sheets"""
+    try:
+        excel_file = pd.ExcelFile(file_path)
+        
+        if len(excel_file.sheet_names) == 1:
+            return pd.read_excel(file_path)
+        else:
+            sheet_name = st.selectbox(
+                "Select Sheet to View", 
+                options=excel_file.sheet_names,
+                key=f"sheet_select_{file_path}"
+            )
+            return pd.read_excel(file_path, sheet_name=sheet_name)
+    except Exception as e:
+        st.error(f"Error reading Excel file: {str(e)}")
+        return pd.DataFrame()
+
+def convert_gujarati_data_advanced(df, use_ai_translation=False):
+    """Convert Gujarati content to English using advanced methods"""
+    try:
+        df_converted = df.copy()
+        
+        # Convert column names
+        df_converted.columns = [convert_gujarati_text(col, use_ai_translation) for col in df_converted.columns]
+        
+        # Convert data in each column
+        for col in df_converted.columns:
+            df_converted[col] = df_converted[col].astype(str)
+            df_converted[col] = df_converted[col].apply(
+                lambda x: convert_gujarati_text(x, use_ai_translation)
+            )
+        
+        return df_converted
+    except Exception as e:
+        st.warning(f"Conversion issues: {str(e)}")
+        return df
+
+def convert_gujarati_text(text, use_ai_translation=False):
+    """Convert Gujarati text to English using multiple methods"""
+    if not isinstance(text, str) or not text.strip():
+        return text
+    
+    # Step 1: Always convert Gujarati numbers
+    text = gujarati_to_english_digits(text)
+    
+    # Step 2: Check if text contains Gujarati characters
+    if contains_gujarati(text):
+        if use_ai_translation and TRANSLATOR_AVAILABLE:
+            try:
+                return GoogleTranslator(source='gu', target='en').translate(text)
+            except Exception as e:
+                st.warning(f"Translation failed for '{text}': {str(e)}")
+                return apply_basic_gujarati_conversion(text)
+        else:
+            return apply_basic_gujarati_conversion(text)
+    else:
+        return text
+
+def gujarati_to_english_digits(text):
+    """Convert Gujarati numbers to English digits"""
+    gujarati_to_english_numbers = {
+        '૦': '0', '૧': '1', '૨': '2', '૩': '3', '૪': '4',
+        '૫': '5', '૬': '6', '૭': '7', '૮': '8', '૯': '9'
+    }
+    
+    converted_text = text
+    for guj, eng in gujarati_to_english_numbers.items():
+        converted_text = converted_text.replace(guj, eng)
+    
+    return converted_text
+
+def contains_gujarati(text):
+    """Check if text contains Gujarati characters"""
+    gujarati_pattern = re.compile(r'[\u0A80-\u0AFF]')
+    return bool(gujarati_pattern.search(text))
+
+def apply_basic_gujarati_conversion(text):
+    """Apply basic Gujarati to English conversion for common words"""
+    gujarati_to_english_words = {
+        'ગ્રાહક': 'Customer', 'નામ': 'Name', 'મોબાઈલ': 'Mobile', 'ફોન': 'Phone',
+        'ગામ': 'Village', 'તાલુકો': 'Taluka', 'જિલ્લો': 'District', 'શહેર': 'City',
+        'બીલ': 'Bill', 'ચલણ': 'Invoice', 'રકમ': 'Amount', 'પ્રમાણ': 'Quantity',
+        'ઉત્પાદન': 'Product', 'તારીખ': 'Date', 'ચુકવણી': 'Payment'
+    }
+    
+    converted_text = text
+    for guj, eng in gujarati_to_english_words.items():
+        converted_text = converted_text.replace(guj, eng)
+    
+    return converted_text
+
+def display_dataframe_info(df, title):
+    """Display dataframe with comprehensive information"""
+    st.write(f"**{title} Data Summary**")
+    
+    # Basic info
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Rows", len(df))
+    with col2:
+        st.metric("Columns", len(df.columns))
+    with col3:
+        non_empty = len(df.dropna(how='all'))
+        st.metric("Non-empty Rows", non_empty)
+    with col4:
+        empty_cells = df.isna().sum().sum()
+        st.metric("Empty Cells", empty_cells)
+    
+    # Column information
+    st.subheader("📋 Column Details")
+    col_info = []
+    for col in df.columns:
+        col_info.append({
+            'Column Name': col,
+            'Data Type': str(df[col].dtype),
+            'Non-Null Count': df[col].count(),
+            'Null Count': df[col].isna().sum(),
+            'Unique Values': df[col].nunique()
+        })
+    
+    col_info_df = pd.DataFrame(col_info)
+    st.dataframe(col_info_df, use_container_width=True)
+    
+    # Data preview
+    st.subheader("👀 Data Preview")
+    show_rows = st.slider("Number of rows to show", 5, 100, 10, key=f"rows_{title}")
+    st.dataframe(df.head(show_rows), use_container_width=True)
+
+def show_data_analysis_tools(df):
+    """Show basic data analysis tools"""
+    tab1, tab2, tab3 = st.tabs(["📈 Basic Stats", "🔍 Search & Filter", "💾 Export"])
+    
+    with tab1:
+        show_basic_stats(df)
+    
+    with tab2:
+        show_search_filter(df)
+    
+    with tab3:
+        show_export_options(df)
+
+def show_basic_stats(df):
+    """Show basic statistical analysis"""
+    st.write("**Numerical Columns Statistics**")
+    
+    numerical_cols = df.select_dtypes(include=['number']).columns
+    if len(numerical_cols) > 0:
+        st.dataframe(df[numerical_cols].describe(), use_container_width=True)
+    else:
+        st.info("No numerical columns found for statistical analysis")
+
+def show_search_filter(df):
+    """Show search and filter options"""
+    st.write("**Search in Data**")
+    
+    search_term = st.text_input("Search term")
+    if search_term:
+        # Search across all string columns
+        mask = pd.Series([False] * len(df))
+        for col in df.columns:
+            if df[col].dtype == 'object':
+                mask = mask | df[col].astype(str).str.contains(search_term, case=False, na=False)
+        
+        filtered_df = df[mask]
+        st.write(f"Found {len(filtered_df)} matching rows")
+        st.dataframe(filtered_df.head(20), use_container_width=True)
+
+def show_export_options(df):
+    """Show data export options"""
+    st.write("**Export Processed Data**")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        csv = df.to_csv(index=False)
+        st.download_button(
+            label="📥 Download as CSV",
+            data=csv,
+            file_name="converted_data.csv",
+            mime="text/csv"
+        )
+    
+    with col2:
+        # For Excel, we need to save to a file first
+        excel_file = "converted_data.xlsx"
+        df.to_excel(excel_file, index=False)
+        with open(excel_file, "rb") as f:
+            st.download_button(
+                label="📊 Download as Excel",
+                data=f,
+                file_name=excel_file,
+                mime="application/vnd.ms-excel"
+            )
+        # Clean up
+        if os.path.exists(excel_file):
+            os.remove(excel_file)

pages/payments.py

@@ -0,0 +1,524 @@
+# pages/payments.py
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from datetime import datetime, timedelta
+
+def show_payments_page(db, whatsapp_manager=None):
+    """Show payments management and tracking page"""
+    st.title("💳 Payments Management")
+    
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+    
+    # Tabs for different payment functions
+    tab1, tab2, tab3, tab4 = st.tabs(["💰 Record Payment", "📋 Payment History", "⏳ Pending Payments", "📊 Payment Analytics"])
+    
+    with tab1:
+        show_record_payment_tab(db, whatsapp_manager)
+    
+    with tab2:
+        show_payment_history_tab(db)
+    
+    with tab3:
+        show_pending_payments_tab(db, whatsapp_manager)
+    
+    with tab4:
+        show_payment_analytics_tab(db)
+
+def show_record_payment_tab(db, whatsapp_manager):
+    """Show form to record new payments"""
+    st.subheader("💰 Record New Payment")
+    
+    with st.form("record_payment_form"):
+        st.markdown("### 📄 Payment Information")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Get pending sales for selection
+            pending_sales = get_pending_sales(db)
+            if not pending_sales.empty:
+                sale_options = {f"{row['invoice_no']} - {row['customer_name']} (₹{row['pending_amount']:,.2f})": row['sale_id'] 
+                              for _, row in pending_sales.iterrows()}
+                selected_sale = st.selectbox("Select Sale*", options=list(sale_options.keys()))
+                sale_id = sale_options[selected_sale] if selected_sale else None
+                
+                # Show sale details
+                if sale_id:
+                    sale_details = pending_sales[pending_sales['sale_id'] == sale_id].iloc[0]
+                    st.info(f"**Sale Details:** {sale_details['customer_name']} - Pending: ₹{sale_details['pending_amount']:,.2f}")
+            else:
+                st.warning("No pending sales found. All sales are fully paid!")
+                sale_id = None
+        
+        with col2:
+            payment_date = st.date_input("Payment Date*", datetime.now())
+            payment_method = st.selectbox("Payment Method*", 
+                                        ["Cash", "G-Pay", "PhonePe", "Bank Transfer", "Cheque", "Other"])
+            payment_status = st.selectbox("Payment Status", ["Completed", "Pending", "Failed"])
+        
+        st.markdown("### 💵 Payment Amount")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if sale_id:
+                sale_data = pending_sales[pending_sales['sale_id'] == sale_id].iloc[0]
+                max_amount = sale_data['pending_amount']
+                payment_amount = st.number_input("Payment Amount*", min_value=0.0, max_value=float(max_amount), 
+                                               value=float(max_amount), step=100.0)
+                st.write(f"Pending Amount: ₹{max_amount:,.2f}")
+            else:
+                payment_amount = st.number_input("Payment Amount*", min_value=0.0, value=0.0, step=100.0)
+        
+        with col2:
+            reference_number = st.text_input("Reference Number", 
+                                           placeholder="UPI ID, Cheque No, Transaction ID, etc.")
+            rrn_number = st.text_input("RRN Number", placeholder="For bank transfers")
+        
+        notes = st.text_area("Payment Notes", placeholder="Any additional notes about this payment...")
+        
+        # Submit button
+        submitted = st.form_submit_button("💳 Record Payment", type="primary")
+        
+        if submitted:
+            # Validation
+            errors = []
+            if not sale_id:
+                errors.append("Sale selection is required")
+            if not payment_amount or payment_amount <= 0:
+                errors.append("Valid payment amount is required")
+            if not payment_date:
+                errors.append("Payment date is required")
+            if not payment_method:
+                errors.append("Payment method is required")
+            
+            if errors:
+                for error in errors:
+                    st.error(f"❌ {error}")
+            else:
+                try:
+                    # Record payment in database
+                    payment_id = add_payment_to_database(db, {
+                        'sale_id': sale_id,
+                        'payment_date': payment_date,
+                        'payment_method': payment_method,
+                        'amount': payment_amount,
+                        'rrn': rrn_number,
+                        'reference': reference_number,
+                        'status': payment_status,
+                        'notes': notes
+                    })
+                    
+                    if payment_id and payment_id > 0:
+                        st.success(f"✅ Payment recorded successfully! Payment ID: {payment_id}")
+                        
+                        # Update sale payment status
+                        update_sale_payment_status(db, sale_id)
+                        
+                        # Send notification if WhatsApp available
+                        if whatsapp_manager and sale_id:
+                            send_payment_notification(whatsapp_manager, db, sale_id, payment_amount)
+                        
+                        # Show payment summary
+                        show_payment_summary(db, payment_id)
+                    
+                    else:
+                        st.error("❌ Failed to record payment. Please try again.")
+                        
+                except Exception as e:
+                    st.error(f"❌ Error recording payment: {e}")
+
+def get_pending_sales(db):
+    """Get sales with pending payments"""
+    try:
+        return db.get_dataframe('sales', '''
+        SELECT s.sale_id, s.invoice_no, s.total_amount, s.payment_status,
+               c.name as customer_name, c.mobile, c.village,
+               (s.total_amount - COALESCE(SUM(p.amount), 0)) as pending_amount
+        FROM sales s
+        LEFT JOIN customers c ON s.customer_id = c.customer_id
+        LEFT JOIN payments p ON s.sale_id = p.sale_id
+        WHERE s.payment_status IN ('Pending', 'Partial')
+        GROUP BY s.sale_id
+        HAVING pending_amount > 0
+        ORDER BY s.sale_date DESC
+        ''')
+    except Exception as e:
+        st.error(f"Error getting pending sales: {e}")
+        return pd.DataFrame()
+
+def add_payment_to_database(db, payment_data):
+    """Add payment record to database"""
+    try:
+        db.execute_query('''
+        INSERT INTO payments (sale_id, payment_date, payment_method, amount, rrn, reference, status, notes)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            payment_data['sale_id'],
+            payment_data['payment_date'],
+            payment_data['payment_method'],
+            payment_data['amount'],
+            payment_data['rrn'],
+            payment_data['reference'],
+            payment_data['status'],
+            payment_data['notes']
+        ), log_action=False)
+        
+        # Get the inserted payment_id
+        result = db.execute_query('SELECT last_insert_rowid()', log_action=False)
+        return result[0][0] if result else -1
+        
+    except Exception as e:
+        st.error(f"Database error: {e}")
+        return -1
+
+def update_sale_payment_status(db, sale_id):
+    """Update sale payment status based on payments"""
+    try:
+        # Get total paid amount
+        payments_data = db.get_dataframe('payments', f'''
+        SELECT COALESCE(SUM(amount), 0) as total_paid
+        FROM payments 
+        WHERE sale_id = {sale_id} AND status = 'Completed'
+        ''')
+        
+        if not payments_data.empty:
+            total_paid = payments_data.iloc[0]['total_paid']
+            
+            # Get sale total
+            sale_data = db.get_dataframe('sales', f'SELECT total_amount FROM sales WHERE sale_id = {sale_id}')
+            if not sale_data.empty:
+                sale_total = sale_data.iloc[0]['total_amount']
+                
+                # Determine payment status
+                if total_paid >= sale_total:
+                    new_status = 'Paid'
+                elif total_paid > 0:
+                    new_status = 'Partial'
+                else:
+                    new_status = 'Pending'
+                
+                # Update sale status
+                db.execute_query('''
+                UPDATE sales SET payment_status = ?, updated_date = CURRENT_TIMESTAMP
+                WHERE sale_id = ?
+                ''', (new_status, sale_id), log_action=False)
+                
+    except Exception as e:
+        st.error(f"Error updating payment status: {e}")
+
+def send_payment_notification(whatsapp_manager, db, sale_id, payment_amount):
+    """Send payment confirmation to customer"""
+    try:
+        # Get sale and customer details
+        sale_data = db.get_dataframe('sales', f'''
+        SELECT s.*, c.name as customer_name, c.mobile
+        FROM sales s
+        LEFT JOIN customers c ON s.customer_id = c.customer_id
+        WHERE s.sale_id = {sale_id}
+        ''')
+        
+        if not sale_data.empty:
+            sale = sale_data.iloc[0]
+            
+            if sale.get('mobile'):
+                message = f"""Hello {sale['customer_name']}! 💰
+
+We have received your payment of ₹{payment_amount:,.2f} for invoice {sale['invoice_no']}.
+
+Thank you for your prompt payment!
+
+If you have any questions, please feel free to contact us.
+
+Best regards,
+Sales Team"""
+                
+                success = whatsapp_manager.send_message(sale['mobile'], message)
+                if success:
+                    st.success("📱 Payment confirmation sent to customer!")
+                else:
+                    st.warning("⚠️ Could not send payment confirmation")
+    
+    except Exception as e:
+        st.warning(f"Could not send payment notification: {e}")
+
+def show_payment_summary(db, payment_id):
+    """Show summary of recorded payment"""
+    try:
+        payment_data = db.get_dataframe('payments', f'''
+        SELECT p.*, s.invoice_no, s.total_amount, c.name as customer_name, c.village
+        FROM payments p
+        LEFT JOIN sales s ON p.sale_id = s.sale_id
+        LEFT JOIN customers c ON s.customer_id = c.customer_id
+        WHERE p.payment_id = {payment_id}
+        ''')
+        
+        if not payment_data.empty:
+            payment = payment_data.iloc[0]
+            
+            st.markdown("## 🎉 Payment Recorded Successfully!")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("💳 Payment Details")
+                st.write(f"**Payment ID:** {payment_id}")
+                st.write(f"**Invoice No:** {payment['invoice_no']}")
+                st.write(f"**Customer:** {payment['customer_name']}")
+                st.write(f"**Village:** {payment['village']}")
+                st.write(f"**Payment Method:** {payment['payment_method']}")
+            
+            with col2:
+                st.subheader("💰 Amount & Status")
+                st.write(f"**Amount Paid:** ₹{payment['amount']:,.2f}")
+                st.write(f"**Sale Total:** ₹{payment['total_amount']:,.2f}")
+                st.write(f"**Payment Date:** {payment['payment_date']}")
+                st.write(f"**Status:** {payment['status']}")
+                
+                if payment['reference']:
+                    st.write(f"**Reference:** {payment['reference']}")
+            
+            # Quick actions
+            st.markdown("### ⚡ Quick Actions")
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                if st.button("📋 View Payment History"):
+                    st.session_state.current_tab = "📋 Payment History"
+            
+            with col2:
+                if st.button("💰 Record Another"):
+                    st.rerun()
+            
+            with col3:
+                if st.button("⏳ View Pending"):
+                    st.session_state.current_tab = "⏳ Pending Payments"
+                    
+    except Exception as e:
+        st.error(f"Error displaying payment summary: {e}")
+
+def show_payment_history_tab(db):
+    """Show payment history and records"""
+    st.subheader("📋 Payment History")
+    
+    try:
+        # Date range filter
+        col1, col2 = st.columns(2)
+        with col1:
+            start_date = st.date_input("Start Date", datetime.now() - timedelta(days=30))
+        with col2:
+            end_date = st.date_input("End Date", datetime.now())
+        
+        # Status filter
+        status_filter = st.multiselect("Filter by Status", 
+                                     ["Completed", "Pending", "Failed"],
+                                     default=["Completed"])
+        
+        # Method filter
+        methods = db.get_dataframe('payments', "SELECT DISTINCT payment_method FROM payments")
+        if not methods.empty:
+            method_options = methods['payment_method'].dropna().unique().tolist()
+            method_filter = st.multiselect("Filter by Method", method_options, default=method_options)
+        
+        # Get payments data
+        payments_data = get_payments_data(db, start_date, end_date, status_filter, method_filter)
+        
+        if not payments_data.empty:
+            st.write(f"**💰 Showing {len(payments_data)} payments**")
+            
+            # Display payments
+            display_data = payments_data[['payment_date', 'customer_name', 'invoice_no', 'amount', 
+                                        'payment_method', 'status', 'reference']].copy()
+            display_data.columns = ['Date', 'Customer', 'Invoice', 'Amount', 'Method', 'Status', 'Reference']
+            display_data['Amount'] = display_data['Amount'].apply(lambda x: f"₹{x:,.2f}")
+            display_data = display_data.sort_values('Date', ascending=False)
+            
+            st.dataframe(display_data, use_container_width=True)
+            
+            # Payment statistics
+            st.subheader("📊 Payment Statistics")
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                total_payments = len(payments_data)
+                st.metric("Total Payments", total_payments)
+            
+            with col2:
+                total_amount = payments_data['amount'].sum()
+                st.metric("Total Amount", f"₹{total_amount:,.2f}")
+            
+            with col3:
+                completed = len(payments_data[payments_data['status'] == 'Completed'])
+                st.metric("Completed", completed)
+            
+            with col4:
+                avg_payment = payments_data['amount'].mean()
+                st.metric("Avg Payment", f"₹{avg_payment:,.0f}")
+        
+        else:
+            st.info("No payments found for the selected criteria.")
+            
+    except Exception as e:
+        st.error(f"Error loading payment history: {e}")
+
+def get_payments_data(db, start_date, end_date, status_filter, method_filter):
+    """Get payments data with filters"""
+    try:
+        query = '''
+        SELECT p.*, s.invoice_no, c.name as customer_name, c.village
+        FROM payments p
+        LEFT JOIN sales s ON p.sale_id = s.sale_id
+        LEFT JOIN customers c ON s.customer_id = c.customer_id
+        WHERE p.payment_date BETWEEN ? AND ?
+        '''
+        
+        params = [start_date, end_date]
+        
+        if status_filter:
+            placeholders = ','.join(['?' for _ in status_filter])
+            query += f' AND p.status IN ({placeholders})'
+            params.extend(status_filter)
+        
+        if method_filter:
+            placeholders = ','.join(['?' for _ in method_filter])
+            query += f' AND p.payment_method IN ({placeholders})'
+            params.extend(method_filter)
+        
+        query += ' ORDER BY p.payment_date DESC'
+        
+        return db.get_dataframe('payments', query, params=params)
+        
+    except Exception as e:
+        st.error(f"Error getting payments data: {e}")
+        return pd.DataFrame()
+
+def show_pending_payments_tab(db, whatsapp_manager):
+    """Show pending payments and reminders"""
+    st.subheader("⏳ Pending Payments")
+    
+    try:
+        # Get pending payments
+        pending_payments = get_pending_sales(db)
+        
+        if not pending_payments.empty:
+            st.warning(f"🚨 {len(pending_payments)} Sales with Pending Payments!")
+            
+            # Display pending payments
+            display_data = pending_payments[['invoice_no', 'customer_name', 'village', 'total_amount', 'pending_amount', 'payment_status']].copy()
+            display_data.columns = ['Invoice', 'Customer', 'Village', 'Total Amount', 'Pending Amount', 'Status']
+            display_data['Total Amount'] = display_data['Total Amount'].apply(lambda x: f"₹{x:,.2f}")
+            display_data['Pending Amount'] = display_data['Pending Amount'].apply(lambda x: f"₹{x:,.2f}")
+            
+            st.dataframe(display_data, use_container_width=True)
+            
+            # Total pending amount
+            total_pending = pending_payments['pending_amount'].sum()
+            st.error(f"**💰 Total Pending Amount: ₹{total_pending:,.2f}**")
+            
+            # Send reminders
+            st.subheader("📱 Send Payment Reminders")
+            selected_invoices = st.multiselect("Select Invoices for Reminders",
+                                             pending_payments['invoice_no'].tolist())
+            
+            if selected_invoices and whatsapp_manager:
+                if st.button("📧 Send WhatsApp Reminders"):
+                    send_bulk_payment_reminders(whatsapp_manager, db, pending_payments, selected_invoices)
+                    st.success("✅ Payment reminders sent!")
+            
+            elif not whatsapp_manager:
+                st.info("📱 WhatsApp manager not available for sending reminders")
+        
+        else:
+            st.success("🎉 All payments are cleared! No pending payments.")
+            
+    except Exception as e:
+        st.error(f"Error loading pending payments: {e}")
+
+def send_bulk_payment_reminders(whatsapp_manager, db, pending_payments, selected_invoices):
+    """Send bulk payment reminders"""
+    try:
+        selected_sales = pending_payments[pending_payments['invoice_no'].isin(selected_invoices)]
+        
+        for _, sale in selected_sales.iterrows():
+            if sale.get('mobile'):
+                message = f"""Hello {sale['customer_name']}! ⏰
+
+Friendly reminder regarding your pending payment.
+
+Invoice: {sale['invoice_no']}
+Pending Amount: ₹{sale['pending_amount']:,.2f}
+
+Please make the payment at your earliest convenience.
+
+Thank you for your cooperation!
+
+Best regards,
+Sales Team"""
+                
+                whatsapp_manager.send_message(sale['mobile'], message)
+        
+    except Exception as e:
+        st.error(f"Error sending reminders: {e}")
+
+def show_payment_analytics_tab(db):
+    """Show payment analytics and trends"""
+    st.subheader("📊 Payment Analytics")
+    
+    try:
+        # Get payments data for analytics
+        payments_data = db.get_dataframe('payments', '''
+        SELECT p.*, s.invoice_no, c.name as customer_name
+        FROM payments p
+        LEFT JOIN sales s ON p.sale_id = s.sale_id
+        LEFT JOIN customers c ON s.customer_id = c.customer_id
+        WHERE p.status = 'Completed'
+        ORDER BY p.payment_date DESC
+        ''')
+        
+        if not payments_data.empty:
+            # Payment method distribution
+            st.subheader("💳 Payment Methods Distribution")
+            method_stats = payments_data['payment_method'].value_counts()
+            
+            if not method_stats.empty:
+                fig = px.pie(values=method_stats.values, names=method_stats.index,
+                           title='Payment Methods Distribution')
+                st.plotly_chart(fig, use_container_width=True)
+            
+            # Monthly payment trend
+            st.subheader("📈 Monthly Payment Trend")
+            try:
+                payments_data['payment_date'] = pd.to_datetime(payments_data['payment_date'])
+                monthly_payments = payments_data.groupby(payments_data['payment_date'].dt.to_period('M')).agg({
+                    'amount': 'sum',
+                    'payment_id': 'count'
+                }).reset_index()
+                monthly_payments['payment_date'] = monthly_payments['payment_date'].astype(str)
+                
+                if not monthly_payments.empty:
+                    fig = px.line(monthly_payments, x='payment_date', y='amount',
+                                title='Monthly Payment Amount Trend',
+                                labels={'payment_date': 'Month', 'amount': 'Amount (₹)'})
+                    st.plotly_chart(fig, use_container_width=True)
+            except:
+                st.info("Could not generate monthly trend chart")
+            
+            # Top customers by payments
+            st.subheader("🏆 Top Customers by Payments")
+            customer_stats = payments_data.groupby('customer_name').agg({
+                'amount': 'sum',
+                'payment_id': 'count'
+            }).reset_index()
+            customer_stats.columns = ['Customer', 'Total Paid', 'Payment Count']
+            customer_stats = customer_stats.sort_values('Total Paid', ascending=False).head(10)
+            
+            st.dataframe(customer_stats, use_container_width=True)
+        
+        else:
+            st.info("No payment data available for analytics.")
+            
+    except Exception as e:
+        st.error(f"Error loading payment analytics: {e}")

pages/reports.py

@@ -0,0 +1,1101 @@
+# pages/reports.py
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import numpy as np
+
+def show_reports_page(db, whatsapp_manager=None):
+    """Show comprehensive business intelligence and reporting"""
+    st.title("📈 Business Intelligence & Reports")
+    
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+    
+    # Tabs for different report types
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["📊 Sales Reports", "👥 Customer Reports", 
+                                           "🤝 Distributor Reports", "💰 Financial Reports", 
+                                           "🎯 Performance Reports"])
+    
+    with tab1:
+        show_sales_reports_tab(db)
+    
+    with tab2:
+        show_customer_reports_tab(db)
+    
+    with tab3:
+        show_distributor_reports_tab(db)
+    
+    with tab4:
+        show_financial_reports_tab(db)
+    
+    with tab5:
+        show_performance_reports_tab(db)
+
+def show_sales_reports_tab(db):
+    """Show sales-related reports and analytics"""
+    st.subheader("📊 Sales Performance Reports")
+    
+    # Date range selection
+    col1, col2, col3 = st.columns([2, 2, 1])
+    
+    with col1:
+        start_date = st.date_input("Start Date", datetime.now() - timedelta(days=30))
+    with col2:
+        end_date = st.date_input("End Date", datetime.now())
+    with col3:
+        report_granularity = st.selectbox("Granularity", ["Daily", "Weekly", "Monthly"])
+    
+    try:
+        # Sales Summary
+        st.subheader("💰 Sales Summary")
+        sales_summary = get_sales_summary(db, start_date, end_date)
+        
+        if sales_summary:
+            col1, col2, col3, col4, col5 = st.columns(5)
+            
+            with col1:
+                st.metric("Total Sales", f"₹{sales_summary.get('total_sales', 0):,.0f}")
+            with col2:
+                st.metric("Total Revenue", f"₹{sales_summary.get('total_revenue', 0):,.0f}")
+            with col3:
+                st.metric("Transactions", sales_summary.get('total_transactions', 0))
+            with col4:
+                st.metric("Avg Sale Value", f"₹{sales_summary.get('avg_sale_value', 0):,.0f}")
+            with col5:
+                st.metric("Unique Customers", sales_summary.get('unique_customers', 0))
+        
+        # Sales Trend Chart
+        st.subheader("📈 Sales Trend")
+        sales_trend = get_sales_trend(db, start_date, end_date, report_granularity)
+        
+        if not sales_trend.empty:
+            fig = px.line(sales_trend, x='period', y='total_amount', 
+                         title=f'Sales Trend ({report_granularity})',
+                         labels={'period': 'Period', 'total_amount': 'Sales Amount (₹)'})
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Product Performance
+        st.subheader("📦 Product Performance")
+        product_performance = get_product_performance(db, start_date, end_date)
+        
+        if not product_performance.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Top products by revenue
+                top_products = product_performance.head(10)
+                fig = px.bar(top_products, x='product_name', y='total_revenue',
+                           title='Top 10 Products by Revenue',
+                           labels={'product_name': 'Product', 'total_revenue': 'Revenue (₹)'})
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                # Product sales distribution
+                fig = px.pie(product_performance, values='total_quantity', names='product_name',
+                           title='Product Sales Distribution (Quantity)')
+                st.plotly_chart(fig, use_container_width=True)
+            
+            # Detailed product table
+            st.dataframe(product_performance, use_container_width=True)
+        
+        # Village-wise Sales
+        st.subheader("🗺️ Village-wise Sales Performance")
+        village_sales = get_village_sales(db, start_date, end_date)
+        
+        if not village_sales.empty:
+            fig = px.bar(village_sales.head(10), x='village', y='total_revenue',
+                       title='Top 10 Villages by Sales Revenue',
+                       labels={'village': 'Village', 'total_revenue': 'Revenue (₹)'})
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Village sales table
+            st.dataframe(village_sales, use_container_width=True)
+        
+        # Export options
+        st.subheader("📤 Export Sales Report")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("📊 Export Sales Data to CSV"):
+                export_sales_data(db, start_date, end_date)
+        
+        with col2:
+            if st.button("📈 Generate Sales PDF Report"):
+                generate_sales_pdf_report(db, start_date, end_date)
+                
+    except Exception as e:
+        st.error(f"Error generating sales reports: {e}")
+
+def get_sales_summary(db, start_date, end_date):
+    """Get sales summary statistics"""
+    try:
+        query = '''
+        SELECT 
+            COUNT(*) as total_transactions,
+            SUM(total_amount) as total_revenue,
+            AVG(total_amount) as avg_sale_value,
+            COUNT(DISTINCT customer_id) as unique_customers,
+            SUM(total_liters) as total_liters_sold
+        FROM sales 
+        WHERE sale_date BETWEEN ? AND ?
+        '''
+        
+        result = db.execute_query(query, (start_date, end_date), log_action=False)
+        
+        if result:
+            row = result[0]
+            return {
+                'total_transactions': row[0] or 0,
+                'total_revenue': row[1] or 0,
+                'avg_sale_value': row[2] or 0,
+                'unique_customers': row[3] or 0,
+                'total_liters_sold': row[4] or 0
+            }
+        return {}
+        
+    except Exception as e:
+        st.error(f"Error getting sales summary: {e}")
+        return {}
+
+def get_sales_trend(db, start_date, end_date, granularity):
+    """Get sales trend data"""
+    try:
+        if granularity == "Daily":
+            group_by = "DATE(sale_date)"
+            period_format = "sale_date"
+        elif granularity == "Weekly":
+            group_by = "STRFTIME('%Y-%W', sale_date)"
+            period_format = "STRFTIME('%Y-W%W', sale_date) as period"
+        else:  # Monthly
+            group_by = "STRFTIME('%Y-%m', sale_date)"
+            period_format = "STRFTIME('%Y-%m', sale_date) as period"
+        
+        query = f'''
+        SELECT {period_format}, 
+               SUM(total_amount) as total_amount,
+               COUNT(*) as transaction_count,
+               AVG(total_amount) as avg_amount
+        FROM sales 
+        WHERE sale_date BETWEEN ? AND ?
+        GROUP BY {group_by}
+        ORDER BY period
+        '''
+        
+        return db.get_dataframe('sales', query, params=(start_date, end_date))
+        
+    except Exception as e:
+        st.error(f"Error getting sales trend: {e}")
+        return pd.DataFrame()
+
+def get_product_performance(db, start_date, end_date):
+    """Get product performance data"""
+    try:
+        query = '''
+        SELECT 
+            p.product_name,
+            p.packing_type,
+            p.capacity_ltr,
+            COUNT(si.item_id) as times_sold,
+            SUM(si.quantity) as total_quantity,
+            SUM(si.amount) as total_revenue,
+            AVG(si.rate) as avg_rate
+        FROM sale_items si
+        JOIN products p ON si.product_id = p.product_id
+        JOIN sales s ON si.sale_id = s.sale_id
+        WHERE s.sale_date BETWEEN ? AND ?
+        GROUP BY p.product_id, p.product_name, p.packing_type, p.capacity_ltr
+        ORDER BY total_revenue DESC
+        '''
+        
+        return db.get_dataframe('sale_items', query, params=(start_date, end_date))
+        
+    except Exception as e:
+        st.error(f"Error getting product performance: {e}")
+        return pd.DataFrame()
+
+def get_village_sales(db, start_date, end_date):
+    """Get village-wise sales data"""
+    try:
+        query = '''
+        SELECT 
+            c.village,
+            COUNT(DISTINCT s.customer_id) as unique_customers,
+            COUNT(s.sale_id) as total_transactions,
+            SUM(s.total_amount) as total_revenue,
+            AVG(s.total_amount) as avg_sale_value
+        FROM sales s
+        JOIN customers c ON s.customer_id = c.customer_id
+        WHERE s.sale_date BETWEEN ? AND ?
+        AND c.village IS NOT NULL AND c.village != ''
+        GROUP BY c.village
+        ORDER BY total_revenue DESC
+        '''
+        
+        return db.get_dataframe('sales', query, params=(start_date, end_date))
+        
+    except Exception as e:
+        st.error(f"Error getting village sales: {e}")
+        return pd.DataFrame()
+
+def show_customer_reports_tab(db):
+    """Show customer-related reports and analytics"""
+    st.subheader("👥 Customer Intelligence Reports")
+    
+    try:
+        # Customer Overview
+        st.subheader("📋 Customer Overview")
+        customer_overview = get_customer_overview(db)
+        
+        if customer_overview:
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Total Customers", customer_overview.get('total_customers', 0))
+            with col2:
+                st.metric("Active Customers", customer_overview.get('active_customers', 0))
+            with col3:
+                st.metric("Avg Customer Value", f"₹{customer_overview.get('avg_customer_value', 0):,.0f}")
+            with col4:
+                st.metric("Repeat Customer Rate", f"{customer_overview.get('repeat_rate', 0):.1f}%")
+        
+        # Top Customers
+        st.subheader("🏆 Top Customers by Spending")
+        top_customers = get_top_customers(db)
+        
+        if not top_customers.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig = px.bar(top_customers.head(10), x='name', y='total_spent',
+                           title='Top 10 Customers by Total Spending',
+                           labels={'name': 'Customer', 'total_spent': 'Total Spent (₹)'})
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                # Customer segmentation by spending
+                spending_brackets = categorize_customers_by_spending(top_customers)
+                fig = px.pie(values=spending_brackets.values, names=spending_brackets.index,
+                           title='Customer Segmentation by Spending')
+                st.plotly_chart(fig, use_container_width=True)
+            
+            # Customer details table
+            st.dataframe(top_customers, use_container_width=True)
+        
+        # Customer Acquisition Trend
+        st.subheader("📈 Customer Acquisition Trend")
+        acquisition_trend = get_customer_acquisition_trend(db)
+        
+        if not acquisition_trend.empty:
+            fig = px.line(acquisition_trend, x='month', y='new_customers',
+                         title='Monthly Customer Acquisition',
+                         labels={'month': 'Month', 'new_customers': 'New Customers'})
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Customer Location Analysis
+        st.subheader("🗺️ Customer Geographic Distribution")
+        customer_geo = get_customer_geographic_data(db)
+        
+        if not customer_geo.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Village-wise customer count
+                village_customers = customer_geo.groupby('village').size().reset_index(name='customer_count')
+                village_customers = village_customers.sort_values('customer_count', ascending=False).head(10)
+                
+                fig = px.bar(village_customers, x='village', y='customer_count',
+                           title='Top 10 Villages by Customer Count',
+                           labels={'village': 'Village', 'customer_count': 'Number of Customers'})
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                # Taluka-wise distribution
+                taluka_customers = customer_geo.groupby('taluka').size().reset_index(name='customer_count')
+                
+                if not taluka_customers.empty:
+                    fig = px.pie(taluka_customers, values='customer_count', names='taluka',
+                               title='Customer Distribution by Taluka')
+                    st.plotly_chart(fig, use_container_width=True)
+        
+        # Customer Lifetime Value Analysis
+        st.subheader("💰 Customer Lifetime Value Analysis")
+        clv_data = get_customer_lifetime_value(db)
+        
+        if not clv_data.empty:
+            st.dataframe(clv_data, use_container_width=True)
+            
+    except Exception as e:
+        st.error(f"Error generating customer reports: {e}")
+
+def get_customer_overview(db):
+    """Get customer overview statistics"""
+    try:
+        # Total customers
+        total_customers = db.execute_query(
+            "SELECT COUNT(*) FROM customers", log_action=False
+        )[0][0]
+        
+        # Customers with purchases
+        active_customers = db.execute_query(
+            "SELECT COUNT(DISTINCT customer_id) FROM sales", log_action=False
+        )[0][0]
+        
+        # Average customer value
+        avg_value_result = db.execute_query(
+            "SELECT AVG(total_amount) FROM sales", log_action=False
+        )
+        avg_customer_value = avg_value_result[0][0] if avg_value_result else 0
+        
+        # Repeat customer rate
+        repeat_customers = db.execute_query(
+            "SELECT COUNT(*) FROM (SELECT customer_id FROM sales GROUP BY customer_id HAVING COUNT(*) > 1)",
+            log_action=False
+        )[0][0]
+        
+        repeat_rate = (repeat_customers / active_customers * 100) if active_customers > 0 else 0
+        
+        return {
+            'total_customers': total_customers,
+            'active_customers': active_customers,
+            'avg_customer_value': avg_customer_value or 0,
+            'repeat_rate': repeat_rate
+        }
+        
+    except Exception as e:
+        st.error(f"Error getting customer overview: {e}")
+        return {}
+
+def get_top_customers(db, limit=20):
+    """Get top customers by spending"""
+    try:
+        query = '''
+        SELECT 
+            c.customer_id,
+            c.name,
+            c.village,
+            c.taluka,
+            c.mobile,
+            COUNT(s.sale_id) as total_purchases,
+            SUM(s.total_amount) as total_spent,
+            MAX(s.sale_date) as last_purchase_date
+        FROM customers c
+        JOIN sales s ON c.customer_id = s.customer_id
+        GROUP BY c.customer_id, c.name, c.village, c.taluka, c.mobile
+        ORDER BY total_spent DESC
+        LIMIT ?
+        '''
+        
+        return db.get_dataframe('customers', query, params=(limit,))
+        
+    except Exception as e:
+        st.error(f"Error getting top customers: {e}")
+        return pd.DataFrame()
+
+def categorize_customers_by_spending(customers_df):
+    """Categorize customers by spending levels"""
+    try:
+        if customers_df.empty:
+            return pd.Series()
+        
+        bins = [0, 1000, 5000, 10000, float('inf')]
+        labels = ['Low (<1K)', 'Medium (1K-5K)', 'High (5K-10K)', 'VIP (>10K)']
+        
+        customers_df['spending_category'] = pd.cut(
+            customers_df['total_spent'], bins=bins, labels=labels, right=False
+        )
+        
+        return customers_df['spending_category'].value_counts()
+        
+    except Exception as e:
+        st.error(f"Error categorizing customers: {e}")
+        return pd.Series()
+
+def get_customer_acquisition_trend(db):
+    """Get customer acquisition trend"""
+    try:
+        query = '''
+        SELECT 
+            STRFTIME('%Y-%m', created_date) as month,
+            COUNT(*) as new_customers
+        FROM customers
+        GROUP BY STRFTIME('%Y-%m', created_date)
+        ORDER BY month
+        '''
+        
+        return db.get_dataframe('customers', query)
+        
+    except Exception as e:
+        st.error(f"Error getting acquisition trend: {e}")
+        return pd.DataFrame()
+
+def get_customer_geographic_data(db):
+    """Get customer geographic distribution"""
+    try:
+        return db.get_dataframe('customers', '''
+        SELECT village, taluka, district, COUNT(*) as customer_count
+        FROM customers
+        WHERE village IS NOT NULL AND village != ''
+        GROUP BY village, taluka, district
+        ORDER BY customer_count DESC
+        ''')
+        
+    except Exception as e:
+        st.error(f"Error getting geographic data: {e}")
+        return pd.DataFrame()
+
+def get_customer_lifetime_value(db):
+    """Calculate customer lifetime value"""
+    try:
+        query = '''
+        SELECT 
+            c.customer_id,
+            c.name,
+            c.village,
+            COUNT(s.sale_id) as purchase_frequency,
+            SUM(s.total_amount) as total_value,
+            AVG(s.total_amount) as avg_order_value,
+            JULIANDAY(MAX(s.sale_date)) - JULIANDAY(MIN(s.sale_date)) as customer_tenure_days,
+            CASE 
+                WHEN COUNT(s.sale_id) > 0 THEN 
+                    SUM(s.total_amount) / (COUNT(s.sale_id) * GREATEST((JULIANDAY(MAX(s.sale_date)) - JULIANDAY(MIN(s.sale_date)))/30, 1))
+                ELSE 0 
+            END as clv
+        FROM customers c
+        LEFT JOIN sales s ON c.customer_id = s.customer_id
+        GROUP BY c.customer_id, c.name, c.village
+        HAVING total_value > 0
+        ORDER BY clv DESC
+        '''
+        
+        return db.get_dataframe('customers', query)
+        
+    except Exception as e:
+        st.error(f"Error calculating CLV: {e}")
+        return pd.DataFrame()
+
+def show_distributor_reports_tab(db):
+    """Show distributor-related reports and analytics"""
+    st.subheader("🤝 Distributor Performance Reports")
+    
+    try:
+        # Distributor Overview
+        st.subheader("📋 Distributor Network Overview")
+        distributor_overview = get_distributor_overview(db)
+        
+        if distributor_overview:
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Total Distributors", distributor_overview.get('total_distributors', 0))
+            with col2:
+                st.metric("Active Distributors", distributor_overview.get('active_distributors', 0))
+            with col3:
+                st.metric("Total Sabhasad", distributor_overview.get('total_sabhasad', 0))
+            with col4:
+                st.metric("Network Size", distributor_overview.get('network_size', 0))
+        
+        # Top Performers
+        st.subheader("🏆 Top Performing Distributors")
+        top_distributors = get_top_distributors(db)
+        
+        if not top_distributors.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig = px.bar(top_distributors.head(10), x='name', y='sabhasad_count',
+                           title='Top 10 Distributors by Sabhasad Count',
+                           labels={'name': 'Distributor', 'sabhasad_count': 'Sabhasad Count'})
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                # Performance tiers
+                tier_distribution = top_distributors['performance_tier'].value_counts()
+                fig = px.pie(values=tier_distribution.values, names=tier_distribution.index,
+                           title='Distributor Performance Tier Distribution')
+                st.plotly_chart(fig, use_container_width=True)
+            
+            # Distributor details table
+            st.dataframe(top_distributors, use_container_width=True)
+        
+        # Territory Coverage
+        st.subheader("🗺️ Territory Coverage Analysis")
+        territory_coverage = get_territory_coverage(db)
+        
+        if not territory_coverage.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig = px.bar(territory_coverage.head(10), x='village', y='distributor_count',
+                           title='Villages with Multiple Distributors',
+                           labels={'village': 'Village', 'distributor_count': 'Distributor Count'})
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                # Coverage status
+                coverage_status = {
+                    'Covered Villages': len(territory_coverage[territory_coverage['distributor_count'] > 0]),
+                    'Uncovered Villages': len(territory_coverage[territory_coverage['distributor_count'] == 0])
+                }
+                
+                fig = px.pie(values=coverage_status.values(), names=coverage_status.keys(),
+                           title='Village Coverage Status')
+                st.plotly_chart(fig, use_container_width=True)
+        
+        # Growth Potential Analysis
+        st.subheader("📈 Growth Potential Analysis")
+        growth_potential = get_growth_potential(db)
+        
+        if not growth_potential.empty:
+            st.dataframe(growth_potential, use_container_width=True)
+            
+    except Exception as e:
+        st.error(f"Error generating distributor reports: {e}")
+
+def get_distributor_overview(db):
+    """Get distributor network overview"""
+    try:
+        distributors = db.get_dataframe('distributors', 'SELECT * FROM distributors')
+        
+        if distributors.empty:
+            return {}
+        
+        total_distributors = len(distributors)
+        active_distributors = len(distributors[distributors['sabhasad_count'] > 0])
+        total_sabhasad = distributors['sabhasad_count'].sum()
+        network_size = total_distributors + total_sabhasad
+        
+        return {
+            'total_distributors': total_distributors,
+            'active_distributors': active_distributors,
+            'total_sabhasad': total_sabhasad,
+            'network_size': network_size
+        }
+        
+    except Exception as e:
+        st.error(f"Error getting distributor overview: {e}")
+        return {}
+
+def get_top_distributors(db, limit=20):
+    """Get top performing distributors"""
+    try:
+        distributors = db.get_dataframe('distributors', '''
+        SELECT *, 
+               (sabhasad_count + contact_in_group) as network_score
+        FROM distributors 
+        ORDER BY sabhasad_count DESC 
+        LIMIT ?
+        ''', params=(limit,))
+        
+        if not distributors.empty:
+            # Add performance tier
+            distributors['performance_tier'] = distributors['sabhasad_count'].apply(
+                lambda x: 'Platinum' if x >= 20 else 'Gold' if x >= 10 else 'Silver' if x >= 5 else 'Bronze'
+            )
+        
+        return distributors
+        
+    except Exception as e:
+        st.error(f"Error getting top distributors: {e}")
+        return pd.DataFrame()
+
+def get_territory_coverage(db):
+    """Get territory coverage analysis"""
+    try:
+        # Get all villages from customers
+        customer_villages = db.get_dataframe('customers', '''
+        SELECT DISTINCT village 
+        FROM customers 
+        WHERE village IS NOT NULL AND village != ''
+        ''')
+        
+        # Get distributor villages
+        distributor_villages = db.get_dataframe('distributors', '''
+        SELECT village, COUNT(*) as distributor_count
+        FROM distributors 
+        WHERE village IS NOT NULL AND village != ''
+        GROUP BY village
+        ''')
+        
+        # Merge to see coverage
+        if not customer_villages.empty:
+            if not distributor_villages.empty:
+                coverage = pd.merge(customer_villages, distributor_villages, on='village', how='left')
+            else:
+                coverage = customer_villages.copy()
+                coverage['distributor_count'] = 0
+            
+            coverage['distributor_count'] = coverage['distributor_count'].fillna(0)
+            return coverage.sort_values('distributor_count', ascending=False)
+        
+        return pd.DataFrame()
+        
+    except Exception as e:
+        st.error(f"Error getting territory coverage: {e}")
+        return pd.DataFrame()
+
+def get_growth_potential(db):
+    """Get distributor growth potential analysis"""
+    try:
+        return db.get_dataframe('distributors', '''
+        SELECT 
+            name,
+            village,
+            sabhasad_count,
+            contact_in_group,
+            (contact_in_group - sabhasad_count) as conversion_potential,
+            CASE 
+                WHEN sabhasad_count = 0 THEN contact_in_group * 0.3
+                ELSE (contact_in_group / sabhasad_count - 1) * sabhasad_count
+            END as growth_opportunity
+        FROM distributors
+        WHERE contact_in_group > sabhasad_count
+        ORDER BY growth_opportunity DESC
+        ''')
+        
+    except Exception as e:
+        st.error(f"Error getting growth potential: {e}")
+        return pd.DataFrame()
+
+def show_financial_reports_tab(db):
+    """Show financial reports and analytics"""
+    st.subheader("💰 Financial Performance Reports")
+    
+    # Date range selection
+    col1, col2 = st.columns(2)
+    with col1:
+        start_date = st.date_input("Start Date", datetime.now() - timedelta(days=90), key="financial_start")
+    with col2:
+        end_date = st.date_input("End Date", datetime.now(), key="financial_end")
+    
+    try:
+        # Financial Summary
+        st.subheader("📋 Financial Summary")
+        financial_summary = get_financial_summary(db, start_date, end_date)
+        
+        if financial_summary:
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Total Revenue", f"₹{financial_summary.get('total_revenue', 0):,.0f}")
+            with col2:
+                st.metric("Total Payments", f"₹{financial_summary.get('total_payments', 0):,.0f}")
+            with col3:
+                st.metric("Pending Amount", f"₹{financial_summary.get('pending_amount', 0):,.0f}")
+            with col4:
+                collection_rate = financial_summary.get('collection_rate', 0)
+                st.metric("Collection Rate", f"{collection_rate:.1f}%")
+        
+        # Revenue vs Payments Trend
+        st.subheader("📈 Revenue vs Payments Trend")
+        financial_trend = get_financial_trend(db, start_date, end_date)
+        
+        if not financial_trend.empty:
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(x=financial_trend['period'], y=financial_trend['revenue'], 
+                                   name='Revenue', line=dict(color='green')))
+            fig.add_trace(go.Scatter(x=financial_trend['period'], y=financial_trend['payments'], 
+                                   name='Payments', line=dict(color='blue')))
+            fig.update_layout(title='Revenue vs Payments Trend', xaxis_title='Period', yaxis_title='Amount (₹)')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Payment Method Analysis
+        st.subheader("💳 Payment Method Analysis")
+        payment_methods = get_payment_methods_analysis(db, start_date, end_date)
+        
+        if not payment_methods.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig = px.pie(payment_methods, values='total_amount', names='payment_method',
+                           title='Payment Methods Distribution')
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                fig = px.bar(payment_methods, x='payment_method', y='transaction_count',
+                           title='Transactions by Payment Method',
+                           labels={'payment_method': 'Payment Method', 'transaction_count': 'Number of Transactions'})
+                st.plotly_chart(fig, use_container_width=True)
+        
+        # Aging Analysis
+        st.subheader("⏳ Accounts Receivable Aging")
+        aging_analysis = get_aging_analysis(db)
+        
+        if not aging_analysis.empty:
+            st.dataframe(aging_analysis, use_container_width=True)
+            
+    except Exception as e:
+        st.error(f"Error generating financial reports: {e}")
+
+def get_financial_summary(db, start_date, end_date):
+    """Get financial summary"""
+    try:
+        # Total revenue
+        revenue_result = db.execute_query(
+            "SELECT SUM(total_amount) FROM sales WHERE sale_date BETWEEN ? AND ?",
+            (start_date, end_date), log_action=False
+        )
+        total_revenue = revenue_result[0][0] or 0 if revenue_result else 0
+        
+        # Total payments
+        payments_result = db.execute_query(
+            "SELECT SUM(amount) FROM payments WHERE payment_date BETWEEN ? AND ? AND status = 'Completed'",
+            (start_date, end_date), log_action=False
+        )
+        total_payments = payments_result[0][0] or 0 if payments_result else 0
+        
+        # Pending amount
+        pending_result = db.execute_query(
+            "SELECT SUM(total_amount - COALESCE((SELECT SUM(amount) FROM payments WHERE payments.sale_id = sales.sale_id AND status = 'Completed'), 0)) FROM sales WHERE sale_date BETWEEN ? AND ?",
+            (start_date, end_date), log_action=False
+        )
+        pending_amount = pending_result[0][0] or 0 if pending_result else 0
+        
+        # Collection rate
+        collection_rate = (total_payments / total_revenue * 100) if total_revenue > 0 else 0
+        
+        return {
+            'total_revenue': total_revenue,
+            'total_payments': total_payments,
+            'pending_amount': pending_amount,
+            'collection_rate': collection_rate
+        }
+        
+    except Exception as e:
+        st.error(f"Error getting financial summary: {e}")
+        return {}
+
+def get_financial_trend(db, start_date, end_date):
+    """Get financial trend data"""
+    try:
+        query = '''
+        SELECT 
+            STRFTIME('%Y-%m', sale_date) as period,
+            SUM(total_amount) as revenue,
+            (SELECT SUM(amount) FROM payments 
+             WHERE STRFTIME('%Y-%m', payment_date) = STRFTIME('%Y-%m', sales.sale_date)
+             AND status = 'Completed') as payments
+        FROM sales
+        WHERE sale_date BETWEEN ? AND ?
+        GROUP BY STRFTIME('%Y-%m', sale_date)
+        ORDER BY period
+        '''
+        
+        return db.get_dataframe('sales', query, params=(start_date, end_date))
+        
+    except Exception as e:
+        st.error(f"Error getting financial trend: {e}")
+        return pd.DataFrame()
+
+def get_payment_methods_analysis(db, start_date, end_date):
+    """Get payment methods analysis"""
+    try:
+        query = '''
+        SELECT 
+            payment_method,
+            COUNT(*) as transaction_count,
+            SUM(amount) as total_amount,
+            AVG(amount) as avg_amount
+        FROM payments
+        WHERE payment_date BETWEEN ? AND ? AND status = 'Completed'
+        GROUP BY payment_method
+        ORDER BY total_amount DESC
+        '''
+        
+        return db.get_dataframe('payments', query, params=(start_date, end_date))
+        
+    except Exception as e:
+        st.error(f"Error getting payment methods analysis: {e}")
+        return pd.DataFrame()
+
+def get_aging_analysis(db):
+    """Get accounts receivable aging analysis"""
+    try:
+        query = '''
+        SELECT 
+            s.invoice_no,
+            c.name as customer_name,
+            c.village,
+            s.sale_date,
+            s.total_amount,
+            COALESCE(SUM(p.amount), 0) as paid_amount,
+            (s.total_amount - COALESCE(SUM(p.amount), 0)) as pending_amount,
+            JULIANDAY('now') - JULIANDAY(s.sale_date) as days_pending,
+            CASE 
+                WHEN JULIANDAY('now') - JULIANDAY(s.sale_date) <= 30 THEN '0-30 days'
+                WHEN JULIANDAY('now') - JULIANDAY(s.sale_date) <= 60 THEN '31-60 days'
+                WHEN JULIANDAY('now') - JULIANDAY(s.sale_date) <= 90 THEN '61-90 days'
+                ELSE 'Over 90 days'
+            END as aging_bucket
+        FROM sales s
+        JOIN customers c ON s.customer_id = c.customer_id
+        LEFT JOIN payments p ON s.sale_id = p.sale_id AND p.status = 'Completed'
+        WHERE s.payment_status IN ('Pending', 'Partial')
+        GROUP BY s.sale_id, s.invoice_no, c.name, c.village, s.sale_date, s.total_amount
+        HAVING pending_amount > 0
+        ORDER BY days_pending DESC
+        '''
+        
+        return db.get_dataframe('sales', query)
+        
+    except Exception as e:
+        st.error(f"Error getting aging analysis: {e}")
+        return pd.DataFrame()
+
+def show_performance_reports_tab(db):
+    """Show overall performance and KPI reports"""
+    st.subheader("🎯 Business Performance Dashboard")
+    
+    try:
+        # Key Performance Indicators
+        st.subheader("📊 Key Performance Indicators (KPIs)")
+        
+        kpis = get_performance_kpis(db)
+        
+        if kpis:
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Monthly Revenue", f"₹{kpis.get('monthly_revenue', 0):,.0f}")
+            with col2:
+                st.metric("Customer Growth", f"+{kpis.get('customer_growth', 0)}")
+            with col3:
+                st.metric("Demo Conversion", f"{kpis.get('demo_conversion_rate', 0):.1f}%")
+            with col4:
+                st.metric("Payment Collection", f"{kpis.get('collection_rate', 0):.1f}%")
+        
+        # Performance Scorecard
+        st.subheader("📋 Performance Scorecard")
+        scorecard = get_performance_scorecard(db)
+        
+        if not scorecard.empty:
+            st.dataframe(scorecard, use_container_width=True)
+        
+        # Goal Tracking
+        st.subheader("🎯 Goal vs Actual Performance")
+        goals_vs_actual = get_goals_vs_actual(db)
+        
+        if not goals_vs_actual.empty:
+            for _, goal in goals_vs_actual.iterrows():
+                progress = min((goal['actual'] / goal['target']) * 100, 100) if goal['target'] > 0 else 0
+                st.write(f"**{goal['metric']}**")
+                st.progress(progress / 100)
+                st.write(f"Target: {goal['target']} | Actual: {goal['actual']} | Progress: {progress:.1f}%")
+        
+        # Export Comprehensive Report
+        st.subheader("📤 Export Comprehensive Report")
+        
+        if st.button("📄 Generate Full Business Report"):
+            generate_comprehensive_report(db)
+            
+    except Exception as e:
+        st.error(f"Error generating performance reports: {e}")
+
+def get_performance_kpis(db):
+    """Get key performance indicators"""
+    try:
+        # Monthly revenue (last 30 days)
+        monthly_revenue_result = db.execute_query(
+            "SELECT SUM(total_amount) FROM sales WHERE sale_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        monthly_revenue = monthly_revenue_result[0][0] or 0 if monthly_revenue_result else 0
+        
+        # Customer growth (last 30 days)
+        customer_growth_result = db.execute_query(
+            "SELECT COUNT(*) FROM customers WHERE created_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        customer_growth = customer_growth_result[0][0] or 0 if customer_growth_result else 0
+        
+        # Demo conversion rate
+        demos_result = db.execute_query(
+            "SELECT COUNT(*), SUM(CASE WHEN conversion_status = 'Converted' THEN 1 ELSE 0 END) FROM demos",
+            log_action=False
+        )
+        if demos_result and demos_result[0][0] > 0:
+            demo_conversion_rate = (demos_result[0][1] / demos_result[0][0]) * 100
+        else:
+            demo_conversion_rate = 0
+        
+        # Collection rate
+        collection_result = db.execute_query(
+            "SELECT SUM(total_amount), SUM(COALESCE((SELECT SUM(amount) FROM payments WHERE payments.sale_id = sales.sale_id AND status = 'Completed'), 0)) FROM sales",
+            log_action=False
+        )
+        if collection_result and collection_result[0][0] and collection_result[0][0] > 0:
+            collection_rate = (collection_result[0][1] / collection_result[0][0]) * 100
+        else:
+            collection_rate = 0
+        
+        return {
+            'monthly_revenue': monthly_revenue,
+            'customer_growth': customer_growth,
+            'demo_conversion_rate': demo_conversion_rate,
+            'collection_rate': collection_rate
+        }
+        
+    except Exception as e:
+        st.error(f"Error getting KPIs: {e}")
+        return {}
+
+def get_performance_scorecard(db):
+    """Get performance scorecard"""
+    try:
+        scorecard_data = []
+        
+        # Sales performance
+        sales_data = db.execute_query(
+            "SELECT COUNT(*), SUM(total_amount), AVG(total_amount) FROM sales WHERE sale_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        if sales_data:
+            scorecard_data.append({
+                'Category': 'Sales',
+                'Metric': 'Monthly Transactions',
+                'Value': sales_data[0][0] or 0,
+                'Target': 50,
+                'Status': 'On Track' if (sales_data[0][0] or 0) >= 40 else 'Needs Attention'
+            })
+            
+            scorecard_data.append({
+                'Category': 'Sales',
+                'Metric': 'Monthly Revenue',
+                'Value': f"₹{sales_data[0][1] or 0:,.0f}",
+                'Target': '₹50,000',
+                'Status': 'On Track' if (sales_data[0][1] or 0) >= 40000 else 'Needs Attention'
+            })
+        
+        # Customer performance
+        customer_data = db.execute_query(
+            "SELECT COUNT(*) FROM customers WHERE created_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        if customer_data:
+            scorecard_data.append({
+                'Category': 'Customers',
+                'Metric': 'New Customers',
+                'Value': customer_data[0][0] or 0,
+                'Target': 20,
+                'Status': 'On Track' if (customer_data[0][0] or 0) >= 15 else 'Needs Attention'
+            })
+        
+        # Distributor performance
+        distributor_data = db.execute_query(
+            "SELECT COUNT(*), SUM(sabhasad_count) FROM distributors",
+            log_action=False
+        )
+        if distributor_data:
+            scorecard_data.append({
+                'Category': 'Distribution',
+                'Metric': 'Total Distributors',
+                'Value': distributor_data[0][0] or 0,
+                'Target': 10,
+                'Status': 'On Track' if (distributor_data[0][0] or 0) >= 8 else 'Needs Attention'
+            })
+            
+            scorecard_data.append({
+                'Category': 'Distribution',
+                'Metric': 'Total Sabhasad',
+                'Value': distributor_data[0][1] or 0,
+                'Target': 100,
+                'Status': 'On Track' if (distributor_data[0][1] or 0) >= 80 else 'Needs Attention'
+            })
+        
+        return pd.DataFrame(scorecard_data)
+        
+    except Exception as e:
+        st.error(f"Error getting performance scorecard: {e}")
+        return pd.DataFrame()
+
+def get_goals_vs_actual(db):
+    """Get goals vs actual performance"""
+    try:
+        goals = [
+            {'metric': 'Monthly Revenue', 'target': 50000, 'actual': 0},
+            {'metric': 'New Customers', 'target': 20, 'actual': 0},
+            {'metric': 'Demos Conducted', 'target': 15, 'actual': 0},
+            {'metric': 'Payment Collection', 'target': 95, 'actual': 0}
+        ]
+        
+        # Get actual values
+        revenue_result = db.execute_query(
+            "SELECT SUM(total_amount) FROM sales WHERE sale_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        if revenue_result:
+            goals[0]['actual'] = revenue_result[0][0] or 0
+        
+        customer_result = db.execute_query(
+            "SELECT COUNT(*) FROM customers WHERE created_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        if customer_result:
+            goals[1]['actual'] = customer_result[0][0] or 0
+        
+        demo_result = db.execute_query(
+            "SELECT COUNT(*) FROM demos WHERE demo_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        if demo_result:
+            goals[2]['actual'] = demo_result[0][0] or 0
+        
+        collection_result = db.execute_query(
+            "SELECT SUM(total_amount), SUM(COALESCE((SELECT SUM(amount) FROM payments WHERE payments.sale_id = sales.sale_id AND status = 'Completed'), 0)) FROM sales WHERE sale_date >= date('now', '-30 days')",
+            log_action=False
+        )
+        if collection_result and collection_result[0][0] and collection_result[0][0] > 0:
+            goals[3]['actual'] = (collection_result[0][1] / collection_result[0][0]) * 100
+        
+        return pd.DataFrame(goals)
+        
+    except Exception as e:
+        st.error(f"Error getting goals vs actual: {e}")
+        return pd.DataFrame()
+
+def export_sales_data(db, start_date, end_date):
+    """Export sales data to CSV"""
+    try:
+        sales_data = db.get_dataframe('sales', '''
+        SELECT s.*, c.name as customer_name, c.village, c.taluka
+        FROM sales s
+        JOIN customers c ON s.customer_id = c.customer_id
+        WHERE s.sale_date BETWEEN ? AND ?
+        ORDER BY s.sale_date DESC
+        ''', params=(start_date, end_date))
+        
+        if not sales_data.empty:
+            csv = sales_data.to_csv(index=False)
+            st.download_button(
+                label="📥 Download Sales Data as CSV",
+                data=csv,
+                file_name=f"sales_report_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv"
+            )
+        
+    except Exception as e:
+        st.error(f"Error exporting sales data: {e}")
+
+def generate_sales_pdf_report(db, start_date, end_date):
+    """Generate PDF sales report (placeholder)"""
+    st.info("📄 PDF report generation feature will be implemented soon!")
+    st.info("This would generate a comprehensive PDF report with charts and analysis.")
+
+def generate_comprehensive_report(db):
+    """Generate comprehensive business report"""
+    st.success("🎉 Comprehensive business report generated!")
+    st.info("""
+    **Report Includes:**
+    - Executive Summary
+    - Sales Performance Analysis
+    - Customer Insights
+    - Distributor Network Performance
+    - Financial Overview
+    - Key Recommendations
+    
+    *Note: Full report generation with export features will be implemented in the next version.*
+    """)
+
+# Add this to your main file routing

pages/sales.py

@@ -0,0 +1,500 @@
+# pages/sales.py
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta
+import re
+
+def show_sales_page(db, whatsapp_manager=None):
+    """Show enhanced sales management page with quick customer creation and WhatsApp"""
+    st.title("💰 Sales Management")
+    
+    if not db:
+        st.error("Database not available. Please check initialization.")
+        return
+    
+    # Tabs for different sales functions
+    tab1, tab2, tab3 = st.tabs(["➕ Quick Sale", "📋 Sales History", "🔍 Sales Analytics"])
+    
+    with tab1:
+        show_quick_sale_tab(db, whatsapp_manager)
+    
+    with tab2:
+        show_sales_history_tab(db)
+    
+    with tab3:
+        show_sales_analytics_tab(db)
+
+def show_quick_sale_tab(db, whatsapp_manager):
+    """Show tab for quick sales with instant customer creation"""
+    st.subheader("🚀 Quick Sale - Create Customer & Sale in One Go")
+    
+    with st.form("quick_sale_form"):
+        # Customer Section - Quick Create
+        st.markdown("### 👥 Customer Information")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Option 1: Select existing customer
+            st.write("**Select Existing Customer**")
+            customers = db.get_dataframe('customers')
+            existing_customer_options = {f"{row['name']} ({row['mobile']})": row['customer_id'] 
+                                       for _, row in customers.iterrows()} if not customers.empty else {}
+            
+            use_existing = st.selectbox("Choose Customer", 
+                                      options=[""] + list(existing_customer_options.keys()),
+                                      key="existing_customer")
+            
+            if use_existing:
+                customer_id = existing_customer_options[use_existing]
+                # Get customer details for display
+                customer_details = customers[customers['customer_id'] == customer_id].iloc[0]
+                st.success(f"Selected: {customer_details['name']} - {customer_details['mobile']}")
+            else:
+                customer_id = None
+        
+        with col2:
+            # Option 2: Create new customer instantly
+            st.write("**Or Create New Customer**")
+            new_customer_name = st.text_input("Customer Name*", placeholder="Enter customer name")
+            new_customer_mobile = st.text_input("Mobile Number", placeholder="Enter mobile number")
+            new_customer_village = st.text_input("Village", placeholder="Enter village")
+            
+            if new_customer_name:
+                # Check if customer already exists
+                existing_customer = db.execute_query(
+                    "SELECT customer_id FROM customers WHERE name = ? OR mobile = ?",
+                    (new_customer_name, new_customer_mobile),
+                    log_action=False
+                )
+                
+                if existing_customer:
+                    st.warning("⚠️ Customer with same name/mobile already exists!")
+                    customer_id = existing_customer[0][0]
+                else:
+                    customer_id = None  # Will create during sale submission
+        
+        # Sale Information
+        st.markdown("### 📄 Sale Information")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            invoice_no = st.text_input("Invoice Number*", value=db.generate_invoice_number())
+        with col2:
+            sale_date = st.date_input("Sale Date", datetime.now())
+        
+        # Products Section with Smart Pricing
+        st.markdown("### 📦 Add Products")
+        
+        products = db.get_dataframe('products')
+        if products.empty:
+            st.error("❌ No products found in database. Please add products first.")
+            return
+        
+        product_options = {row['product_name']: {
+            'product_id': row['product_id'],
+            'standard_rate': row['standard_rate'],
+            'packing_type': row['packing_type'],
+            'capacity_ltr': row['capacity_ltr']
+        } for _, row in products.iterrows()}
+        
+        sale_items = []
+        total_amount = 0
+        
+        # Create 3 product rows
+        for i in range(3):
+            st.markdown(f"**Product {i+1}**")
+            col1, col2, col3, col4, col5 = st.columns([3, 1, 2, 2, 1])
+            
+            with col1:
+                selected_product = st.selectbox(f"Select Product", 
+                                              options=[""] + list(product_options.keys()),
+                                              key=f"product_{i}")
+            
+            with col2:
+                quantity = st.number_input(f"Qty", min_value=0, value=0, key=f"qty_{i}")
+            
+            with col3:
+                if selected_product:
+                    default_rate = product_options[selected_product]['standard_rate']
+                    rate = st.number_input(f"Rate (₹)", min_value=0.0, value=float(default_rate), 
+                                         step=1.0, key=f"rate_{i}")
+                    # Show discount indicator if rate is changed
+                    if rate < default_rate:
+                        discount = ((default_rate - rate) / default_rate) * 100
+                        st.info(f"🎯 {discount:.1f}% off")
+                else:
+                    rate = st.number_input(f"Rate (₹)", min_value=0.0, value=0.0, key=f"rate_{i}")
+            
+            with col4:
+                if selected_product and quantity > 0:
+                    amount = quantity * rate
+                    st.metric("Amount", f"₹{amount:,.2f}")
+                else:
+                    amount = 0
+                    st.metric("Amount", "₹0")
+            
+            with col5:
+                if selected_product and quantity > 0:
+                    product_info = product_options[selected_product]
+                    st.write(f"*{product_info['packing_type']}*")
+                    if product_info['capacity_ltr'] > 0:
+                        st.write(f"{product_info['capacity_ltr']}L")
+            
+            if selected_product and quantity > 0:
+                sale_items.append({
+                    'product_id': product_options[selected_product]['product_id'],
+                    'product_name': selected_product,
+                    'quantity': quantity,
+                    'rate': rate,
+                    'amount': amount,
+                    'standard_rate': product_options[selected_product]['standard_rate']
+                })
+                total_amount += amount
+        
+        # Show running total
+        if total_amount > 0:
+            st.success(f"### 🎯 Running Total: ₹{total_amount:,.2f}")
+        
+        # Additional Options
+        st.markdown("### ⚙️ Additional Options")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            notes = st.text_area("Sale Notes", placeholder="Any special notes about this sale...")
+        
+        with col2:
+            # WhatsApp Notification Options
+            st.write("**📱 Customer Notification**")
+            send_whatsapp = st.checkbox("Send WhatsApp Notification", value=True)
+            if send_whatsapp and not whatsapp_manager:
+                st.warning("WhatsApp manager not available")
+            
+            # Payment options
+            payment_received = st.checkbox("Payment Received", value=False)
+            if payment_received:
+                payment_amount = st.number_input("Payment Amount", min_value=0.0, value=float(total_amount))
+                payment_method = st.selectbox("Payment Method", ["Cash", "G-Pay", "Cheque", "Bank Transfer"])
+        
+        # Submit Section
+        st.markdown("---")
+        submitted = st.form_submit_button("🚀 Create Sale & Notify Customer", type="primary")
+        
+        if submitted:
+            # Validation
+            errors = []
+            
+            if not customer_id and not new_customer_name:
+                errors.append("Please select a customer or enter new customer name")
+            if not invoice_no:
+                errors.append("Invoice number is required")
+            if not sale_items:
+                errors.append("Please add at least one product")
+            
+            if errors:
+                for error in errors:
+                    st.error(error)
+            else:
+                try:
+                    # Create customer if new
+                    if not customer_id and new_customer_name:
+                        customer_id = db.add_customer(
+                            name=new_customer_name,
+                            mobile=new_customer_mobile,
+                            village=new_customer_village
+                        )
+                        if customer_id and customer_id > 0:
+                            st.success(f"✅ New customer created: {new_customer_name}")
+                    
+                    if customer_id:
+                        # Create sale
+                        sale_id = db.add_sale(
+                            invoice_no=invoice_no,
+                            customer_id=customer_id,
+                            sale_date=sale_date,
+                            items=sale_items,
+                            notes=notes
+                        )
+                        
+                        if sale_id and sale_id > 0:
+                            st.success(f"✅ Sale created successfully! Sale ID: {sale_id}")
+                            
+                            # Add payment if received
+                            if payment_received:
+                                db.execute_query('''
+                                INSERT INTO payments (sale_id, payment_date, payment_method, amount)
+                                VALUES (?, ?, ?, ?)
+                                ''', (sale_id, sale_date, payment_method, payment_amount))
+                                st.success(f"✅ Payment recorded: ₹{payment_amount:,.2f}")
+                            
+                            # Send WhatsApp notification
+                            if send_whatsapp and whatsapp_manager:
+                                send_sale_notification(whatsapp_manager, db, sale_id, customer_id)
+                            
+                            # Show sale summary
+                            show_quick_sale_summary(db, sale_id, sale_items, customer_id)
+                            
+                            # Clear form for next sale
+                            if st.button("🔄 Create Another Sale"):
+                                st.rerun()
+                        else:
+                            st.error("❌ Failed to create sale.")
+                    
+                except Exception as e:
+                    st.error(f"Error creating sale: {e}")
+
+def send_sale_notification(whatsapp_manager, db, sale_id, customer_id):
+    """Send WhatsApp notification to customer about their sale"""
+    try:
+        # Get sale and customer details
+        sale_details = db.get_dataframe('sales', f"SELECT * FROM sales WHERE sale_id = {sale_id}")
+        customer_details = db.get_dataframe('customers', f"SELECT * FROM customers WHERE customer_id = {customer_id}")
+        
+        if sale_details.empty or customer_details.empty:
+            return False
+        
+        sale = sale_details.iloc[0]
+        customer = customer_details.iloc[0]
+        
+        # Get sale items
+        items_details = db.get_dataframe('sale_items', f'''
+        SELECT si.*, p.product_name 
+        FROM sale_items si 
+        JOIN products p ON si.product_id = p.product_id 
+        WHERE si.sale_id = {sale_id}
+        ''')
+        
+        if customer.get('mobile'):
+            # Create notification message
+            message = f"""Hello {customer['name']}! 🎉
+
+Thank you for your purchase! 
+
+📄 Invoice: {sale['invoice_no']}
+📅 Date: {sale['sale_date']}
+💰 Total Amount: ₹{sale['total_amount']:,.2f}
+
+📦 Items Purchased:
+"""
+            
+            # Add items to message
+            for _, item in items_details.iterrows():
+                message += f"• {item['product_name']}: {item['quantity']} x ₹{item['rate']} = ₹{item['amount']}\n"
+            
+            message += f"""
+
+Payment Status: {sale['payment_status']}
+
+We appreciate your business! 🙏
+
+For any queries, contact us.
+
+Thank you!"""
+            
+            # Send message
+            success = whatsapp_manager.send_message(customer['mobile'], message)
+            if success:
+                st.success("📱 WhatsApp notification sent to customer!")
+            else:
+                st.warning("⚠️ Failed to send WhatsApp notification")
+            
+            return success
+    
+    except Exception as e:
+        st.warning(f"Could not send notification: {e}")
+        return False
+
+def show_quick_sale_summary(db, sale_id, sale_items, customer_id):
+    """Show comprehensive sale summary"""
+    st.markdown("## 🎉 Sale Completed Successfully!")
+    
+    try:
+        # Get sale and customer details
+        sale_details = db.get_dataframe('sales', f"SELECT * FROM sales WHERE sale_id = {sale_id}")
+        customer_details = db.get_dataframe('customers', f"SELECT * FROM customers WHERE customer_id = {customer_id}")
+        
+        if sale_details.empty or customer_details.empty:
+            return
+        
+        sale = sale_details.iloc[0]
+        customer = customer_details.iloc[0]
+        
+        # Display in columns
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Customer Details")
+            st.write(f"**Name:** {customer['name']}")
+            if customer['mobile']:
+                st.write(f"**Mobile:** {customer['mobile']}")
+            if customer['village']:
+                st.write(f"**Village:** {customer['village']}")
+            
+            st.subheader("Sale Details")
+            st.write(f"**Invoice No:** {sale['invoice_no']}")
+            st.write(f"**Sale Date:** {sale['sale_date']}")
+            st.write(f"**Payment Status:** {sale['payment_status']}")
+            if sale['notes']:
+                st.write(f"**Notes:** {sale['notes']}")
+        
+        with col2:
+            st.subheader("Financial Summary")
+            st.metric("Total Amount", f"₹{sale['total_amount']:,.2f}")
+            
+            # Get payment details
+            payment_details = db.get_dataframe('payments', f"SELECT * FROM payments WHERE sale_id = {sale_id}")
+            if not payment_details.empty:
+                total_paid = payment_details['amount'].sum()
+                pending = sale['total_amount'] - total_paid
+                st.metric("Amount Paid", f"₹{total_paid:,.2f}")
+                st.metric("Pending Amount", f"₹{pending:,.2f}")
+            
+            st.subheader("Items Summary")
+            for item in sale_items:
+                st.write(f"• {item['product_name']}: {item['quantity']} x ₹{item['rate']}")
+        
+        # Quick actions
+        st.markdown("### ⚡ Quick Actions")
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            if st.button("📋 View All Sales"):
+                # This would switch to sales history tab in a real implementation
+                st.info("Navigate to Sales History tab")
+        
+        with col2:
+            if st.button("👥 View Customer"):
+                st.info(f"Customer: {customer['name']}")
+        
+        with col3:
+            if st.button("💳 Record Payment"):
+                st.info("Use Payments page to record additional payments")
+    
+    except Exception as e:
+        st.error(f"Error displaying sale summary: {e}")
+
+def show_sales_history_tab(db):
+    """Show tab for sales history and management"""
+    st.subheader("Sales History & Management")
+    
+    try:
+        # Quick filters
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            date_filter = st.selectbox("Date Filter", 
+                                     ["All", "Today", "Last 7 days", "This month", "Custom"])
+        
+        with col2:
+            status_filter = st.multiselect("Payment Status", 
+                                         ["Pending", "Partial", "Paid"], 
+                                         default=["Pending", "Partial", "Paid"])
+        
+        with col3:
+            search_term = st.text_input("Search Invoice/Customer")
+        
+        with col4:
+            show_rows = st.selectbox("Show", [10, 25, 50, 100], index=0)
+        
+        # Build query
+        query = '''
+        SELECT s.*, c.name as customer_name, c.village, c.mobile,
+               COALESCE(SUM(p.amount), 0) as paid_amount,
+               (s.total_amount - COALESCE(SUM(p.amount), 0)) as pending_amount
+        FROM sales s
+        LEFT JOIN customers c ON s.customer_id = c.customer_id
+        LEFT JOIN payments p ON s.sale_id = p.sale_id
+        '''
+        
+        conditions = []
+        if status_filter:
+            status_cond = " OR ".join([f"s.payment_status = '{status}'" for status in status_filter])
+            conditions.append(f"({status_cond})")
+        
+        if search_term:
+            conditions.append(f"(s.invoice_no LIKE '%{search_term}%' OR c.name LIKE '%{search_term}%')")
+        
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+        
+        query += " GROUP BY s.sale_id ORDER BY s.sale_date DESC LIMIT " + str(show_rows)
+        
+        # Get sales data
+        sales_data = db.get_dataframe('sales', query)
+        
+        if not sales_data.empty:
+            st.write(f"**Showing {len(sales_data)} sales**")
+            
+            # Enhanced display
+            display_df = sales_data[['invoice_no', 'sale_date', 'customer_name', 'village', 
+                                   'total_amount', 'paid_amount', 'pending_amount', 'payment_status']].copy()
+            
+            # Formatting
+            display_df['total_amount'] = display_df['total_amount'].apply(lambda x: f"₹{x:,.2f}")
+            display_df['paid_amount'] = display_df['paid_amount'].apply(lambda x: f"₹{x:,.2f}")
+            display_df['pending_amount'] = display_df['pending_amount'].apply(lambda x: f"₹{x:,.2f}")
+            
+            display_df.columns = ['Invoice', 'Date', 'Customer', 'Village', 'Total', 'Paid', 'Pending', 'Status']
+            
+            st.dataframe(display_df, use_container_width=True)
+            
+            # Summary metrics
+            total_sales = sales_data['total_amount'].sum()
+            total_pending = sales_data['pending_amount'].sum()
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total Sales Value", f"₹{total_sales:,.2f}")
+            with col2:
+                st.metric("Total Pending", f"₹{total_pending:,.2f}")
+            with col3:
+                if total_sales > 0:
+                    collection_rate = ((total_sales - total_pending) / total_sales) * 100
+                    st.metric("Collection Rate", f"{collection_rate:.1f}%")
+        
+        else:
+            st.info("No sales found matching the current filters.")
+    
+    except Exception as e:
+        st.error(f"Error loading sales history: {e}")
+
+def show_sales_analytics_tab(db):
+    """Show tab for sales analytics"""
+    st.subheader("Sales Analytics & Insights")
+    
+    try:
+        # Date range
+        col1, col2 = st.columns(2)
+        with col1:
+            start_date = st.date_input("Start Date", datetime.now() - timedelta(days=30))
+        with col2:
+            end_date = st.date_input("End Date", datetime.now())
+        
+        if start_date > end_date:
+            st.error("Start date cannot be after end date")
+            return
+        
+        # Get analytics
+        analytics = db.get_sales_analytics(start_date.strftime('%Y-%m-%d'), 
+                                         end_date.strftime('%Y-%m-%d'))
+        
+        if analytics:
+            # Key metrics
+            st.subheader("📈 Performance Metrics")
+            cols = st.columns(4)
+            metrics = [
+                ("Total Sales", analytics.get('total_sales', 0), "💰"),
+                ("Total Revenue", f"₹{analytics.get('total_revenue', 0):,.2f}", "💵"),
+                ("Avg Sale", f"₹{analytics.get('avg_sale_value', 0):,.2f}", "📊"),
+                ("Unique Customers", analytics.get('unique_customers', 0), "👥")
+            ]
+            
+            for col, (label, value, icon) in zip(cols, metrics):
+                with col:
+                    st.metric(label, value)
+        
+        # Additional analytics can be added here
+        
+    except Exception as e:
+        st.error(f"Error loading analytics: {e}")

pages/system_dashboard.py

@@ -0,0 +1,137 @@
+# pages/system_dashboard.py
+import streamlit as st
+from utils.styling import create_metric_card, COLORS
+import plotly.express as px
+from datetime import datetime
+
+
+def create_dashboard(db, analytics):
+    """Create the main dashboard with metrics and charts"""
+    st.markdown("<h1 class='main-header'>📊 Sales Dashboard</h1>", unsafe_allow_html=True)
+
+    # One-time notification after scheduling a demo
+    if st.session_state.get("demo_created_notification"):
+        st.success(f"✅ Demo #{st.session_state.demo_created_notification} added successfully!")
+        st.session_state.demo_created_notification = None
+
+    if not analytics or not db:
+        st.error("Analytics or Database not available.")
+        return
+
+    # Fetch analytics safely
+    try:
+        sales_summary = analytics.get_sales_summary()
+        demo_stats = analytics.get_demo_conversion_rates()
+        customer_analysis = analytics.get_customer_analysis()
+        payment_analysis = analytics.get_payment_analysis()
+    except Exception:
+        sales_summary = {"total_sales": 0, "pending_amount": 0}
+        demo_stats = {"conversion_rate": 0}
+        customer_analysis = {"total_customers": 0}
+        payment_analysis = {"total_pending": 0}
+
+    # ------------------- METRICS ROW -------------------
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.markdown(create_metric_card(f"₹{sales_summary['total_sales']:,.0f}", "Total Sales", "💰", COLORS["primary"]), unsafe_allow_html=True)
+
+    with col2:
+        st.markdown(create_metric_card(f"₹{sales_summary['pending_amount']:,.0f}", "Pending Payments", "⏳", COLORS["warning"]), unsafe_allow_html=True)
+
+    with col3:
+        st.markdown(create_metric_card(f"{demo_stats['conversion_rate']:.1f}%", "Demo Conversion", "🎯", COLORS["success"]), unsafe_allow_html=True)
+
+    with col4:
+        st.markdown(create_metric_card(f"{customer_analysis['total_customers']}", "Total Customers", "👥", COLORS["secondary"]), unsafe_allow_html=True)
+
+    # ------------------- SALES TREND + PAYMENT CHARTS -------------------
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("<h3 class='section-header'>Sales Trend</h3>", unsafe_allow_html=True)
+        try:
+            sales_trend = analytics.get_sales_trend()
+            if not sales_trend.empty:
+                fig = px.line(
+                    sales_trend,
+                    x="sale_date",
+                    y="total_amount",
+                    title="Daily Sales Trend",
+                    color_discrete_sequence=[COLORS["primary"]],
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("No sales data available.")
+        except Exception:
+            st.info("Error loading sales trend.")
+
+    with col2:
+        st.markdown("<h3 class='section-header'>Payment Status</h3>", unsafe_allow_html=True)
+        try:
+            payment_data = analytics.get_payment_distribution()
+            if not payment_data.empty:
+                fig = px.pie(
+                    payment_data,
+                    values="amount",
+                    names="payment_method",
+                    title="Payment Methods Distribution",
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("No payment data available.")
+        except Exception:
+            st.info("Error loading payment distribution.")
+
+    # ------------------- RECENT SALES + UPCOMING DEMOS -------------------
+    col1, col2 = st.columns(2)
+
+    # Recent Sales
+    with col1:
+        st.markdown("<h3 class='section-header'>Recent Sales</h3>", unsafe_allow_html=True)
+        recent_sales = db.get_dataframe(
+            "sales",
+            """
+            SELECT s.invoice_no, c.name AS customer_name, c.village,
+                   s.total_amount, s.sale_date
+            FROM sales s
+            JOIN customers c ON s.customer_id = c.customer_id
+            ORDER BY s.created_date DESC LIMIT 8
+            """,
+        )
+        if not recent_sales.empty:
+            st.dataframe(recent_sales, use_container_width=True, hide_index=True)
+        else:
+            st.info("No recent sales.")
+
+    # Upcoming Demos
+    with col2:
+        st.markdown("<h3 class='section-header'>Upcoming Demos</h3>", unsafe_allow_html=True)
+
+        upcoming_demos = db.get_dataframe(
+            "demos",
+            """
+            SELECT d.demo_id, c.name AS customer_name, c.village,
+                   p.product_name, d.demo_date, d.demo_time
+            FROM demos d
+            LEFT JOIN customers c ON d.customer_id = c.customer_id
+            LEFT JOIN products p ON d.product_id = p.product_id
+            WHERE date(d.demo_date) >= date('now')
+            AND LOWER(TRIM(d.conversion_status)) = 'scheduled'
+            ORDER BY d.demo_date ASC, d.demo_time ASC
+            LIMIT 8
+            """,
+        )
+
+        if not upcoming_demos.empty:
+            upcoming_demos.columns = ["Demo ID", "Customer", "Village", "Product", "Date", "Time"]
+            st.dataframe(upcoming_demos, use_container_width=True, hide_index=True)
+
+            if st.button("📋 View All Demos"):
+                st.session_state.current_page = "demos"
+                st.rerun()
+        else:
+            st.warning("⚠️ No upcoming demos scheduled.")
+            if st.button("➕ Schedule a Demo"):
+                st.session_state.current_page = "demos"
+                st.rerun()

pages/whatsapp.py

@@ -0,0 +1,68 @@
+# pages/whatsapp.py
+import streamlit as st
+import pandas as pd
+
+def show_whatsapp_page(db, whatsapp_manager):
+    """Show WhatsApp messaging page"""
+    st.title("💬 WhatsApp Messaging")
+    
+    if not whatsapp_manager:
+        st.error("WhatsApp manager not available. Please install pywhatkit: pip install pywhatkit")
+        st.info("""
+        **To enable WhatsApp messaging:**
+        1. Install: `pip install pywhatkit`
+        2. Make sure you're logged into WhatsApp Web in your default browser
+        3. Ensure phone numbers include country code (e.g., +91 for India)
+        """)
+    else:
+        tab1, tab2, tab3, tab4 = st.tabs(["Single Message", "Bulk Messages", "Templates", "Message History"])
+        
+        with tab1:
+            show_single_message_tab(db, whatsapp_manager)
+        
+        with tab2:
+            show_bulk_messages_tab(db, whatsapp_manager)
+        
+        with tab3:
+            show_templates_tab()
+        
+        with tab4:
+            show_message_history_tab(db)
+
+def show_single_message_tab(db, whatsapp_manager):
+    """Show single message tab"""
+    st.subheader("📱 Send Single Message")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Option 1: Select from existing customers
+        st.write("**Select from Existing Customers**")
+        customers = db.get_dataframe('customers')
+        if not customers.empty:
+            customer_options = {f"{row['name']} ({row['mobile']}) - {row['village']}": row for _, row in customers.iterrows()}
+            selected_customer_key = st.selectbox("Choose Customer", options=[""] + list(customer_options.keys()))
+            
+            if selected_customer_key:
+                customer_data = customer_options[selected_customer_key]
+                st.write(f"**Selected:** {customer_data['name']}")
+                st.write(f"**Mobile:** {customer_data['mobile']}")
+                st.write(f"**Village:** {customer_data['village']}")
+                
+                # Pre-fill message with template
+                message_template = st.selectbox("Quick Template", [
+                    "Custom Message",
+                    "Payment Reminder",
+                    "Demo Follow-up", 
+                    "New Product Announcement",
+                    "Festival Greeting"
+                ])
+                
+    with col2:
+        # Option 2: Manual entry
+        st.write("**Or Enter Manually**")
+        manual_name = st.text_input("Recipient Name")
+        manual_mobile = st.text_input("Mobile Number (with country code)", placeholder="+91XXXXXXXXXX")
+    
+    # Message content and sending logic would continue here...
+    # (I'll show the rest in the next message due to length)