Initial commit

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")

analytics.py

@@ -0,0 +1,192 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+class Analytics:
+    def __init__(self, db_manager):
+        self.db = db_manager
+    
+    def get_sales_summary(self):
+        """Get comprehensive sales summary statistics"""
+        try:
+            sales_df = self.db.get_dataframe('sales')
+            payments_df = self.db.get_dataframe('payments')
+            
+            if sales_df.empty:
+                return {
+                    'total_sales': 0,
+                    'total_payments': 0,
+                    'pending_amount': 0,
+                    'total_transactions': 0,
+                    'avg_sale_value': 0
+                }
+            
+            total_sales = sales_df['total_amount'].sum()
+            total_payments = payments_df['amount'].sum() if not payments_df.empty else 0
+            pending_amount = total_sales - total_payments
+            
+            return {
+                'total_sales': total_sales,
+                'total_payments': total_payments,
+                'pending_amount': pending_amount,
+                'total_transactions': len(sales_df),
+                'avg_sale_value': sales_df['total_amount'].mean()
+            }
+        except Exception as e:
+            return {
+                'total_sales': 0,
+                'total_payments': 0,
+                'pending_amount': 0,
+                'total_transactions': 0,
+                'avg_sale_value': 0
+            }
+    
+    def get_customer_analysis(self):
+        """Analyze customer data"""
+        try:
+            customers_df = self.db.get_dataframe('customers')
+            sales_df = self.db.get_dataframe('sales')
+            
+            if customers_df.empty:
+                return {
+                    'total_customers': 0,
+                    'village_distribution': {},
+                    'top_customers': {}
+                }
+            
+            # Customer distribution by village
+            village_stats = customers_df['village'].value_counts().head(10)
+            
+            # Top customers by spending
+            if not sales_df.empty:
+                customer_sales = sales_df.groupby('customer_id')['total_amount'].sum()
+                top_customers = customer_sales.nlargest(10)
+            else:
+                top_customers = pd.Series(dtype=float)
+            
+            return {
+                'total_customers': len(customers_df),
+                'village_distribution': village_stats.to_dict(),
+                'top_customers': top_customers.to_dict()
+            }
+        except Exception as e:
+            return {
+                'total_customers': 0,
+                'village_distribution': {},
+                'top_customers': {}
+            }
+    
+    def get_payment_analysis(self):
+        """Analyze payment data"""
+        try:
+            pending_payments = self.db.get_pending_payments()
+            payments_df = self.db.get_dataframe('payments')
+            
+            if pending_payments.empty:
+                return {
+                    'total_pending': 0,
+                    'customer_pending': {},
+                    'payment_methods': {}
+                }
+            
+            # Group by customer
+            customer_pending = pending_payments.groupby('customer_id')['pending_amount'].sum()
+            
+            # Payment method distribution
+            if not payments_df.empty:
+                payment_methods = payments_df['payment_method'].value_counts()
+            else:
+                payment_methods = pd.Series(dtype=object)
+            
+            return {
+                'total_pending': pending_payments['pending_amount'].sum(),
+                'customer_pending': customer_pending.to_dict(),
+                'payment_methods': payment_methods.to_dict()
+            }
+        except Exception as e:
+            return {
+                'total_pending': 0,
+                'customer_pending': {},
+                'payment_methods': {}
+            }
+    
+    def get_demo_conversion_rates(self):
+        """Calculate demo conversion rates"""
+        try:
+            demos_df = self.db.get_demo_conversions()
+            
+            if demos_df.empty:
+                return {
+                    'total_demos': 0,
+                    'converted_demos': 0,
+                    'conversion_rate': 0
+                }
+            
+            total_demos = len(demos_df)
+            converted_demos = len(demos_df[demos_df['conversion_status'] == 'Converted'])
+            conversion_rate = (converted_demos / total_demos) * 100 if total_demos > 0 else 0
+            
+            return {
+                'total_demos': total_demos,
+                'converted_demos': converted_demos,
+                'conversion_rate': conversion_rate
+            }
+        except Exception as e:
+            return {
+                'total_demos': 0,
+                'converted_demos': 0,
+                'conversion_rate': 0
+            }
+    
+    def get_sales_trend(self):
+        """Get sales trend data for charts"""
+        try:
+            sales_df = self.db.get_dataframe('sales')
+            
+            if sales_df.empty:
+                return pd.DataFrame()
+            
+            # Convert sale_date to datetime if it's not
+            sales_df['sale_date'] = pd.to_datetime(sales_df['sale_date'])
+            
+            # Group by date
+            daily_sales = sales_df.groupby('sale_date')['total_amount'].sum().reset_index()
+            daily_sales = daily_sales.sort_values('sale_date')
+            
+            return daily_sales
+        except Exception as e:
+            return pd.DataFrame()
+    
+    def get_payment_distribution(self):
+        """Get payment distribution for charts"""
+        try:
+            payments_df = self.db.get_dataframe('payments')
+            
+            if payments_df.empty:
+                return pd.DataFrame()
+            
+            payment_dist = payments_df.groupby('payment_method')['amount'].sum().reset_index()
+            return payment_dist
+        except Exception as e:
+            return pd.DataFrame()
+    
+    def get_product_performance(self):
+        """Get product performance data"""
+        try:
+            sale_items_df = self.db.get_dataframe('sale_items', '''
+            SELECT si.*, p.product_name 
+            FROM sale_items si 
+            JOIN products p ON si.product_id = p.product_id
+            ''')
+            
+            if sale_items_df.empty:
+                return pd.DataFrame()
+            
+            product_perf = sale_items_df.groupby('product_name').agg({
+                'quantity': 'sum',
+                'amount': 'sum'
+            }).reset_index()
+            
+            return product_perf
+        except Exception as e:
+            return pd.DataFrame()

automation.py

@@ -0,0 +1,88 @@
+# enhanced_automation.py
+import schedule
+import time
+import smtplib
+from email.mime.text import MimeText
+from email.mime.multipart import MimeMultipart
+from datetime import datetime, timedelta
+
+class AutomationManager:
+    def __init__(self, db_manager, whatsapp_manager):
+        self.db = db_manager
+        self.whatsapp = whatsapp_manager
+    
+    def daily_payment_reminders(self):
+        """Send payment reminders for overdue payments"""
+        overdue_payments = self.db.get_pending_payments()
+        
+        for _, payment in overdue_payments.iterrows():
+            if payment['pending_amount'] > 0:
+                customer = self.db.get_dataframe('customers', 
+                    f"SELECT * FROM customers WHERE customer_id = {payment['customer_id']}")
+                
+                if not customer.empty:
+                    customer_data = customer.iloc[0]
+                    message = f"""Hello {customer_data['name']},
+
+This is a friendly reminder that your payment of ₹{payment['pending_amount']:,.2f} for invoice {payment['invoice_no']} is overdue.
+
+Please make the payment at your earliest convenience.
+
+Thank you,
+Sales Team"""
+                    
+                    self.whatsapp.send_message(customer_data['mobile'], message)
+    
+    def demo_followups(self):
+        """Send follow-up messages for demos"""
+        upcoming_followups = self.db.get_dataframe('demos', '''
+        SELECT d.*, c.name as customer_name, c.mobile, p.product_name
+        FROM demos d
+        JOIN customers c ON d.customer_id = c.customer_id
+        JOIN products p ON d.product_id = p.product_id
+        WHERE d.follow_up_date = date('now')
+        AND d.conversion_status = 'Not Converted'
+        ''')
+        
+        for _, demo in upcoming_followups.iterrows():
+            message = f"""Hello {demo['customer_name']},
+
+Following up on your demo of {demo['product_name']} on {demo['demo_date']}. 
+
+How was your experience? Would you like to place an order or need another demo?
+
+Best regards,
+Sales Team"""
+            
+            self.whatsapp.send_message(demo['mobile'], message)
+    
+    def weekly_performance_report(self):
+        """Generate and send weekly performance report"""
+        analytics = Analytics(self.db)
+        
+        sales_summary = analytics.get_sales_summary()
+        demo_stats = analytics.get_demo_conversion_rates()
+        payment_analysis = analytics.get_payment_analysis()
+        
+        report = f"""
+        📊 WEEKLY PERFORMANCE REPORT
+        ----------------------------
+        Total Sales: ₹{sales_summary.get('total_sales', 0):,.2f}
+        Pending Payments: ₹{sales_summary.get('pending_amount', 0):,.2f}
+        Demo Conversion Rate: {demo_stats.get('conversion_rate', 0):.1f}%
+        Total Customers: {analytics.get_customer_analysis().get('total_customers', 0)}
+        
+        Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M')}
+        """
+        
+        # You can extend this to email the report
+        self._save_report(report)
+        return report
+    
+    def _save_report(self, report):
+        """Save report to file"""
+        filename = f"reports/weekly_report_{datetime.now().strftime('%Y%m%d')}.txt"
+        os.makedirs('reports', exist_ok=True)
+        
+        with open(filename, 'w') as f:
+            f.write(report)

components/database_status.py

@@ -0,0 +1,26 @@
+# components/database_status.py
+import streamlit as st
+
+def show_database_status(db):
+    """Show current database status"""
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("📊 Database Status")
+    
+    try:
+        if db:
+            customers_count = len(db.get_dataframe('customers'))
+            sales_count = len(db.get_dataframe('sales'))
+            distributors_count = len(db.get_dataframe('distributors'))
+            payments_count = len(db.get_dataframe('payments'))
+            products_count = len(db.get_dataframe('products'))
+            
+            st.sidebar.metric("👥 Customers", customers_count)
+            st.sidebar.metric("💰 Sales", sales_count)
+            st.sidebar.metric("🤝 Distributors", distributors_count)
+            st.sidebar.metric("💳 Payments", payments_count)
+            st.sidebar.metric("📦 Products", products_count)
+        else:
+            st.sidebar.error("Database not available")
+            
+    except Exception as e:
+        st.sidebar.error("Database connection issue")

data_processor.py

@@ -0,0 +1,710 @@
+import pandas as pd
+import numpy as np
+import os
+import re
+from datetime import datetime
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DataProcessor:
+    def __init__(self, db_manager):
+        self.db = db_manager
+        self.product_mapping = self._create_product_mapping()
+    
+    def _create_product_mapping(self):
+        """Create product mapping from database"""
+        try:
+            products_df = self.db.get_dataframe('products')
+            return {row['product_name'].upper(): row['product_id'] for _, row in products_df.iterrows()}
+        except Exception as e:
+            logger.error(f"Error creating product mapping: {e}")
+            return {}
+    
+    def process_excel_file(self, file_path):
+        """Enhanced file processing with all data types"""
+        try:
+            file_name = os.path.basename(file_path)
+            print(f"🚀 Processing file: {file_name}")
+            
+            excel_file = pd.ExcelFile(file_path)
+            processed_sheets = 0
+            
+            for sheet_name in excel_file.sheet_names:
+                df = pd.read_excel(file_path, sheet_name=sheet_name)
+                df_clean = self._clean_dataframe(df)
+                
+                print(f"\n📊 Sheet: {sheet_name}")
+                print(f"   Columns: {df_clean.columns.tolist()}")
+                
+                # Check all types with priority
+                is_payment = self._is_payment_sheet(df_clean)
+                is_sales = self._is_sales_sheet(df_clean)
+                is_customer = self._is_customer_sheet(df_clean)
+                is_distributor = self._is_distributor_sheet(df_clean)
+                
+                print(f"   Detection - Payment: {is_payment}, Sales: {is_sales}, Customer: {is_customer}, Distributor: {is_distributor}")
+                
+                processed = False
+                if is_payment:
+                    processed = self.process_payment_sheet(df_clean, file_name, sheet_name)
+                elif is_sales:
+                    processed = self.process_sales_sheet(df_clean, file_name, sheet_name)
+                elif is_distributor:
+                    processed = self.process_distributor_sheet(df_clean, file_name, sheet_name)
+                elif is_customer:
+                    processed = self.process_customer_sheet(df_clean, file_name, sheet_name)
+                
+                if processed:
+                    processed_sheets += 1
+                    print(f"   ✅ Successfully processed as detected type")
+                else:
+                    print(f"   ❌ Failed to process")
+            
+            print(f"\n🎉 File processing complete: {processed_sheets}/{len(excel_file.sheet_names)} sheets processed")
+            return processed_sheets > 0
+            
+        except Exception as e:
+            print(f"💥 Error processing file {file_path}: {e}")
+            return False
+    
+    def _clean_dataframe(self, df):
+        """Clean and prepare dataframe for processing"""
+        # Remove completely empty rows and columns
+        df = df.dropna(how='all').dropna(axis=1, how='all')
+        
+        # Reset index
+        df = df.reset_index(drop=True)
+        
+        # Convert column names to string and clean them
+        df.columns = [str(col).strip().upper() for col in df.columns]
+        
+        return df
+    
+    def _is_sales_sheet(self, df):
+        """Check if sheet contains sales data"""
+        required_columns = ['INVOICE', 'CUSTOMER', 'PRODUCT', 'QUANTITY', 'AMOUNT']
+        existing_columns = [col for col in df.columns if any(req in col for req in required_columns)]
+        return len(existing_columns) >= 3
+    
+    def _is_customer_sheet(self, df):
+        """Check if sheet contains customer data"""
+        required_columns = ['CUSTOMER', 'NAME', 'MOBILE', 'VILLAGE']
+        existing_columns = [col for col in df.columns if any(req in col for req in required_columns)]
+        return len(existing_columns) >= 2
+    
+    def _is_distributor_sheet(self, df):
+        """Check if sheet contains distributor data"""
+        required_columns = ['DISTRIBUTOR', 'MANTRI', 'SABHASAD']
+        existing_columns = [col for col in df.columns if any(req in col for req in required_columns)]
+        return len(existing_columns) >= 2
+    
+    def process_sales_sheet(self, df, file_name, sheet_name):
+        """Process sales data from sheet"""
+        try:
+            processed_rows = 0
+            
+            for index, row in df.iterrows():
+                try:
+                    # Skip header rows and empty rows
+                    if self._is_header_row(row) or pd.isna(row.iloc[0]):
+                        continue
+                    
+                    # Extract sales data (adjust column indices based on your Excel structure)
+                    invoice_no = str(row.iloc[0]) if len(row) > 0 else f"INV_{datetime.now().strftime('%Y%m%d%H%M%S')}_{index}"
+                    customer_name = str(row.iloc[1]) if len(row) > 1 else "Unknown Customer"
+                    product_name = str(row.iloc[2]) if len(row) > 2 else "Unknown Product"
+                    quantity = self._safe_float(row.iloc[3]) if len(row) > 3 else 0
+                    amount = self._safe_float(row.iloc[4]) if len(row) > 4 else 0
+                    
+                    # Get or create customer
+                    customer_id = self._get_or_create_customer(customer_name, "", "", "", "")
+                    
+                    # Get product ID
+                    product_id = self._get_product_id(product_name)
+                    
+                    if customer_id and product_id and quantity > 0:
+                        # Create sale
+                        sale_date = datetime.now().date()
+                        sale_items = [{
+                            'product_id': product_id,
+                            'quantity': quantity,
+                            'rate': amount / quantity if quantity > 0 else 0
+                        }]
+                        
+                        self.db.add_sale(invoice_no, customer_id, sale_date, sale_items)
+                        processed_rows += 1
+                        
+                except Exception as e:
+                    logger.warning(f"Error processing row {index} in sales sheet: {e}")
+                    continue
+            
+            logger.info(f"Processed {processed_rows} sales from {sheet_name}")
+            return processed_rows > 0
+            
+        except Exception as e:
+            logger.error(f"Error processing sales sheet: {e}")
+            return False
+    
+    def process_customer_sheet(self, df, file_name, sheet_name):
+        """Process customer data from sheet with duplicate handling"""
+        try:
+            processed_rows = 0
+            duplicate_rows = 0
+            error_rows = 0
+            
+            print(f"🔄 Processing customer sheet: {sheet_name} with {len(df)} rows")
+            
+            for index, row in df.iterrows():
+                try:
+                    # Skip header rows and empty rows
+                    if self._is_header_row(row) or pd.isna(row.iloc[0]):
+                        continue
+                    
+                    # Extract customer data
+                    customer_code = str(row.iloc[0]) if len(row) > 0 and pd.notna(row.iloc[0]) else None
+                    name = str(row.iloc[1]) if len(row) > 1 and pd.notna(row.iloc[1]) else "Unknown"
+                    mobile = str(row.iloc[2]) if len(row) > 2 and pd.notna(row.iloc[2]) else ""
+                    
+                    # Extract location - adjust indices based on your Excel structure
+                    village = str(row.iloc[3]) if len(row) > 3 and pd.notna(row.iloc[3]) else ""
+                    taluka = str(row.iloc[4]) if len(row) > 4 and pd.notna(row.iloc[4]) else ""
+                    district = str(row.iloc[5]) if len(row) > 5 and pd.notna(row.iloc[5]) else ""
+                    
+                    # If village is combined with name, split them
+                    if not village and "(" in name:
+                        name_parts = name.split("(")
+                        if len(name_parts) > 1:
+                            name = name_parts[0].strip()
+                            village = name_parts[1].replace(")", "").strip()
+                    
+                    # Skip if no name
+                    if not name or name == "Unknown":
+                        continue
+                    
+                    # Add customer to database (method now handles duplicates)
+                    customer_id = self.db.add_customer(name, mobile, village, taluka, district, customer_code)
+                    
+                    if customer_id and customer_id != -1:
+                        processed_rows += 1
+                        if processed_rows % 50 == 0:  # Progress update
+                            print(f"📊 Processed {processed_rows} customers...")
+                    else:
+                        duplicate_rows += 1
+                        
+                except Exception as e:
+                    error_rows += 1
+                    if error_rows <= 5:  # Only log first few errors
+                        print(f"❌ Error in row {index}: {e}")
+                    continue
+            
+            print(f"🎉 Customer processing complete: {processed_rows} added, {duplicate_rows} duplicates, {error_rows} errors")
+            return processed_rows > 0
+            
+        except Exception as e:
+            print(f"💥 Error processing customer sheet: {e}")
+            return False
+    
+    def process_distributor_sheet(self, df, file_name, sheet_name):
+        """Process distributor data from sheet"""
+        try:
+            processed_rows = 0
+            
+            # Clean the dataframe - convert column names to consistent format
+            df.columns = [str(col).strip().upper() for col in df.columns]
+            print(f"DEBUG: Processing distributor sheet with columns: {df.columns.tolist()}")
+            
+            for index, row in df.iterrows():
+                try:
+                    # Skip header rows and empty rows
+                    if self._is_header_row(row) or pd.isna(row.iloc[0]):
+                        print(f"DEBUG: Skipping row {index} - header or empty")
+                        continue
+                    
+                    print(f"DEBUG: Processing row {index}")
+                    
+                    # Extract distributor data based on YOUR ACTUAL COLUMNS
+                    # Map your Excel columns to database fields
+                    name = self._extract_distributor_name(row)  # We'll use Village + Taluka as name
+                    village = self._safe_get(row, 'Village', 1)
+                    taluka = self._safe_get(row, 'Taluka', 2) 
+                    district = self._safe_get(row, 'District', 3)
+                    mantri_name = self._safe_get(row, 'Mantri_Name', 4)
+                    mantri_mobile = self._safe_get(row, 'Mantri_Mobile', 5)
+                    sabhasad_count = self._safe_get_int(row, 'Sabhasad', 6)
+                    contact_in_group = self._safe_get_int(row, 'Contact_In_Group', 7)
+                    
+                    print(f"DEBUG: Extracted - Village: {village}, Taluka: {taluka}, Mantri: {mantri_name}")
+                    
+                    # Validate we have essential data
+                    if not village or not taluka:
+                        print(f"DEBUG: Skipping - missing village or taluka")
+                        continue
+                    
+                    # Create distributor name from village + taluka
+                    if not name:
+                        name = f"{village} - {taluka}"
+                    
+                    # Add distributor to database with ALL fields
+                    self.db.execute_query('''
+                    INSERT OR REPLACE INTO distributors 
+                    (name, village, taluka, district, mantri_name, mantri_mobile, sabhasad_count, contact_in_group)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                    ''', (name, village, taluka, district, mantri_name, mantri_mobile, sabhasad_count, contact_in_group))
+                    
+                    processed_rows += 1
+                    print(f"DEBUG: Successfully added distributor: {name}")
+                    
+                except Exception as e:
+                    logger.warning(f"Error processing row {index} in distributor sheet: {e}")
+                    continue
+            
+            logger.info(f"Processed {processed_rows} distributors from {sheet_name}")
+            return processed_rows > 0
+            
+        except Exception as e:
+            logger.error(f"Error processing distributor sheet: {e}")
+            return False
+
+    def _extract_distributor_name(self, row):
+        """Extract distributor name from village and taluka"""
+        village = self._safe_get(row, 'Village', 1)
+        taluka = self._safe_get(row, 'Taluka', 2)
+        
+        if village and taluka:
+            return f"{village} - {taluka}"
+        elif village:
+            return village
+        elif taluka:
+            return taluka
+        else:
+            return "Unknown Distributor"
+
+    def _safe_get(self, row, column_name, default_index):
+        """Safely get value from row by column name or index"""
+        try:
+            # Try by column name first
+            if column_name in row.index:
+                value = row[column_name]
+                if pd.isna(value):
+                    return ""
+                return str(value).strip()
+            
+            # Fallback to index
+            if len(row) > default_index:
+                value = row.iloc[default_index]
+                if pd.isna(value):
+                    return ""
+                return str(value).strip()
+            
+            return ""
+        except Exception:
+            return ""
+
+    def _safe_get_int(self, row, column_name, default_index):
+        """Safely get integer value from row"""
+        try:
+            str_value = self._safe_get(row, column_name, default_index)
+            if str_value and str_value.strip():
+                return int(float(str_value))  # Handle both int and float strings
+            return 0
+        except (ValueError, TypeError):
+            return 0
+    
+    def _is_header_row(self, row):
+        """Check if row is a header row - updated for your data"""
+        if len(row) == 0:
+            return True
+            
+        first_value = str(row.iloc[0]) if pd.notna(row.iloc[0]) else ""
+        first_value_upper = first_value.upper()
+        
+        # Header indicators for YOUR data
+        header_indicators = [
+            'DATE', 'VILLAGE', 'TALUKA', 'DISTRICT', 'MANTRI', 
+            'SABHASAD', 'CONTACT', 'TOTAL', 'SR', 'NO', 'NAME'
+        ]
+        
+        # If first value contains any header indicator, it's likely a header
+        return any(indicator in first_value_upper for indicator in header_indicators)
+        
+    def _safe_float(self, value):
+        """Safely convert value to float"""
+        try:
+            if pd.isna(value):
+                return 0.0
+            return float(value)
+        except (ValueError, TypeError):
+            return 0.0
+    
+    def _get_or_create_customer(self, name, mobile, village, taluka, district):
+        """Get existing customer or create new one"""
+        try:
+            # Check if customer exists
+            result = self.db.execute_query(
+                'SELECT customer_id FROM customers WHERE name = ? AND mobile = ?', 
+                (name, mobile)
+            )
+            
+            if result:
+                return result[0][0]
+            else:
+                # Create new customer
+                customer_code = f"CUST_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+                self.db.add_customer(name, mobile, village, taluka, district, customer_code)
+                
+                # Get the new customer ID
+                result = self.db.execute_query(
+                    'SELECT customer_id FROM customers WHERE customer_code = ?', 
+                    (customer_code,)
+                )
+                return result[0][0] if result else None
+                
+        except Exception as e:
+            logger.error(f"Error getting/creating customer: {e}")
+            return None
+    
+    def _get_product_id(self, product_name):
+        """Get product ID from product name"""
+        clean_name = product_name.upper().strip()
+        return self.product_mapping.get(clean_name, None)
+    
+    def _extract_location_from_name(self, name):
+        """Extract village and taluka from customer name"""
+        name_upper = name.upper()
+        
+        locations = {
+            'AMIYAD': ('Amiyad', ''),
+            'AMVAD': ('Amvad', ''),
+            'ANKALAV': ('', 'Ankalav'),
+            'PETLAD': ('', 'Petlad'),
+            'BORSAD': ('', 'Borsad'),
+            'VADODARA': ('', 'Vadodara'),
+            'ANAND': ('', 'Anand'),
+            'NADIAD': ('', 'Nadiad')
+        }
+        
+        village, taluka = "", ""
+        for location, (v, t) in locations.items():
+            if location in name_upper:
+                if v: 
+                    village = v
+                if t: 
+                    taluka = t
+                break
+        
+        return village, taluka
+    
+
+
+    # Add to DataProcessor class in data_processor.py
+
+    def _is_sales_sheet(self, df):
+        """Enhanced sales sheet detection with better logging"""
+        columns_lower = [str(col).lower() for col in df.columns]
+        
+        print(f"\n🔍 ENHANCED SALES DETECTION:")
+        print(f"   All columns: {columns_lower}")
+        
+        sales_indicators = [
+            'invoice', 'sale', 'amount', 'product', 'quantity', 'rate', 
+            'total', 'price', 'bill', 'payment', 'item', 'qty'
+        ]
+        
+        found_indicators = []
+        for indicator in sales_indicators:
+            matching_cols = [col for col in columns_lower if indicator in col]
+            if matching_cols:
+                found_indicators.append((indicator, matching_cols))
+        
+        print(f"   Found sales indicators: {found_indicators}")
+        
+        score = len(found_indicators)
+        print(f"   Sales detection score: {score}")
+        
+        return score >= 2
+
+    def process_sales_sheet(self, df, file_name, sheet_name):
+        """Enhanced sales data processing with better logging"""
+        try:
+            processed_rows = 0
+            print(f"🔄 Processing sales sheet: {sheet_name} with {len(df)} rows")
+            
+            for index, row in df.iterrows():
+                try:
+                    # Skip header rows and empty rows
+                    if self._is_header_row(row) or pd.isna(row.iloc[0]):
+                        continue
+                    
+                    print(f"🔧 Processing row {index}")
+                    
+                    # Extract sales data with flexible column mapping
+                    invoice_no = self._extract_sales_value(row, 'invoice', 0, f"INV_{datetime.now().strftime('%Y%m%d%H%M%S')}_{index}")
+                    customer_name = self._extract_sales_value(row, 'customer', 1, "Unknown Customer")
+                    product_name = self._extract_sales_value(row, 'product', 2, "Unknown Product")
+                    quantity = self._safe_float(self._extract_sales_value(row, 'quantity', 3, 0))
+                    amount = self._safe_float(self._extract_sales_value(row, 'amount', 4, 0))
+                    
+                    print(f"   Extracted - Invoice: '{invoice_no}', Customer: '{customer_name}', Product: '{product_name}', Qty: {quantity}, Amount: {amount}")
+                    
+                    # Validate essential data
+                    if not customer_name or customer_name == "Unknown Customer":
+                        print(f"   ⚠️ Skipping - invalid customer name")
+                        continue
+                    
+                    if quantity <= 0:
+                        print(f"   ⚠️ Skipping - invalid quantity: {quantity}")
+                        continue
+                    
+                    if amount <= 0:
+                        print(f"   ⚠️ Skipping - invalid amount: {amount}")
+                        continue
+                    
+                    # Get or create customer
+                    customer_id = self._get_or_create_customer(customer_name, "", "", "", "")
+                    if not customer_id:
+                        print(f"   ⚠️ Skipping - could not get/create customer")
+                        continue
+                    
+                    # Get product ID
+                    product_id = self._get_product_id(product_name)
+                    if not product_id:
+                        print(f"   ⚠️ Skipping - product not found: '{product_name}'")
+                        print(f"   Available products: {list(self.product_mapping.keys())}")
+                        continue
+                    
+                    # Calculate rate
+                    rate = amount / quantity if quantity > 0 else 0
+                    
+                    # Create sale items
+                    sale_date = datetime.now().date()
+                    sale_items = [{
+                        'product_id': product_id,
+                        'quantity': quantity,
+                        'rate': rate
+                    }]
+                    
+                    # Generate proper invoice number
+                    if not invoice_no or invoice_no.startswith('INV_'):
+                        invoice_no = self.db.generate_invoice_number()
+                    
+                    print(f"   Creating sale - Customer ID: {customer_id}, Product ID: {product_id}")
+                    
+                    # Add sale to database
+                    sale_id = self.db.add_sale(invoice_no, customer_id, sale_date, sale_items)
+                    
+                    if sale_id and sale_id > 0:
+                        processed_rows += 1
+                        print(f"   ✅ Successfully created sale ID: {sale_id}")
+                    else:
+                        print(f"   ❌ Failed to create sale")
+                        
+                except Exception as e:
+                    print(f"   ❌ Error in row {index}: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    continue
+            
+            print(f"🎉 Processed {processed_rows} sales from {sheet_name}")
+            return processed_rows > 0
+            
+        except Exception as e:
+            print(f"💥 Error processing sales sheet: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+    def _extract_sales_value(self, row, field_name, default_index, default_value):
+        """Extract sales values with flexible column matching"""
+        # Try to find column by name
+        for col_name in row.index:
+            if field_name in str(col_name).lower():
+                value = row[col_name]
+                if pd.notna(value):
+                    return str(value).strip()
+        
+        # Fallback to index
+        if len(row) > default_index:
+            value = row.iloc[default_index]
+            if pd.notna(value):
+                return str(value).strip()
+        
+        return default_value
+
+    # Add to DataProcessor class
+
+    def _is_payment_sheet(self, df):
+        """Detect payment sheets"""
+        columns_lower = [str(col).lower() for col in df.columns]
+        
+        payment_indicators = [
+            'payment', 'paid', 'amount', 'invoice', 'date', 'method',
+            'cash', 'gpay', 'cheque', 'bank', 'rrn', 'reference'
+        ]
+        
+        score = sum(1 for indicator in payment_indicators 
+                    if any(indicator in col for col in columns_lower))
+        
+        print(f"🔍 Payment detection - Score: {score}, Columns: {columns_lower}")
+        return score >= 2
+
+    def process_payment_sheet(self, df, file_name, sheet_name):
+        """Process payment data from sheet"""
+        try:
+            processed_rows = 0
+            print(f"🔄 Processing payment sheet: {sheet_name}")
+            
+            for index, row in df.iterrows():
+                try:
+                    if self._is_header_row(row) or pd.isna(row.iloc[0]):
+                        continue
+                    
+                    # Extract payment data
+                    invoice_no = self._extract_sales_value(row, 'invoice', 0, "")
+                    amount = self._safe_float(self._extract_sales_value(row, 'amount', 1, 0))
+                    payment_date = self._extract_sales_value(row, 'date', 2, datetime.now().date())
+                    payment_method = self._extract_sales_value(row, 'method', 3, "Cash")
+                    
+                    if invoice_no and amount > 0:
+                        # Find sale by invoice number
+                        sale_result = self.db.execute_query(
+                            'SELECT sale_id FROM sales WHERE invoice_no = ?',
+                            (invoice_no,),
+                            log_action=False
+                        )
+                        
+                        if sale_result:
+                            sale_id = sale_result[0][0]
+                            
+                            # Add payment
+                            self.db.execute_query('''
+                            INSERT INTO payments (sale_id, payment_date, payment_method, amount)
+                            VALUES (?, ?, ?, ?)
+                            ''', (sale_id, payment_date, payment_method, amount))
+                            
+                            processed_rows += 1
+                            print(f"✅ Processed payment for invoice {invoice_no}")
+                    
+                except Exception as e:
+                    print(f"❌ Error processing payment row {index}: {e}")
+                    continue
+            
+            print(f"🎉 Processed {processed_rows} payments from {sheet_name}")
+            return processed_rows > 0
+            
+        except Exception as e:
+            print(f"💥 Error processing payment sheet: {e}")
+            return False
+
+
+    def _is_customer_sheet(self, df):
+        """Check if sheet contains customer data - IMPROVED"""
+        columns_lower = [str(col).lower() for col in df.columns]
+        
+        customer_indicators = [
+            'customer', 'name', 'mobile', 'phone', 'village', 'taluka', 
+            'district', 'code', 'contact'
+        ]
+        
+        score = sum(1 for indicator in customer_indicators 
+                if any(indicator in col for col in columns_lower))
+        
+        print(f"🔍 Customer sheet detection - Score: {score}, Columns: {columns_lower}")
+        return score >= 2
+
+    def _is_distributor_sheet(self, df):
+        """Enhanced distributor sheet detection with better logging"""
+        columns_lower = [str(col).lower() for col in df.columns]
+        
+        print(f"\n🔍 ENHANCED DISTRIBUTOR DETECTION:")
+        print(f"   All columns: {columns_lower}")
+        
+        distributor_indicators = [
+            'distributor', 'mantri', 'sabhasad', 'contact_in_group',
+            'village', 'taluka', 'district', 'leader', 'team', 'sabh'
+        ]
+        
+        found_indicators = []
+        for indicator in distributor_indicators:
+            matching_cols = [col for col in columns_lower if indicator in col]
+            if matching_cols:
+                found_indicators.append((indicator, matching_cols))
+        
+        print(f"   Found indicators: {found_indicators}")
+        
+        score = len(found_indicators)
+        print(f"   Detection score: {score}")
+        
+        # More flexible detection - lower threshold
+        return score >= 1  # Even if we find just one indicator, try processing
+
+    def process_single_sheet(self, df, sheet_name, file_name):
+        """Process a single sheet with detailed logging"""
+        print(f"🔄 Processing sheet: {sheet_name} from {file_name}")
+        
+        if self._is_sales_sheet(df):
+            print("✅ Detected as SALES sheet")
+            return self.process_sales_sheet(df, file_name, sheet_name)
+        elif self._is_customer_sheet(df):
+            print("✅ Detected as CUSTOMER sheet") 
+            return self.process_customer_sheet(df, file_name, sheet_name)
+        elif self._is_distributor_sheet(df):
+            print("✅ Detected as DISTRIBUTOR sheet")
+            return self.process_distributor_sheet(df, file_name, sheet_name)
+        else:
+            print("❓ Unknown sheet type - trying customer processing as fallback")
+            return self.process_customer_sheet(df, file_name, sheet_name)
+        
+    def process_excel_file(self, file_path):
+        """Enhanced file processing with all data types"""
+        try:
+            file_name = os.path.basename(file_path)
+            print(f"🚀 Processing file: {file_name}")
+            
+            excel_file = pd.ExcelFile(file_path)
+            processed_sheets = 0
+            
+            for sheet_name in excel_file.sheet_names:
+                df = pd.read_excel(file_path, sheet_name=sheet_name)
+                df_clean = self._clean_dataframe(df)
+                
+                print(f"\n📊 Sheet: {sheet_name}")
+                print(f"   Columns: {df_clean.columns.tolist()}")
+                
+                # Check all types with priority
+                is_payment = self._is_payment_sheet(df_clean)
+                is_sales = self._is_sales_sheet(df_clean)
+                is_customer = self._is_customer_sheet(df_clean)
+                is_distributor = self._is_distributor_sheet(df_clean)
+                
+                print(f"   Detection - Payment: {is_payment}, Sales: {is_sales}, Customer: {is_customer}, Distributor: {is_distributor}")
+                
+                processed = False
+                if is_payment:
+                    print("   💳 Processing as PAYMENT sheet")
+                    processed = self.process_payment_sheet(df_clean, file_name, sheet_name)
+                elif is_sales:
+                    print("   💰 Processing as SALES sheet")
+                    processed = self.process_sales_sheet(df_clean, file_name, sheet_name)
+                elif is_distributor:
+                    print("   🤝 Processing as DISTRIBUTOR sheet")
+                    processed = self.process_distributor_sheet(df_clean, file_name, sheet_name)
+                elif is_customer:
+                    print("   👥 Processing as CUSTOMER sheet")
+                    processed = self.process_customer_sheet(df_clean, file_name, sheet_name)
+                else:
+                    print("   ❓ Unknown sheet type")
+                
+                if processed:
+                    processed_sheets += 1
+                    print(f"   ✅ Successfully processed")
+                else:
+                    print(f"   ❌ Failed to process")
+            
+            print(f"\n🎉 File processing complete: {processed_sheets}/{len(excel_file.sheet_names)} sheets processed")
+            return processed_sheets > 0
+            
+        except Exception as e:
+            print(f"💥 Error processing file {file_path}: {e}")
+            return False

database.py

@@ -0,0 +1,893 @@
+import sqlite3
+import pandas as pd
+import os
+import logging
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+import random  # Add this import
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    def __init__(self, db_path="sales_management.db"):
+        self.db_path = db_path
+        self._is_logging = False  # Prevent recursion
+        self.init_database()
+    
+    def get_connection(self):
+        """Get database connection with error handling"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            conn.row_factory = sqlite3.Row  # This enables column access by name
+            return conn
+        except sqlite3.Error as e:
+            logger.error(f"Database connection error: {e}")
+            raise
+    
+    def init_database(self):
+        """Initialize database with all tables and relationships"""
+        conn = self.get_connection()
+        
+        try:
+            # Customers table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS customers (
+                customer_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                customer_code TEXT UNIQUE,
+                name TEXT NOT NULL,
+                mobile TEXT,
+                village TEXT,
+                taluka TEXT,
+                district TEXT,
+                status TEXT DEFAULT 'Active',
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            
+            # Distributors table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS distributors (
+                distributor_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                village TEXT,
+                taluka TEXT,
+                district TEXT,
+                mantri_name TEXT,
+                mantri_mobile TEXT,
+                sabhasad_count INTEGER DEFAULT 0,
+                contact_in_group INTEGER DEFAULT 0,
+                status TEXT DEFAULT 'Active',
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            
+            # Products table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS products (
+                product_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                product_name TEXT UNIQUE NOT NULL,
+                packing_type TEXT,
+                capacity_ltr REAL,
+                category TEXT,
+                standard_rate REAL,
+                is_active INTEGER DEFAULT 1,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            
+            # Sales table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS sales (
+                sale_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                invoice_no TEXT UNIQUE NOT NULL,
+                customer_id INTEGER,
+                sale_date DATE,
+                total_amount REAL DEFAULT 0,
+                total_liters REAL DEFAULT 0,
+                payment_status TEXT DEFAULT 'Pending',
+                notes TEXT,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (customer_id) REFERENCES customers (customer_id) ON DELETE SET NULL
+            )
+            ''')
+            
+            # Sale items table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS sale_items (
+                item_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                sale_id INTEGER,
+                product_id INTEGER,
+                quantity INTEGER,
+                rate REAL,
+                amount REAL,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (sale_id) REFERENCES sales (sale_id) ON DELETE CASCADE,
+                FOREIGN KEY (product_id) REFERENCES products (product_id) ON DELETE SET NULL
+            )
+            ''')
+            
+            # Payments table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS payments (
+                payment_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                sale_id INTEGER,
+                payment_date DATE,
+                payment_method TEXT,
+                amount REAL,
+                rrn TEXT,
+                reference TEXT,
+                status TEXT DEFAULT 'Completed',
+                notes TEXT,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (sale_id) REFERENCES sales (sale_id) ON DELETE CASCADE
+            )
+            ''')
+            
+            # Demos table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS demos (
+                demo_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                customer_id INTEGER,
+                distributor_id INTEGER,
+                demo_date DATE,
+                product_id INTEGER,
+                quantity_provided INTEGER,
+                follow_up_date DATE,
+                conversion_status TEXT DEFAULT 'Not Converted',
+                notes TEXT,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (customer_id) REFERENCES customers (customer_id) ON DELETE SET NULL,
+                FOREIGN KEY (distributor_id) REFERENCES distributors (distributor_id) ON DELETE SET NULL,
+                FOREIGN KEY (product_id) REFERENCES products (product_id) ON DELETE SET NULL
+            )
+            ''')
+            
+            # WhatsApp logs table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS whatsapp_logs (
+                log_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                customer_id INTEGER,
+                distributor_id INTEGER,
+                message_type TEXT,
+                message_content TEXT,
+                status TEXT,
+                sent_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                response TEXT,
+                FOREIGN KEY (customer_id) REFERENCES customers (customer_id) ON DELETE SET NULL,
+                FOREIGN KEY (distributor_id) REFERENCES distributors (distributor_id) ON DELETE SET NULL
+            )
+            ''')
+            
+            # Follow-ups table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS follow_ups (
+                follow_up_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                customer_id INTEGER,
+                distributor_id INTEGER,
+                demo_id INTEGER,
+                follow_up_date DATE,
+                follow_up_type TEXT,
+                notes TEXT,
+                status TEXT DEFAULT 'Pending',
+                next_follow_up_date DATE,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (customer_id) REFERENCES customers (customer_id) ON DELETE SET NULL,
+                FOREIGN KEY (distributor_id) REFERENCES distributors (distributor_id) ON DELETE SET NULL,
+                FOREIGN KEY (demo_id) REFERENCES demos (demo_id) ON DELETE SET NULL
+            )
+            ''')
+            
+            # System logs table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS system_logs (
+                log_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                log_type TEXT,
+                log_message TEXT,
+                table_name TEXT,
+                record_id INTEGER,
+                action TEXT,
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                user_info TEXT
+            )
+            ''')
+            
+            # Rollback logs table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS rollback_logs (
+                rollback_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                table_name TEXT,
+                record_id INTEGER,
+                old_data TEXT,
+                new_data TEXT,
+                action TEXT,
+                rollback_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                rolled_back_by TEXT
+            )
+            ''')
+            
+            # Offers table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS offers (
+                offer_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                offer_name TEXT NOT NULL,
+                offer_description TEXT,
+                product_id INTEGER,
+                discount_percentage REAL,
+                discount_amount REAL,
+                start_date DATE,
+                end_date DATE,
+                status TEXT DEFAULT 'Active',
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (product_id) REFERENCES products (product_id) ON DELETE SET NULL
+            )
+            ''')
+            
+            # Demo teams table
+            conn.execute('''
+            CREATE TABLE IF NOT EXISTS demo_teams (
+                team_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                team_name TEXT NOT NULL,
+                team_leader TEXT,
+                team_members TEXT,
+                assigned_villages TEXT,
+                status TEXT DEFAULT 'Active',
+                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            
+            conn.commit()
+            logger.info("Database tables initialized successfully")
+            
+        except sqlite3.Error as e:
+            logger.error(f"Error initializing database: {e}")
+            raise
+        finally:
+            conn.close()
+        
+        self.initialize_default_data()
+        self.create_indexes()
+    
+    def create_indexes(self):
+        """Create indexes for better performance"""
+        conn = self.get_connection()
+        
+        try:
+            # Create indexes for frequently queried columns
+            indexes = [
+                "CREATE INDEX IF NOT EXISTS idx_customers_village ON customers(village)",
+                "CREATE INDEX IF NOT EXISTS idx_customers_mobile ON customers(mobile)",
+                "CREATE INDEX IF NOT EXISTS idx_sales_customer_id ON sales(customer_id)",
+                "CREATE INDEX IF NOT EXISTS idx_sales_date ON sales(sale_date)",
+                "CREATE INDEX IF NOT EXISTS idx_sales_invoice ON sales(invoice_no)",
+                "CREATE INDEX IF NOT EXISTS idx_payments_sale_id ON payments(sale_id)",
+                "CREATE INDEX IF NOT EXISTS idx_demos_customer_id ON demos(customer_id)",
+                "CREATE INDEX IF NOT EXISTS idx_demos_date ON demos(demo_date)",
+                "CREATE INDEX IF NOT EXISTS idx_sale_items_sale_id ON sale_items(sale_id)",
+                "CREATE INDEX IF NOT EXISTS idx_follow_ups_date ON follow_ups(follow_up_date)",
+                "CREATE INDEX IF NOT EXISTS idx_whatsapp_customer_id ON whatsapp_logs(customer_id)"
+            ]
+            
+            for index_sql in indexes:
+                conn.execute(index_sql)
+            
+            conn.commit()
+            logger.info("Database indexes created successfully")
+            
+        except sqlite3.Error as e:
+            logger.error(f"Error creating indexes: {e}")
+        finally:
+            conn.close()
+    
+    def initialize_default_data(self):
+        """Initialize with default products and demo teams"""
+        default_products = [
+            ('1 LTR PLASTIC JAR', 'PLASTIC_JAR', 1.0, 'Regular', 95),
+            ('2 LTR PLASTIC JAR', 'PLASTIC_JAR', 2.0, 'Regular', 185),
+            ('5 LTR PLASTIC JAR', 'PLASTIC_JAR', 5.0, 'Regular', 460),
+            ('5 LTR STEEL BARNI', 'STEEL_BARNI', 5.0, 'Premium', 680),
+            ('10 LTR STEEL BARNI', 'STEEL_BARNI', 10.0, 'Premium', 1300),
+            ('20 LTR STEEL BARNI', 'STEEL_BARNI', 20.0, 'Premium', 2950),
+            ('20 LTR PLASTIC CAN', 'PLASTIC_CAN', 20.0, 'Regular', 2400),
+            ('1 LTR PET BOTTLE', 'PET_BOTTLE', 1.0, 'Regular', 85)
+        ]
+        
+        default_teams = [
+            ('Team A - North Region', 'Rajesh Kumar', 'Mohan, Suresh, Priya', 'Amiyad, Amvad, Ankalav'),
+            ('Team B - South Region', 'Sunil Patel', 'Anita, Vijay, Deepak', 'Petlad, Borsad, Vadodara')
+        ]
+        
+        conn = self.get_connection()
+        try:
+            # Insert default products
+            for product in default_products:
+                conn.execute('''
+                INSERT OR IGNORE INTO products (product_name, packing_type, capacity_ltr, category, standard_rate)
+                VALUES (?, ?, ?, ?, ?)
+                ''', product)
+            
+            # Insert default demo teams
+            for team in default_teams:
+                conn.execute('''
+                INSERT OR IGNORE INTO demo_teams (team_name, team_leader, team_members, assigned_villages)
+                VALUES (?, ?, ?, ?)
+                ''', team)
+            
+            conn.commit()
+            logger.info("Default data initialized successfully")
+            
+        except sqlite3.Error as e:
+            logger.error(f"Error initializing default data: {e}")
+        finally:
+            conn.close()
+    
+    def _execute_query_internal(self, query: str, params: tuple = None) -> List[tuple]:
+        """Internal method to execute SQL query without logging"""
+        conn = self.get_connection()
+        try:
+            cursor = conn.cursor()
+            if params:
+                cursor.execute(query, params)
+            else:
+                cursor.execute(query)
+            
+            # Only try to fetch results for SELECT queries
+            if query.strip().upper().startswith('SELECT'):
+                result = cursor.fetchall()
+            else:
+                result = []
+                
+            conn.commit()
+            return result
+            
+        except sqlite3.Error as e:
+            logger.error(f"Database query error: {e}")
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+    
+    def execute_query(self, query: str, params: tuple = None, log_action: bool = True) -> List[tuple]:
+        """Execute a SQL query with comprehensive error handling"""
+        try:
+            result = self._execute_query_internal(query, params)
+            
+            # Log the query execution (but avoid recursion)
+            if log_action and not self._is_logging:
+                try:
+                    self._is_logging = True
+                    self._execute_query_internal('''
+                    INSERT INTO system_logs (log_type, log_message, table_name, record_id, action)
+                    VALUES (?, ?, ?, ?, ?)
+                    ''', ('QUERY_EXECUTION', f"Executed query: {query[:100]}...", None, None, 'EXECUTE'))
+                except Exception as e:
+                    logger.error(f"Error logging system action: {e}")
+                finally:
+                    self._is_logging = False
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error in execute_query: {e}")
+            return []  # Return empty list instead of raising exception
+    
+    def get_dataframe(self, table_name: str = None, query: str = None, params: tuple = None) -> pd.DataFrame:
+        """Get table data as DataFrame with flexible query support"""
+        conn = self.get_connection()
+        try:
+            if query:
+                df = pd.read_sql_query(query, conn, params=params)
+            else:
+                df = pd.read_sql_query(f"SELECT * FROM {table_name}", conn)
+            return df
+        except Exception as e:
+            logger.error(f"Error getting DataFrame for {table_name if table_name else 'query'}: {e}")
+            # Return empty DataFrame with proper structure
+            return pd.DataFrame()
+        finally:
+            conn.close()
+    
+    def add_customer(self, name: str, mobile: str = "", village: str = "", taluka: str = "", 
+                district: str = "", customer_code: str = None) -> int:
+        """Add a new customer with duplicate handling"""
+        
+        # Generate customer code if not provided
+        if not customer_code:
+            customer_code = f"CUST{datetime.now().strftime('%Y%m%d%H%M%S')}{random.randint(100, 999)}"
+        
+        try:
+            # Check if customer already exists (by mobile or similar name+village)
+            existing_customer = self.execute_query(
+                'SELECT customer_id FROM customers WHERE mobile = ? OR (name = ? AND village = ?)',
+                (mobile, name, village),
+                log_action=False
+            )
+            
+            if existing_customer:
+                # Customer already exists, return existing ID
+                return existing_customer[0][0]
+            
+            # If customer_code already exists, generate a new one
+            max_attempts = 5
+            for attempt in range(max_attempts):
+                try:
+                    result = self.execute_query('''
+                    INSERT INTO customers (customer_code, name, mobile, village, taluka, district)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    ''', (customer_code, name, mobile, village, taluka, district), log_action=False)
+                    break
+                except sqlite3.IntegrityError as e:
+                    if "UNIQUE constraint failed: customers.customer_code" in str(e) and attempt < max_attempts - 1:
+                        # Generate new unique customer code
+                        customer_code = f"CUST{datetime.now().strftime('%Y%m%d%H%M%S')}{random.randint(1000, 9999)}"
+                        continue
+                    else:
+                        raise e
+            
+            # Get the inserted customer_id
+            customer_id = self.execute_query('SELECT last_insert_rowid()', log_action=False)[0][0]
+            
+            self.log_system_action('CUSTOMER_ADD', f"Added customer: {name}", 'customers', customer_id, 'INSERT')
+            
+            return customer_id
+        except Exception as e:
+            logger.error(f"Error adding customer: {e}")
+            # Return a fallback - this won't be in database but prevents crashes
+            return -1
+    def add_distributor(self, name: str, village: str = "", taluka: str = "", district: str = "", 
+                   mantri_name: str = "", mantri_mobile: str = "", sabhasad_count: int = 0, 
+                   contact_in_group: int = 0, status: str = "Active") -> int:
+        """Add a new distributor with duplicate handling"""
+        
+        try:
+            # Check if distributor already exists
+            existing_distributor = self.execute_query(
+                'SELECT distributor_id FROM distributors WHERE name = ? AND village = ? AND taluka = ?',
+                (name, village, taluka),
+                log_action=False
+            )
+            
+            if existing_distributor:
+                # Distributor already exists, return existing ID
+                return existing_distributor[0][0]
+            
+            # Insert new distributor
+            self.execute_query('''
+            INSERT INTO distributors (name, village, taluka, district, mantri_name, mantri_mobile, 
+                                    sabhasad_count, contact_in_group, status)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (name, village, taluka, district, mantri_name, mantri_mobile, 
+                sabhasad_count, contact_in_group, status), log_action=False)
+            
+            # Get the inserted distributor_id
+            distributor_id = self.execute_query('SELECT last_insert_rowid()', log_action=False)[0][0]
+            
+            self.log_system_action('DISTRIBUTOR_ADD', f"Added distributor: {name}", 'distributors', distributor_id, 'INSERT')
+            
+            return distributor_id
+            
+        except Exception as e:
+            logger.error(f"Error adding distributor: {e}")
+            return -1
+    def get_distributor_by_location(self, village: str, taluka: str) -> Optional[Dict]:
+        """Get distributor by village and taluka"""
+        try:
+            result = self.execute_query(
+                'SELECT * FROM distributors WHERE village = ? AND taluka = ?',
+                (village, taluka),
+                log_action=False
+            )
+            if result:
+                return dict(result[0])
+            return None
+        except Exception as e:
+            logger.error(f"Error getting distributor by location: {e}")
+            return None
+
+    def distributor_exists(self, name: str, village: str, taluka: str) -> bool:
+        """Check if distributor already exists"""
+        try:
+            result = self.execute_query(
+                'SELECT distributor_id FROM distributors WHERE name = ? AND village = ? AND taluka = ?',
+                (name, village, taluka),
+                log_action=False
+            )
+            return len(result) > 0
+        except Exception as e:
+            logger.error(f"Error checking distributor existence: {e}")
+            return False
+    # In your DatabaseManager class in database.py, replace the generate_invoice_number method:
+
+    def generate_invoice_number(self):
+        """Generate automatic invoice number in format: INVCLmmyyserial"""
+        try:
+            # Get current date components
+            now = datetime.now()
+            month = now.strftime('%m')  # Two-digit month
+            year = now.strftime('%y')   # Two-digit year
+            
+            # Get the last invoice number for this month-year
+            result = self.execute_query(
+                "SELECT invoice_no FROM sales WHERE invoice_no LIKE ? ORDER BY sale_id DESC LIMIT 1",
+                (f"INVCL{month}{year}%",),
+                log_action=False
+            )
+            
+            if result:
+                last_invoice = result[0][0]
+                # Extract serial number and increment
+                try:
+                    # Format: INVCLmmyyXXX
+                    serial_part = last_invoice[8:]  # Get part after INVCLmmyy
+                    last_serial = int(serial_part)
+                    new_serial = last_serial + 1
+                except ValueError:
+                    new_serial = 1
+            else:
+                # First invoice of the month-year
+                new_serial = 1
+            
+            # Format: INVCL + month(2) + year(2) + serial(3 digits)
+            return f"INVCL{month}{year}{new_serial:03d}"
+            
+        except Exception as e:
+            logger.error(f"Error generating invoice number: {e}")
+            # Fallback: timestamp-based
+            return f"INVCL{int(datetime.now().timestamp())}"
+
+    # Or if you want a more flexible version with configurable prefix:
+    def generate_invoice_number(self, prefix="INVCL"):
+        """Generate automatic invoice number in format: PREFIXmmyyserial"""
+        try:
+            now = datetime.now()
+            month = now.strftime('%m')
+            year = now.strftime('%y')
+            
+            result = self.execute_query(
+                "SELECT invoice_no FROM sales WHERE invoice_no LIKE ? ORDER BY sale_id DESC LIMIT 1",
+                (f"{prefix}{month}{year}%",),
+                log_action=False
+            )
+            
+            if result:
+                last_invoice = result[0][0]
+                try:
+                    # Remove prefix and date part, get serial
+                    serial_part = last_invoice[len(prefix) + 4:]  # prefix + 4 digits (mmyy)
+                    last_serial = int(serial_part)
+                    new_serial = last_serial + 1
+                except ValueError:
+                    new_serial = 1
+            else:
+                new_serial = 1
+            
+            return f"{prefix}{month}{year}{new_serial:03d}"
+            
+        except Exception as e:
+            logger.error(f"Error generating invoice number: {e}")
+            return f"{prefix}{int(datetime.now().timestamp())}"
+        
+    # Add to your DatabaseManager class in database.py
+
+    def add_sale(self, invoice_no: str, customer_id: int, sale_date, items: List[Dict], 
+             payments: List[Dict] = None, notes: str = "") -> int:
+        """Add a new sale with items and optional payments - ENHANCED"""
+        conn = self.get_connection()
+        try:
+            cursor = conn.cursor()
+            
+            # Calculate total amount and liters
+            total_amount = sum(item['quantity'] * item['rate'] for item in items)
+            total_liters = sum(item.get('liters', 0) for item in items)
+            
+            print(f"🔧 DEBUG: Creating sale - Invoice: {invoice_no}, Customer: {customer_id}, Total: {total_amount}")  # DEBUG
+            
+            # Add sale record
+            cursor.execute('''
+            INSERT INTO sales (invoice_no, customer_id, sale_date, total_amount, total_liters, notes)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ''', (invoice_no, customer_id, sale_date, total_amount, total_liters, notes))
+            
+            # Get the sale ID
+            sale_id = cursor.lastrowid
+            print(f"🔧 DEBUG: Sale created with ID: {sale_id}")  # DEBUG
+            
+            # Add sale items
+            for item in items:
+                amount = item['quantity'] * item['rate']
+                print(f"🔧 DEBUG: Adding item - Product: {item['product_id']}, Qty: {item['quantity']}, Rate: {item['rate']}")  # DEBUG
+                
+                cursor.execute('''
+                INSERT INTO sale_items (sale_id, product_id, quantity, rate, amount)
+                VALUES (?, ?, ?, ?, ?)
+                ''', (sale_id, item['product_id'], item['quantity'], item['rate'], amount))
+            
+            # Add payments if provided
+            if payments:
+                for payment in payments:
+                    cursor.execute('''
+                    INSERT INTO payments (sale_id, payment_date, payment_method, amount, rrn, reference)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    ''', (sale_id, payment['payment_date'], payment['method'], 
+                        payment['amount'], payment.get('rrn', ''), payment.get('reference', '')))
+            
+            conn.commit()
+            
+            # Update payment status
+            self._update_payment_status(sale_id)
+            
+            print(f"🔧 DEBUG: Sale {sale_id} completed successfully")  # DEBUG
+            return sale_id
+            
+        except Exception as e:
+            conn.rollback()
+            logger.error(f"Error adding sale: {e}")
+            print(f"❌ ERROR in add_sale: {e}")  # DEBUG
+            raise
+        finally:
+            conn.close()
+    
+    def _update_payment_status(self, sale_id: int):
+        """Update payment status for a sale"""
+        conn = self.get_connection()
+        try:
+            # Get total paid amount
+            cursor = conn.cursor()
+            cursor.execute('SELECT COALESCE(SUM(amount), 0) FROM payments WHERE sale_id = ?', (sale_id,))
+            total_paid = cursor.fetchone()[0]
+            
+            # Get sale total
+            cursor.execute('SELECT total_amount FROM sales WHERE sale_id = ?', (sale_id,))
+            sale_total = cursor.fetchone()[0]
+            
+            # Determine payment status
+            if total_paid >= sale_total:
+                status = 'Paid'
+            elif total_paid > 0:
+                status = 'Partial'
+            else:
+                status = 'Pending'
+            
+            # Update status
+            cursor.execute('UPDATE sales SET payment_status = ? WHERE sale_id = ?', (status, sale_id))
+            conn.commit()
+            
+        except Exception as e:
+            logger.error(f"Error updating payment status: {e}")
+        finally:
+            conn.close()
+    
+    def get_pending_payments(self) -> pd.DataFrame:
+        """Get all pending payments with customer details"""
+        return self.get_dataframe('sales', '''
+        SELECT s.sale_id, s.invoice_no, s.sale_date, c.name as customer_name, 
+               c.mobile, c.village, s.total_amount,
+               (s.total_amount - COALESCE(SUM(p.amount), 0)) as pending_amount,
+               COALESCE(SUM(p.amount), 0) as paid_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
+        ''')
+    
+    def get_demo_conversions(self) -> pd.DataFrame:
+        """Get demo conversion statistics with details"""
+        return self.get_dataframe('demos', '''
+        SELECT d.*, c.name as customer_name, p.product_name, 
+               dist.name as distributor_name, c.village, c.taluka,
+               CASE WHEN d.conversion_status = 'Converted' THEN 1 ELSE 0 END as converted
+        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
+        ''')
+    
+    def get_sales_analytics(self, start_date: str = None, end_date: str = None) -> Dict:
+        """Get comprehensive sales analytics"""
+        if not start_date:
+            start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
+        if not end_date:
+            end_date = datetime.now().strftime('%Y-%m-%d')
+        
+        query = '''
+        SELECT 
+            COUNT(*) as total_sales,
+            SUM(total_amount) as total_revenue,
+            AVG(total_amount) as avg_sale_value,
+            COUNT(DISTINCT customer_id) as unique_customers,
+            SUM(CASE WHEN payment_status = 'Paid' THEN 1 ELSE 0 END) as completed_payments,
+            SUM(CASE WHEN payment_status IN ('Pending', 'Partial') THEN 1 ELSE 0 END) as pending_payments
+        FROM sales 
+        WHERE sale_date BETWEEN ? AND ?
+        '''
+        
+        result = self.execute_query(query, (start_date, end_date), log_action=False)
+        
+        if result:
+            row = result[0]
+            return {
+                'total_sales': row[0] or 0,
+                'total_revenue': row[1] or 0,
+                'avg_sale_value': row[2] or 0,
+                'unique_customers': row[3] or 0,
+                'completed_payments': row[4] or 0,
+                'pending_payments': row[5] or 0
+            }
+        return {}
+    
+    def log_system_action(self, log_type: str, message: str, table_name: str = None, 
+                         record_id: int = None, action: str = None):
+        """Log system actions for audit trail - without recursion"""
+        if self._is_logging:
+            return  # Prevent recursion
+        
+        try:
+            self._is_logging = True
+            self._execute_query_internal('''
+            INSERT INTO system_logs (log_type, log_message, table_name, record_id, action)
+            VALUES (?, ?, ?, ?, ?)
+            ''', (log_type, message, table_name, record_id, action))
+        except Exception as e:
+            logger.error(f"Error logging system action: {e}")
+        finally:
+            self._is_logging = False
+    
+    def create_rollback_point(self, table_name: str, record_id: int, old_data: str, 
+                             new_data: str, action: str):
+        """Create a rollback point for data changes"""
+        try:
+            self.execute_query('''
+            INSERT INTO rollback_logs (table_name, record_id, old_data, new_data, action)
+            VALUES (?, ?, ?, ?, ?)
+            ''', (table_name, record_id, old_data, new_data, action), log_action=False)
+        except Exception as e:
+            logger.error(f"Error creating rollback point: {e}")
+    
+    def get_recent_activity(self, limit: int = 10) -> pd.DataFrame:
+        """Get recent system activity"""
+        return self.get_dataframe('system_logs', f'''
+        SELECT log_type, log_message, table_name, record_id, action, created_date
+        FROM system_logs 
+        ORDER BY created_date DESC 
+        LIMIT {limit}
+        ''')
+    
+    def backup_database(self, backup_path: str = None):
+        """Create a database backup"""
+        if not backup_path:
+            backup_path = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+        
+        try:
+            conn = self.get_connection()
+            backup_conn = sqlite3.connect(backup_path)
+            
+            with backup_conn:
+                conn.backup(backup_conn)
+            
+            conn.close()
+            backup_conn.close()
+            
+            logger.info(f"Database backup created: {backup_path}")
+            return backup_path
+            
+        except Exception as e:
+            logger.error(f"Error creating database backup: {e}")
+            return None
+    
+    def get_village_wise_sales(self) -> pd.DataFrame:
+        """Get sales data grouped by village"""
+        return self.get_dataframe('sales', '''
+        SELECT c.village, COUNT(s.sale_id) as total_sales, 
+               SUM(s.total_amount) as total_revenue,
+               AVG(s.total_amount) as avg_sale_value,
+               COUNT(DISTINCT s.customer_id) as unique_customers
+        FROM sales s
+        JOIN customers c ON s.customer_id = c.customer_id
+        WHERE c.village IS NOT NULL AND c.village != ''
+        GROUP BY c.village
+        ORDER BY total_revenue DESC
+        ''')
+    
+    def get_product_performance(self) -> pd.DataFrame:
+        """Get product performance analytics"""
+        return self.get_dataframe('sale_items', '''
+        SELECT p.product_name, 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
+        GROUP BY p.product_id, p.product_name
+        ORDER BY total_revenue DESC
+        ''')
+    
+    def get_upcoming_follow_ups(self) -> pd.DataFrame:
+        """Get upcoming follow-ups"""
+        return self.get_dataframe('follow_ups', '''
+        SELECT f.*, c.name as customer_name, c.mobile, 
+               d.name as distributor_name, dm.demo_date
+        FROM follow_ups f
+        LEFT JOIN customers c ON f.customer_id = c.customer_id
+        LEFT JOIN distributors d ON f.distributor_id = d.distributor_id
+        LEFT JOIN demos dm ON f.demo_id = dm.demo_id
+        WHERE f.follow_up_date >= date('now') 
+        AND f.status = 'Pending'
+        ORDER BY f.follow_up_date ASC
+        LIMIT 20
+        ''')
+    
+    def get_whatsapp_logs(self, customer_id: int = None) -> pd.DataFrame:
+        """Get WhatsApp communication logs"""
+        if customer_id:
+            return self.get_dataframe('whatsapp_logs', '''
+            SELECT w.*, c.name as customer_name, c.mobile
+            FROM whatsapp_logs w
+            LEFT JOIN customers c ON w.customer_id = c.customer_id
+            WHERE w.customer_id = ?
+            ORDER BY w.sent_date DESC
+            ''', (customer_id,))
+        else:
+            return self.get_dataframe('whatsapp_logs', '''
+            SELECT w.*, c.name as customer_name, c.mobile
+            FROM whatsapp_logs w
+            LEFT JOIN customers c ON w.customer_id = c.customer_id
+            ORDER BY w.sent_date DESC
+            LIMIT 50
+            ''')
+    
+    def cleanup_old_data(self, days: int = 365):
+        """Clean up old data (logs, etc.) older than specified days"""
+        try:
+            cutoff_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
+            
+            # Clean system logs
+            self.execute_query('DELETE FROM system_logs WHERE created_date < ?', (cutoff_date,), log_action=False)
+            
+            # Clean rollback logs
+            self.execute_query('DELETE FROM rollback_logs WHERE rollback_date < ?', (cutoff_date,), log_action=False)
+            
+            logger.info(f"Cleaned up data older than {days} days")
+            
+        except Exception as e:
+            logger.error(f"Error cleaning up old data: {e}")
+
+# Utility function to check database health
+def check_database_health(db_path: str = "sales_management.db") -> Dict:
+    """Check database health and statistics"""
+    try:
+        db = DatabaseManager(db_path)
+        
+        # Get table counts
+        tables = ['customers', 'sales', 'distributors', 'demos', 'payments', 'products']
+        counts = {}
+        
+        for table in tables:
+            result = db.execute_query(f"SELECT COUNT(*) FROM {table}", log_action=False)
+            counts[table] = result[0][0] if result else 0
+        
+        # Get database size
+        db_size = os.path.getsize(db_path) if os.path.exists(db_path) else 0
+        
+        return {
+            'status': 'healthy',
+            'table_counts': counts,
+            'database_size_mb': round(db_size / (1024 * 1024), 2),
+            'last_backup': 'N/A',  # You can implement backup tracking
+            'integrity_check': 'passed'  # You can add actual integrity checks
+        }
+        
+    except Exception as e:
+        return {
+            'status': 'error',
+            'error': str(e),
+            'table_counts': {},
+            'database_size_mb': 0,
+            'integrity_check': 'failed'
+        }

main.py

@@ -0,0 +1,211 @@
+# main.py (Fixed version)
+import streamlit as st
+import os
+import sys
+
+# Add the current directory to Python path
+sys.path.append(os.path.dirname(__file__))
+
+# MUST BE FIRST - Page configuration
+st.set_page_config(
+    page_title="Sales Management System",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Import utilities - Create these if they don't exist
+try:
+    from utils.styling import apply_custom_css
+    from utils.helpers import init_session_state, check_module_availability
+    from components.database_status import show_database_status
+except ImportError:
+    # Create basic fallbacks if utils don't exist
+    def apply_custom_css():
+        st.markdown("""
+        <style>
+        .main-header { color: #1f77b4; }
+        .section-header { color: #2e86ab; margin-top: 2rem; }
+        </style>
+        """, unsafe_allow_html=True)
+    
+    def init_session_state():
+        if 'db' not in st.session_state:
+            st.session_state.db = None
+        if 'data_processor' not in st.session_state:
+            st.session_state.data_processor = None
+        if 'analytics' not in st.session_state:
+            st.session_state.analytics = None
+        if 'whatsapp_manager' not in st.session_state:
+            st.session_state.whatsapp_manager = None
+    
+    def check_module_availability():
+        try:
+            import pandas, plotly, sqlite3
+            MODULES_AVAILABLE = True
+        except ImportError:
+            MODULES_AVAILABLE = False
+        
+        try:
+            import pywhatkit
+            WHATSAPP_AVAILABLE = True
+        except ImportError:
+            WHATSAPP_AVAILABLE = False
+            
+        return MODULES_AVAILABLE, WHATSAPP_AVAILABLE
+    
+    def show_database_status(db):
+        if db:
+            try:
+                health = db.execute_query("SELECT COUNT(*) FROM sqlite_master", log_action=False)
+                st.sidebar.success("✅ Database Connected")
+            except:
+                st.sidebar.error("❌ Database Error")
+        else:
+            st.sidebar.warning("⚠️ Database Not Initialized")
+
+# Apply custom CSS
+apply_custom_css()
+
+# Initialize session state
+init_session_state()
+
+# Check module availability
+MODULES_AVAILABLE, WHATSAPP_AVAILABLE = check_module_availability()
+
+# Initialize components with error handling
+if MODULES_AVAILABLE:
+    try:
+        from database import DatabaseManager
+        from data_processor import DataProcessor
+        from analytics import Analytics
+        
+        if st.session_state.db is None:
+            st.session_state.db = DatabaseManager()
+            st.success("✅ Database initialized successfully!")
+        
+        if st.session_state.data_processor is None:
+            st.session_state.data_processor = DataProcessor(st.session_state.db)
+        
+        if st.session_state.analytics is None:
+            st.session_state.analytics = Analytics(st.session_state.db)
+        
+        if WHATSAPP_AVAILABLE and st.session_state.whatsapp_manager is None:
+            try:
+                from whatsapp_manager import WhatsAppManager
+                st.session_state.whatsapp_manager = WhatsAppManager(st.session_state.db)
+                st.success("✅ WhatsApp Manager initialized!")
+            except Exception as e:
+                st.warning(f"⚠️ WhatsApp Manager not available: {e}")
+                st.session_state.whatsapp_manager = None
+                
+    except Exception as e:
+        st.error(f"❌ Application initialization failed: {e}")
+        st.info("Please check that all required files are in the correct location.")
+
+# Assign to local variables for easier access
+db = st.session_state.db
+data_processor = st.session_state.data_processor
+analytics = st.session_state.analytics
+whatsapp_manager = st.session_state.whatsapp_manager
+
+# Sidebar navigation
+st.sidebar.markdown("<h1 style='text-align: center;'>🚀 Sales Management</h1>", unsafe_allow_html=True)
+
+page = st.sidebar.radio("Navigation", [
+    "📊 Dashboard", "👥 Customers", "💰 Sales", "💳 Payments", 
+    "🎯 Demos", "🤝 Distributors", "🔍 File Viewer", "📤 Data Import", "📈 Reports"
+], index=0)
+
+# Page routing with error handling
+try:
+    if page == "📊 Dashboard":
+        try:
+            from pages.dashboard import create_dashboard
+            create_dashboard(db, analytics)
+        except ImportError:
+            st.error("Dashboard page not available. Creating basic dashboard...")
+            show_basic_dashboard(db, analytics)
+    
+    elif page == "👥 Customers":
+        try:
+            from pages.customers import show_customers_page
+            show_customers_page(db, whatsapp_manager)
+        except ImportError:
+            st.error("Customers page not available")
+    
+    elif page == "💰 Sales":
+        try:
+            from pages.sales import show_sales_page
+            show_sales_page(db, whatsapp_manager)
+        except ImportError:
+            st.error("Sales page not available")
+    
+    elif page == "🎯 Demos":
+        from pages.demos import show_demos_page
+        show_demos_page(db, whatsapp_manager)
+        
+    elif page == "💳 Payments":
+        from pages.payments import show_payments_page
+        show_payments_page(db, whatsapp_manager)
+    
+    elif page == "🤝 Distributors":
+        try:
+            from pages.distributors import show_distributors_page
+            show_distributors_page(db, whatsapp_manager)
+        except ImportError:
+            st.error("Distributors page not available")
+    
+    elif page == "🔍 File Viewer":
+        try:
+            from pages.file_viewer import show_file_viewer_page
+            show_file_viewer_page(db, data_processor)
+        except ImportError:
+            st.error("File Viewer page not available")
+    
+    elif page == "📤 Data Import":
+        try:
+            from pages.data_import import show_data_import_page
+            show_data_import_page(db, data_processor)
+        except ImportError:
+            st.error("Data Import page not available")
+    
+    elif page == "📈 Reports":
+        try:
+            from pages.reports import show_reports_page
+            show_reports_page(db,whatsapp_manager)
+        except ImportError:
+            st.error("Reports page not available")
+
+except Exception as e:
+    st.error(f"Application error: {e}")
+    st.info("Please check the console for more details.")
+
+# Show database status in sidebar
+show_database_status(db)
+
+st.sidebar.markdown("---")
+st.sidebar.info("🚀 Sales Management System v2.0")
+
+# Basic dashboard fallback
+def show_basic_dashboard(db, analytics):
+    st.title("📊 Sales Dashboard")
+    
+    if db and analytics:
+        try:
+            sales_summary = analytics.get_sales_summary()
+            
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Total Sales", f"₹{sales_summary.get('total_sales', 0):,.0f}")
+            with col2:
+                st.metric("Pending Payments", f"₹{sales_summary.get('pending_amount', 0):,.0f}")
+            with col3:
+                st.metric("Total Transactions", sales_summary.get('total_transactions', 0))
+            with col4:
+                st.metric("Avg Sale", f"₹{sales_summary.get('avg_sale_value', 0):,.0f}")
+                
+        except Exception as e:
+            st.error(f"Error loading dashboard data: {e}")
+    else:
+        st.warning("Database or analytics not available")