updated features

app.py

@@ -7,552 +7,590 @@ import time
 
 # Page config
 st.set_page_config(
-    page_title="Cold Email Outreach Assistant",
+    page_title="Cold Email Assistant - Premium Demo",
     page_icon="📧",
     layout="wide"
 )
 
-# Initialize session state for usage tracking
-if 'email_count' not in st.session_state:
-    st.session_state.email_count = 0
-if 'user_email' not in st.session_state:
-    st.session_state.user_email = ""
-if 'is_premium' not in st.session_state:
-    st.session_state.is_premium = False
+# Import components
+try:
+    from scraper import scrape_company_info
+    SCRAPER_AVAILABLE = True
+except ImportError as e:
+    print(f"⚠️ Scraper not available: {e}")
+    SCRAPER_AVAILABLE = False
+    def scrape_company_info(url_or_company):
+        return "Company research feature requires additional setup. Please contact support for enterprise features."
 
-# Usage limits
-FREE_DAILY_LIMIT = 5
-PREMIUM_DAILY_LIMIT = 1000
+from email_gen import generate_cold_email
+from usage_tracker import UsageTracker
 
-def check_usage_limit():
-    """Check if user has exceeded daily limit"""
-    if st.session_state.is_premium:
-        return True
-    return st.session_state.email_count < FREE_DAILY_LIMIT
+# Initialize usage tracker
+tracker = UsageTracker()
 
-def increment_usage():
-    """Increment usage counter"""
-    st.session_state.email_count += 1
+# CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        margin-bottom: 2rem;
+    }
+    .premium-badge {
+        background: linear-gradient(45deg, #FFD700, #FFA500);
+        color: #000;
+        padding: 0.5rem 1rem;
+        border-radius: 20px;
+        font-weight: bold;
+        font-size: 0.9rem;
+    }
+    .limit-warning {
+        background: #fff3cd;
+        border: 1px solid #ffeeba;
+        border-radius: 5px;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
 
-def show_upgrade_cta():
-    """Show upgrade call-to-action when limit reached"""
-    st.error("🚫 **Daily limit reached!** You've used all 5 free emails today.")
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown("""
-        ### 🚀 Upgrade to Unlimited
-        **$19 one-time payment**
-        - ✅ Unlimited emails per day
-        - ✅ Priority processing
-        - ✅ Advanced tone options
-        - ✅ Bulk export features
-        """)
-        
-        if st.button("🔓 Get Unlimited Access - $19", use_container_width=True):
-            st.markdown("**[🛒 Purchase Here →](https://gumroad.com/l/cold-email-unlimited)**")
-            st.info("💡 **Limited Time:** Regular price $49, now only $19!")
-    
-    with col2:
-        st.markdown("""
-        ### 💼 Need More?
-        **Professional Service Available**
-        - 📧 Custom email campaigns
-        - 🎯 Industry-specific targeting  
-        - 📊 A/B testing & optimization
-        - 🚀 Done-for-you outreach
-        """)
-        
-        if st.button("💼 Hire Me on Fiverr", use_container_width=True):
-            st.markdown("**[🎯 Professional Service →](https://fiverr.com/your-username)**")
+# Header with premium badge and urgency
+st.markdown("""
+<div class="main-header">
+    <h1>🚀 Cold Email Assistant - Premium Demo</h1>
+    <p>✨ You're experiencing $97/month features for FREE • Limited daily usage</p>
+    <span class="premium-badge">🔥 ALL PREMIUM FEATURES UNLOCKED</span>
+</div>
+""", unsafe_allow_html=True)
 
-def init_database():
-    """Initialize SQLite database for caching"""
-    conn = sqlite3.connect('leads.db')
-    cursor = conn.cursor()
-    
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS scraped_data (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT,
-            email TEXT,
-            company TEXT,
-            linkedin_url TEXT,
-            scraped_info TEXT,
-            generated_subject TEXT,
-            generated_email TEXT,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    ''')
-    
-    conn.commit()
-    conn.close()
+# Add urgency banner
+usage_percent = (tracker.get_emails_generated() / tracker.daily_email_limit) * 100
+if usage_percent > 70:
+    st.error(f"⚠️ **{100-usage_percent:.0f}% of daily quota remaining** - Upgrade now to avoid interruption!")
+elif usage_percent > 40:
+    st.warning(f"📊 **{100-usage_percent:.0f}% of daily quota remaining** - Consider upgrading for unlimited access")
 
-@st.cache_resource
-def load_modules():
-    """Load required modules with error handling"""
-    try:
-        from scraper import LinkedInScraper
-        from email_gen import EmailGenerator
-        
-        scraper = LinkedInScraper()
-        email_generator = EmailGenerator()
-        
-        return scraper, email_generator
-    except Exception as e:
-        st.error(f"❌ Failed to load modules: {str(e)}")
-        st.info("💡 The AI model will be downloaded automatically on first run. Please ensure you have a stable internet connection.")
-        return None, None
+# Show usage in sidebar
+tracker.show_usage_sidebar()
 
-def create_fallback_email(name, company, tone="professional"):
-    """Simple fallback when main system fails"""
-    return {
-        'subject': f"Partnership opportunity - {company}",
-        'content': f"Hi {name},\n\nI'd love to explore how we can help {company} grow.\n\nInterested in a quick call?\n\nBest regards,\nAlex",
-        'quality_score': 8.0
-    }
+# Sidebar with user info
+st.sidebar.title("📋 Navigation")
+page = st.sidebar.selectbox("Choose a page", ["🎯 Generate Emails", "📊 Bulk Processing", "📈 Analytics Preview"])
 
-def process_leads(df, tone, creativity):
-    """Process leads with bulletproof functionality"""
-    scraper, email_generator = load_modules()
-    
-    results = []
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    for idx, row in df.iterrows():
-        try:
-            progress = (idx + 1) / len(df)
-            progress_bar.progress(progress)
-            status_text.text(f"Processing {row['name']} ({idx + 1}/{len(df)})")
-            
-            # Scrape company data with fallback
-            company_data = ""
-            if scraper:
-                try:
-                    if hasattr(scraper, 'scrape_linkedin_company'):
-                        company_data = scraper.scrape_linkedin_company(row['linkedin_url'])
-                    elif hasattr(scraper, 'scrape_linkedin_profile'):
-                        company_data = scraper.scrape_linkedin_profile(row['linkedin_url'])
-                    elif hasattr(scraper, 'scrape_linkedin_or_company'):
-                        company_data = scraper.scrape_linkedin_or_company(row['linkedin_url'], row['company'])
-                except Exception:
-                    company_data = f"Company: {row['company']} - Professional services company"
-            
-            if not company_data:
-                company_data = f"Company: {row['company']} - Industry leading organization"
-            
-            # Generate email with multiple fallbacks
-            email_result = None
-            
-            # Try AI generation first
-            if email_generator:
-                try:
-                    # Check the email generator's method signature
-                    if hasattr(email_generator, 'generate_email'):
-                        # Try different method signatures
-                        try:
-                            # Try the newer signature (name, company, company_info, tone, temperature)
-                            subject, body = email_generator.generate_email(
-                                name=row['name'],
-                                company=row['company'],
-                                company_info=company_data,
-                                tone=tone,
-                                temperature=creativity
-                            )
-                            email_result = {
-                                'subject': subject,
-                                'content': body,
-                                'quality_score': 8.0
-                            }
-                        except TypeError:
-                            # Try older signature (recipient_name, recipient_email, company_name, company_data, tone, temperature)
-                            email_result = email_generator.generate_email(
-                                recipient_name=row['name'],
-                                recipient_email=row['email'],
-                                company_name=row['company'],
-                                company_data={'description': company_data},
-                                tone=tone.lower(),
-                                temperature=creativity
-                            )
-                except Exception as e:
-                    print(f"AI generation failed for {row['name']}: {e}")
-                    email_result = None
-            
-            # Use advanced fallback if AI failed
-            if not email_result or not email_result.get('content'):
-                if email_generator:
-                    try:
-                        # Use the email generator's advanced fallback system
-                        subject, body = email_generator._advanced_fallback_generation(
-                            row['name'], 
-                            row['company'], 
-                            company_data, 
-                            tone
-                        )
-                        email_result = {
-                            'subject': subject,
-                            'content': body,
-                            'quality_score': 8.5
-                        }
-                    except:
-                        # Final fallback
-                        email_result = create_fallback_email(row['name'], row['company'], tone)
-                else:
-                    email_result = create_fallback_email(row['name'], row['company'], tone)
-            
-            # Create result
-            result = {
-                'name': row['name'],
-                'email': row['email'],
-                'company': row['company'],
-                'subject': email_result.get('subject', f"Partnership Opportunity - {row['company']}"),
-                'email_content': email_result.get('content', ''),
-                'quality_score': email_result.get('quality_score', 8.0),
-                'status': 'success'
-            }
-            
-            results.append(result)
-            time.sleep(0.3)  # Rate limiting
-            
-        except Exception as e:
-            st.warning(f"⚠️ Issue with {row['name']}: {str(e)}")
-            # Always create a result, even with errors
-            if email_generator:
-                try:
-                    fallback_result = email_generator._advanced_fallback_generation(
-                        row['name'], 
-                        row['company'], 
-                        '', 
-                        tone
-                    )
-                    result = {
-                        'name': row['name'],
-                        'email': row['email'],
-                        'company': row['company'],
-                        'subject': fallback_result[0],
-                        'email_content': fallback_result[1],
-                        'quality_score': 8.0,
-                        'status': 'fallback'
-                    }
-                except:
-                    fallback_result = create_fallback_email(row['name'], row['company'], tone)
-                    result = {
-                        'name': row['name'],
-                        'email': row['email'],
-                        'company': row['company'],
-                        'subject': fallback_result.get('subject', f"Partnership Opportunity - {row['company']}"),
-                        'email_content': fallback_result.get('content', ''),
-                        'quality_score': 7.0,
-                        'status': 'error'
-                    }
-            else:
-                fallback_result = create_fallback_email(row['name'], row['company'], tone)
-                result = {
-                    'name': row['name'],
-                    'email': row['email'],
-                    'company': row['company'],
-                    'subject': fallback_result.get('subject', f"Partnership Opportunity - {row['company']}"),
-                    'email_content': fallback_result.get('content', ''),
-                    'quality_score': 7.0,
-                    'status': 'basic_fallback'
-                }
-            
-            results.append(result)
-    
-    progress_bar.progress(1.0)
-    status_text.text("✅ Processing complete!")
-    
-    return results
+# Sender Information
+st.sidebar.markdown("---")
+st.sidebar.subheader("👤 Your Information")
+sender_name = st.sidebar.text_input("Your Name", value="Alex Thompson", help="Your name that will appear in email signatures")
+sender_title = st.sidebar.text_input("Your Title (Optional)", value="", placeholder="e.g., Sales Director", help="Your job title (optional)")
+sender_company = st.sidebar.text_input("Your Company (Optional)", value="", placeholder="e.g., TechSolutions Inc.", help="Your company name (optional)")
 
-def main():
-    # Initialize database
-    init_database()
+# Create sender signature
+if sender_title and sender_company:
+    sender_signature = f"{sender_name}\n{sender_title}, {sender_company}"
+elif sender_title:
+    sender_signature = f"{sender_name}\n{sender_title}"
+else:
+    sender_signature = sender_name
+
+if page == "🎯 Generate Emails":
+    st.header("🎯 Premium Email Generation")
     
-    # Header
-    st.title("📧 Cold Email Outreach Assistant")
-    st.markdown("Transform your lead list into personalized, high-converting cold emails using AI")
+    # Check if user can generate emails
+    if not tracker.can_generate_email():
+        st.error("🚫 **Daily limit reached!** You've experienced the premium features.")
+        
+        col1, col2 = st.columns([2, 1])
+        with col1:
+            st.markdown("""
+            ### 🎯 What you experienced today:
+            - ✅ AI-powered email generation (normally $97/month)
+            - ✅ Company research automation (saves 2+ hours/day)
+            - ✅ Industry-specific templates (10x better conversion)
+            - ✅ Premium quality scoring (proven to increase responses)
+            """)
+        
+        with col2:
+            st.markdown("""
+            ### 💰 Your ROI Calculation:
+            **Time saved:** 2 hours × $50/hour = **$100/day**  
+            **Responses gained:** +40% = **$500+ in deals**  
+            **Tool cost:** Only $19 one-time  
+            **ROI:** 2,500%+ 🚀
+            """)
+        
+        st.markdown("""
+        <div style='background: linear-gradient(90deg, #FF6B6B, #4ECDC4); padding: 1.5rem; border-radius: 10px; text-align: center; color: white; margin: 1rem 0;'>
+            <h3>�� Limited Time: $19 Lifetime Deal</h3>
+            <p><strong>What others charge $97/month for - you get FOREVER for just $19</strong></p>
+            <p>Join 500+ sales professionals already using this</p>
+            <a href="https://gumroad.com/l/cold-email-assistant" style="background: white; color: #333; padding: 0.8rem 2rem; border-radius: 25px; text-decoration: none; font-weight: bold; margin-top: 1rem; display: inline-block;">🚀 Get Lifetime Access Now</a>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.stop()
+    
+    col1, col2 = st.columns([2, 1])
     
-    # Sidebar settings
-    with st.sidebar:
-        st.header("⚙️ Settings")
+    with col1:
+        st.subheader("📝 Lead Information")
+        
+        # Input fields
+        name = st.text_input("👤 Contact Name", 
+                            placeholder="e.g., Sarah Johnson (Director of Sales)")
+        email = st.text_input("📧 Email Address", 
+                             placeholder="e.g., [email protected]")
+        company = st.text_input("🏢 Company Name", 
+                               placeholder="e.g., TechFlow Solutions (B2B SaaS, 50-200 employees)")
+        linkedin_url = st.text_input("🔗 LinkedIn URL (Optional)", 
+                                    placeholder="https://linkedin.com/company/techflow-solutions")
         
-        tone = st.selectbox(
-            "🎭 Email Tone",
-            ["Professional", "Friendly", "Direct"],
-            index=0
-        )
+        # Company details with premium badge
+        st.markdown("### 💼 Company Research **✨ PREMIUM**")
+        company_details = st.text_area("Company Details", 
+                                      placeholder="AI will enhance this with premium research...",
+                                      height=100,
+                                      help="🚀 Premium feature: Enhanced company research and personalization")
         
-        creativity = st.slider(
-            "🎨 Creativity Level",
-            min_value=0.3,
-            max_value=0.9,
-            value=0.7,
-            step=0.1
-        )
+        # Premium tone options
+        st.markdown("### 🎭 Email Tone **✨ PREMIUM**")
+        tone_options = {
+            "Professional": "Formal, executive-level",
+            "Friendly": "Warm, relationship-building", 
+            "Direct": "Straight to the point",
+            "Consultative": "Expert advisor approach ✨",
+            "Enthusiastic": "High-energy, excited ✨"
+        }
         
-        st.markdown("---")
-        st.subheader("🤖 AI Model Status")
+        tone_labels = [f"{tone} - {desc}" for tone, desc in tone_options.items()]
+        selected_tone = st.selectbox("Choose tone", tone_labels)
+        tone = selected_tone.split(" - ")[0]
         
-        # Try to load modules to show status
-        scraper, email_gen = load_modules()
-        if scraper and email_gen:
-            st.success("✅ AI model loaded successfully")
-        else:
-            st.warning("⚠️ AI model loading... (this may take 10-15 minutes on first run)")
-            st.info("💡 The app will work with high-quality fallback emails while the model loads")
+        # Premium industry templates
+        st.markdown("### 🏭 Industry Intelligence **✨ PREMIUM**")
+        industry_options = {
+            "SaaS/Tech": "Software, AI, Digital platforms",
+            "E-commerce": "Online retail, DTC brands", 
+            "Manufacturing": "Industrial, Production",
+            "Healthcare": "Medical, Pharma, Clinical",
+            "Financial Services": "FinTech, Banking ✨",
+            "Real Estate": "PropTech, Commercial ✨",
+            "Generic B2B": "General business approach"
+        }
         
-        st.markdown("---")
-        st.info("💡 **Tip**: Use LinkedIn company URLs for best results")
+        industry_labels = [f"{ind} - {desc}" for ind, desc in industry_options.items()]
+        selected_industry = st.selectbox("Industry template", industry_labels, index=6)
+        industry_template = selected_industry.split(" - ")[0]
         
-        # Email capture for lead generation
-        st.markdown("---")
-        st.subheader("🔔 Stay Updated")
+        # Call to action
+        cta_type = st.selectbox("📞 Call-to-Action Type",
+                               ["Meeting/Call", "Demo", "Information", "Partnership", "Custom"])
         
-        user_email = st.text_input(
-            "📧 Email Address", 
-            placeholder="[email protected]",
-            help="Get notified when Pro features launch"
-        )
+        if cta_type == "Custom":
+            custom_cta = st.text_input("✍️ Custom CTA", placeholder="e.g., Schedule a consultation")
+        else:
+            custom_cta = None
+    
+    with col2:
+        st.subheader("🎯 Premium Actions")
         
-        if st.button("🚀 Notify Me", use_container_width=True):
-            if user_email and "@" in user_email:
-                st.session_state.user_email = user_email
-                # Here you could save to a database or CSV
-                st.success("✅ Thanks! We'll keep you updated.")
+        # LinkedIn scraping with limits
+        scraper_button_text = "🔍 Auto-Research Company" if SCRAPER_AVAILABLE else "🔍 Auto-Research Company (Setup Required)"
+        if st.button(scraper_button_text, use_container_width=True):
+            if not SCRAPER_AVAILABLE:
+                st.warning("🔧 **Company research requires additional setup**")
+                st.info("💡 **Premium Feature Preview:** This would normally scrape LinkedIn/company websites for detailed information to personalize your emails.")
+                st.markdown("**Value:** Manual research = 30 min × $50/hr = $25. This tool = $0.06 per research!")
+                st.success("✨ **Upgrade to get:** Automated LinkedIn scraping, company website analysis, and industry insights!")
+            elif not tracker.can_scrape_linkedin():
+                st.warning("🚫 **Research limit reached!** This premium feature saves 30+ minutes per lead.")
+                st.markdown("**💡 Upgrade for unlimited company research** - [Get it here →](https://gumroad.com/l/cold-email-assistant)")
+            elif linkedin_url or company:
+                with st.spinner("🕒 Researching company (Premium feature)..."):
+                    try:
+                        scraped_info = scrape_company_info(linkedin_url if linkedin_url else company)
+                        if scraped_info and "requires additional setup" not in scraped_info:
+                            company_details = scraped_info
+                            tracker.increment_linkedin_scrape()
+                            tracker.add_premium_feature_used("LinkedIn Research")
+                            st.success("✅ Premium research completed! (Saved you 30+ minutes)")
+                            st.text_area("📋 Research Results", value=scraped_info, height=150, disabled=True)
+                            
+                            # Show value
+                            st.info("💰 **Value delivered:** Manual research = 30 min × $50/hr = $25. This tool = $0.06 per research!")
+                        else:
+                            st.warning("⚠️ Could not research this company. Try manual details.")
+                    except Exception as e:
+                        st.error(f"❌ Research failed: {str(e)}")
             else:
-                st.error("❌ Please enter a valid email")
+                st.error("Please provide LinkedIn URL or company name")
         
-        # Show current usage
-        if not st.session_state.is_premium:
-            remaining = FREE_DAILY_LIMIT - st.session_state.email_count
-            st.markdown("---")
-            st.subheader("📊 Usage Today")
-            st.progress(st.session_state.email_count / FREE_DAILY_LIMIT)
-            st.write(f"**{remaining} free emails remaining**")
+        # A/B testing preview
+        st.markdown("### 📊 A/B Testing **✨ PREMIUM**")
+        if st.button("🧪 Generate A/B Variants", use_container_width=True):
+            tracker.add_premium_feature_used("A/B Testing")
+            st.success("✨ **A/B Testing unlocked!** Generate 3 different email variants:")
+            
+            variants = [
+                "📧 **Variant A:** Direct approach - 'Quick question about [company]'",
+                "📧 **Variant B:** Value-first - 'Helping [industry] companies save [pain point]'", 
+                "📧 **Variant C:** Social proof - 'How [similar company] achieved [result]'"
+            ]
             
-            if remaining <= 2:
-                st.warning("⚠️ Almost at daily limit!")
-                if st.button("🔓 Upgrade Now", use_container_width=True):
-                    st.markdown("**[Get Unlimited Access →](https://gumroad.com/l/cold-email-unlimited)**")
+            for variant in variants:
+                st.info(variant)
+            
+            st.warning("🚫 **Full A/B testing with metrics requires upgrade** - Track which emails get 3x better responses!")
+            st.caption("💰 **Value:** A/B testing typically increases response rates by 40-60%")
+        
+        # Quality insights
+        st.markdown("### 📈 Quality Insights **✨ PREMIUM**") 
+        st.info("🎯 **Premium Quality Scoring**\n\n• Personalization analysis\n• Industry benchmarking\n• Conversion predictors\n• Improvement suggestions")
+        
+        # Usage warning
+        remaining = tracker.get_remaining_emails()
+        if remaining <= 2:
+            st.warning(f"⚠️ Only {remaining} emails left today!")
     
-    # Main content
-    st.subheader("📁 Upload Your Leads")
+    # Generate email button
+    if st.button("🚀 Generate Premium Email", use_container_width=True, type="primary"):
+        if name and company:
+            if not tracker.can_generate_email():
+                tracker.show_upgrade_prompt("email generation")
+            else:
+                try:
+                    with st.spinner("🤖 AI is crafting your premium personalized email..."):
+                        # Generate email with premium features
+                        result = generate_cold_email(
+                            name=name,
+                            company=company,
+                            company_details=company_details or "",
+                            tone=tone.lower(),
+                            cta_type=cta_type.lower().replace("/", "_") if cta_type != "Custom" else custom_cta,
+                            industry_template=industry_template,
+                            sender_signature=sender_signature
+                        )                        if result:
+                            subject, body, quality_score = result
+                            
+                            # Check if this is a setup error
+                            if subject == "Setup Required":
+                                st.error("🔧 **Premium AI Features Need Setup**")
+                                st.markdown(body)  # This contains the setup instructions
+                                
+                                # Show what users are missing
+                                st.info("🚀 **What you're missing without AI setup:**")
+                                st.markdown("""
+                                - 🤖 **Advanced AI Personalization** (40% better conversion)
+                                - 🎯 **Industry-Specific Intelligence** (10x more relevant)
+                                - 📊 **AI Quality Scoring** (proven metrics)
+                                - 🔍 **Smart Company Analysis** (saves 30+ min research)
+                                """)
+                                
+                                st.success("✨ **Good News:** All premium features work perfectly once set up!")
+                                st.markdown("**💰 Value Unlocked:** $97/month worth of AI features for just $19 lifetime")
+                                
+                                # Still show upgrade CTA
+                                st.markdown("""
+                                <div style='background: linear-gradient(90deg, #FF6B6B, #4ECDC4); padding: 1.5rem; border-radius: 10px; text-align: center; color: white; margin: 1rem 0;'>
+                                    <h3>🔥 Skip Setup - Get Pre-Configured Version</h3>
+                                    <p><strong>Get the fully-configured app with all AI features ready to use</strong></p>
+                                    <a href="https://gumroad.com/l/cold-email-assistant" style="background: white; color: #333; padding: 0.8rem 2rem; border-radius: 25px; text-decoration: none; font-weight: bold; margin-top: 1rem; display: inline-block;">🚀 Get Lifetime Access Now</a>
+                                </div>
+                                """, unsafe_allow_html=True)
+                                return
+                            
+                            # Track usage for successful generation
+                            tracker.increment_email_generation()
+                            tracker.add_premium_feature_used("Premium Email Generation")
+                        
+                        # Display results with premium features
+                        st.success("✅ Premium email generated successfully!")
+                        
+                        col_result1, col_result2 = st.columns([3, 1])
+                        
+                        with col_result1:
+                            st.subheader("📧 Generated Premium Email")
+                            
+                            # Subject line
+                            st.markdown("**📋 Subject Line:**")
+                            st.code(subject, language="text")
+                            
+                            # Email body
+                            st.markdown("**✉️ Email Body:**")
+                            st.text_area("", value=body, height=300, key="generated_email")
+                            
+                            # Premium copy buttons
+                            col_copy1, col_copy2 = st.columns(2)
+                            with col_copy1:
+                                if st.button("📋 Copy Subject", use_container_width=True):
+                                    st.code(f"Subject copied: {subject}")
+                            with col_copy2:
+                                if st.button("📋 Copy Email Body", use_container_width=True):
+                                    st.code("Email body copied to clipboard!")
+                        
+                        with col_result2:
+                            st.markdown("### 📊 Premium Quality Score")
+                            score_color = "🟢" if quality_score >= 8 else "🟡" if quality_score >= 6 else "🔴"
+                            st.markdown(f"## {score_color} {quality_score}/10")
+                            
+                            # Premium quality insights
+                            if quality_score >= 8:
+                                st.success("🚀 Premium Quality!")
+                                st.caption("✅ AI-optimized personalization\n✅ Industry-specific messaging\n✅ Conversion-tested format")
+                            elif quality_score >= 6:
+                                st.warning("📈 Good Quality")
+                                st.caption("✅ Decent personalization\n⚠️ Could be more specific")
+                            else:
+                                st.error("⚡ Needs Premium Boost")
+                                st.caption("💡 Try premium research features")
+                            
+                            st.markdown("### 🎯 Premium Features Used")
+                            features_used = tracker.get_premium_features_used()
+                            for feature in features_used:
+                                st.caption(f"✨ {feature}")
+                            
+                            # Remaining usage
+                            remaining_after = tracker.get_remaining_emails()
+                            if remaining_after > 0:
+                                st.info(f"📧 {remaining_after} emails left today")
+                            else:
+                                st.error("📧 Daily limit reached!")
+                                st.markdown("**[🚀 Get Unlimited →](https://gumroad.com/l/cold-email-assistant)**")
+                
+                except Exception as e:
+                    st.error(f"❌ Error generating email: {str(e)}")
+        else:
+            st.error("❌ Please fill in at least Name and Company fields")
+
+elif page == "📊 Bulk Processing":
+    st.header("📊 Premium Bulk Processing")
     
-    uploaded_file = st.file_uploader(
-        "Choose a CSV file",
-        type=['csv'],
-        help="Upload a CSV with columns: name, email, company, linkedin_url"
-    )
+    # Check bulk export limit
+    if not tracker.can_bulk_export():
+        tracker.show_upgrade_prompt("bulk processing")
+        st.stop()
     
-    # Sample CSV download
-    col1, col2 = st.columns([2, 1])
-    with col2:
-        sample_data = {
-            'name': ['John Smith', 'Jane Doe', 'Mike Johnson', 'Sarah Wilson', 'David Brown'],
-            'email': ['[email protected]', '[email protected]', '[email protected]', '[email protected]', '[email protected]'],
-            'company': ['TechCorp Inc', 'StartupXYZ', 'Creative Agency', 'FutureTech', 'DigitalSolutions'],
-            'linkedin_url': [
-                'https://linkedin.com/company/techcorp',
-                'https://linkedin.com/company/startupxyz', 
-                'https://linkedin.com/company/creative-agency',
-                'https://linkedin.com/company/futuretech',
-                'https://linkedin.com/company/digital-solutions'
-            ]
-        }
-        sample_df = pd.DataFrame(sample_data)
-        csv = sample_df.to_csv(index=False)
-        st.download_button(
-            "📄 Download Sample CSV",
-            csv,
-            "sample_leads.csv",
-            "text/csv"
-        )
+    st.info("🚀 **Premium Bulk Processing** - Process up to 10 leads in demo mode")
     
-    if uploaded_file is not None:
+    # File upload
+    uploaded_file = st.file_uploader("📁 Upload CSV file", type=['csv'])
+    
+    if uploaded_file:
         try:
-            # Load CSV
             df = pd.read_csv(uploaded_file)
             
-            # Validate columns
-            required_columns = ['name', 'email', 'company', 'linkedin_url']
-            missing_columns = [col for col in required_columns if col not in df.columns]
+            # Limit to 10 rows in demo
+            if len(df) > 10:
+                st.warning(f"⚠️ Demo limited to 10 leads. Uploaded {len(df)} leads.")
+                df = df.head(10)
+                st.info("🚀 Upgrade for unlimited bulk processing!")
             
-            if missing_columns:
-                st.error(f"❌ Missing columns: {', '.join(missing_columns)}")
-                st.info("Required columns: name, email, company, linkedin_url")
-            else:
-                st.success(f"✅ Loaded {len(df)} leads")
+            st.success(f"✅ File uploaded! Processing {len(df)} leads in demo mode.")
+            
+            # Show preview
+            st.subheader("👀 Data Preview")
+            st.dataframe(df.head())
+            
+            # Processing options
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                tone = st.selectbox("🎭 Email Tone for All", 
+                                   ["Professional", "Friendly", "Direct", "Consultative ✨"])
                 
-                # Show preview
-                with st.expander("👀 Preview Data"):
-                    st.dataframe(df.head(), use_container_width=True)
+                industry_template = st.selectbox("🏭 Industry Template", 
+                                               ["SaaS/Tech", "E-commerce", "Healthcare", "Generic B2B"],
+                                               index=3)
+            
+            with col2:
+                st.markdown("**✨ Premium Features:**")
+                st.caption("• AI-powered personalization")
+                st.caption("• Industry-specific templates") 
+                st.caption("• Quality scoring")
+                st.caption("• Bulk export")
+            
+            # Process button
+            if st.button("🚀 Process All Leads (Premium Demo)", use_container_width=True, type="primary"):
+                progress_bar = st.progress(0)
+                status_text = st.empty()
                 
-                # Process button
-                if st.button("🚀 Generate Cold Emails", type="primary", use_container_width=True):
-                    
-                    # Check usage limits first
-                    if not check_usage_limit():
-                        show_upgrade_cta()
-                        return
+                results = []
+                
+                for idx, row in df.iterrows():
+                    status_text.text(f"Processing {idx + 1}/{len(df)}: {row['name']} at {row['company']}")
                     
-                    # Check if user will exceed limit with this batch
-                    batch_size = len(df)
-                    if st.session_state.email_count + batch_size > FREE_DAILY_LIMIT and not st.session_state.is_premium:
-                        remaining = FREE_DAILY_LIMIT - st.session_state.email_count
-                        st.warning(f"⚠️ You can only generate {remaining} more emails today. Upgrade for unlimited access!")
+                    try:
+                        # Generate email
+                        result = generate_cold_email(
+                            name=row['name'],
+                            company=row['company'],
+                            company_details="",
+                            tone=tone.lower(),
+                            cta_type="meeting_call",
+                            industry_template=industry_template,
+                            sender_signature=sender_signature
+                        )
                         
-                        if st.button("� Continue with Limited Batch", use_container_width=True):
-                            df = df.head(remaining) if remaining > 0 else df.head(0)
+                        # Check if result is an error/setup message
+                        if isinstance(result, str) and any(error_type in result for error_type in ["Setup Required", "AI Model Error", "Generation Error"]):
+                            results.append({
+                                'name': row['name'],
+                                'company': row['company'],
+                                'email': row.get('email', ''),
+                                'subject': '',
+                                'body': '',
+                                'quality_score': 0,
+                                'status': f'Setup Required: {result[:100]}...'
+                            })
+                        elif result and isinstance(result, tuple) and len(result) == 3:
+                            subject, body, quality_score = result
+                            results.append({
+                                'name': row['name'],
+                                'company': row['company'],
+                                'email': row.get('email', ''),
+                                'subject': subject,
+                                'body': body,
+                                'quality_score': quality_score,
+                                'status': 'Success'
+                            })
                         else:
-                            show_upgrade_cta()
-                            return
+                            results.append({
+                                'name': row['name'],
+                                'company': row['company'],
+                                'email': row.get('email', ''),
+                                'subject': '',
+                                'body': '',
+                                'quality_score': 0,
+                                'status': 'Error: Invalid response from email generator'
+                            })
                     
-                    with st.spinner("�🔄 Processing your leads and generating emails..."):
-                        results = process_leads(df, tone, creativity)
-                        # Increment usage counter
-                        increment_usage()
-                    
-                    if results:
-                        st.success(f"✅ Generated {len(results)} professional emails!")
-                        
-                        # Display metrics
-                        col1, col2, col3 = st.columns(3)
-                        with col1:
-                            st.metric("📨 Emails Generated", len(results))
-                        with col2:
-                            avg_quality = sum(r['quality_score'] for r in results) / len(results)
-                            st.metric("🎯 Avg Quality Score", f"{avg_quality:.1f}")
-                        with col3:
-                            high_quality = len([r for r in results if r['quality_score'] >= 8.0])
-                            st.metric("⭐ High Quality", high_quality)
-                        
-                        # Results table with data validation
-                        st.subheader("📊 Generated Emails")
-                        try:
-                            # Clean and validate results data before display
-                            clean_results = []
-                            for r in results:
-                                # Ensure all values are strings and properly sanitized
-                                clean_result = {
-                                    'name': str(r.get('name', 'Unknown')).replace('\n', ' ').replace('\r', '')[:50],
-                                    'company': str(r.get('company', 'Unknown')).replace('\n', ' ').replace('\r', '')[:50],
-                                    'subject': str(r.get('subject', 'No subject')).replace('\n', ' ').replace('\r', '')[:80],
-                                    'quality_score': round(float(r.get('quality_score', 8.0)), 1)
-                                }
-                                # Validate that quality score is within range
-                                if clean_result['quality_score'] < 1.0 or clean_result['quality_score'] > 10.0:
-                                    clean_result['quality_score'] = 8.0
-                                clean_results.append(clean_result)
-                            
-                            display_df = pd.DataFrame(clean_results)
-                            # Ensure DataFrame has the expected columns
-                            expected_columns = ['name', 'company', 'subject', 'quality_score']
-                            for col in expected_columns:
-                                if col not in display_df.columns:
-                                    display_df[col] = 'N/A'
-                            
-                            st.dataframe(display_df[expected_columns], use_container_width=True, height=300)
-                        except Exception as e:
-                            st.warning("⚠️ Display issue - showing simplified view")
-                            simple_data = [[r['name'], r['company'], f"{r['quality_score']:.1f}"] for r in results]
-                            st.table(pd.DataFrame(simple_data, columns=['Name', 'Company', 'Quality']))
-                        
-                        # Email preview with error handling
-                        st.subheader("📝 Email Preview")
-                        try:
-                            if len(results) > 0:
-                                selected_idx = st.selectbox(
-                                    "Select email to preview:",
-                                    range(min(len(results), 50)),  # Limit to prevent crashes
-                                    format_func=lambda x: f"{results[x]['name']} - {results[x]['company']} (Q: {results[x]['quality_score']:.1f})"
-                                )
-                                
-                                if selected_idx < len(results):
-                                    selected_email = results[selected_idx]
-                                    
-                                    col1, col2 = st.columns([1, 1])
-                                    with col1:
-                                        st.write("**📧 Subject:**")
-                                        # Ensure subject is clean and safe for display
-                                        clean_subject = str(selected_email.get('subject', 'No subject'))
-                                        clean_subject = clean_subject.replace('\n', ' ').replace('\r', '')[:150]
-                                        st.code(clean_subject)
-                                        st.write("**📊 Quality Score:**")
-                                        quality = float(selected_email.get('quality_score', 8.0))
-                                        # Ensure quality is in valid range
-                                        quality = max(1.0, min(10.0, quality))
-                                        st.metric("", f"{quality:.1f}/10")
-                                    
-                                    with col2:
-                                        st.write("**📄 Email Content:**")
-                                        # Ensure content is clean and safe for display
-                                        clean_content = str(selected_email.get('email_content', 'No content'))
-                                        # Remove problematic characters that might cause React errors
-                                        clean_content = clean_content.replace('\r\n', '\n').replace('\r', '\n')
-                                        # Limit length to prevent display issues
-                                        clean_content = clean_content[:2000]
-                                        st.text_area(
-                                            "",
-                                            clean_content,
-                                            height=250,
-                                            disabled=True,
-                                            label_visibility="collapsed"
-                                        )
-                        except Exception as e:
-                            st.error("⚠️ Preview unavailable - but your emails were generated successfully")
-                        
-                        # Export with data validation
-                        st.subheader("📤 Export Results")
-                        try:
-                            # Clean export data with robust validation
-                            export_data = []
-                            for r in results:
-                                # Sanitize all data for CSV export
-                                clean_row = {
-                                    'name': str(r.get('name', 'Unknown')).strip()[:100],
-                                    'email': str(r.get('email', '[email protected]')).strip()[:100],
-                                    'company': str(r.get('company', 'Unknown')).strip()[:100],
-                                    'subject': str(r.get('subject', 'No subject')).replace('\n', ' ').replace('\r', ' ').strip()[:200],
-                                    'email_content': str(r.get('email_content', 'No content')).replace('\r\n', '\n').replace('\r', '\n').strip()[:5000],
-                                    'quality_score': round(max(1.0, min(10.0, float(r.get('quality_score', 8.0)))), 1),
-                                    'status': str(r.get('status', 'success')).strip()[:20]
-                                }
-                                export_data.append(clean_row)
-                            
-                            export_df = pd.DataFrame(export_data)
-                            # Ensure no NaN values that could cause issues
-                            export_df = export_df.fillna('')
-                            csv_data = export_df.to_csv(index=False, encoding='utf-8').encode('utf-8')
-                            
-                            st.download_button(
-                                "📥 Download All Emails (CSV)",
-                                csv_data,
-                                f"cold_emails_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-                                "text/csv",
-                                use_container_width=True
-                            )
-                            
-                            st.info(f"💡 Ready to export {len(results)} professional cold emails for your outreach campaign!")
-                        except Exception as e:
-                            st.error("⚠️ Export issue - please try regenerating")
+                    except Exception as e:
+                        results.append({
+                            'name': row['name'],
+                            'company': row['company'],
+                            'email': row.get('email', ''),
+                            'subject': '',
+                            'body': '',
+                            'quality_score': 0,
+                            'status': f'Error: {str(e)}'
+                        })
                     
-                    else:
-                        st.error("❌ Failed to generate emails. Please try again.")
+                    # Update progress
+                    progress_bar.progress((idx + 1) / len(df))
+                    time.sleep(0.5)
+                
+                # Track usage
+                tracker.increment_bulk_export()
+                tracker.add_premium_feature_used("Bulk Processing")
+                
+                # Show results
+                status_text.text("✅ Premium processing complete!")
+                results_df = pd.DataFrame(results)
+                
+                # Display summary
+                successful = len(results_df[results_df['status'] == 'Success'])
+                
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("📧 Processed", len(results_df))
+                with col2:
+                    st.metric("✅ Successful", successful)
+                with col3:
+                    avg_quality = results_df['quality_score'].mean()
+                    st.metric("⭐ Avg Quality", f"{avg_quality:.1f}/10")
+                
+                # Show results table
+                st.subheader("📊 Results")
+                st.dataframe(results_df)
+                
+                # Download option
+                csv = results_df.to_csv(index=False)
+                st.download_button(
+                    "📥 Download Results (Premium)",
+                    csv,
+                    f"premium_emails_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                    "text/csv",
+                    use_container_width=True
+                )
+                
+                st.success("✨ Premium bulk processing complete! Upgrade for unlimited processing.")
         
         except Exception as e:
-            st.error(f"❌ Error loading CSV: {str(e)}")
-            st.info("Please ensure your CSV file has the correct format and encoding.")
+            st.error(f"❌ Error processing file: {str(e)}")
+
+elif page == "📈 Analytics Preview":
+    st.header("📈 Premium Analytics Preview")
+    
+    st.info("🚀 **Premium Analytics Dashboard** - Get insights on your email performance")
+    
+    # Mock analytics data
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("📧 Total Emails", "127", "+23 this week")
+    with col2:
+        st.metric("📈 Avg Quality", "8.3/10", "+0.5 improvement")
+    with col3:
+        st.metric("🏢 Companies", "45", "+12 this week")
+    with col4:
+        st.metric("⭐ Top Score", "9.2/10", "Healthcare emails")
+    
+    # Charts preview
+    st.subheader("📊 Performance Insights")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("**📈 Quality Trends**")
+        st.line_chart(pd.DataFrame({
+            'Day': range(7),
+            'Quality Score': [7.2, 7.8, 8.1, 8.3, 8.5, 8.2, 8.7]
+        }).set_index('Day'))
+    
+    with col2:
+        st.markdown("**🏭 Industry Performance**")
+        st.bar_chart(pd.DataFrame({
+            'SaaS': [8.5],
+            'Healthcare': [9.2],
+            'Manufacturing': [7.8],
+            'E-commerce': [8.1]
+        }))
+    
+    # Premium features preview
+    st.subheader("✨ Premium Analytics Features")
+    
+    features = [
+        "📊 Conversion tracking integration",
+        "📈 A/B testing results dashboard", 
+        "🎯 Industry benchmarking",
+        "📧 Email performance heatmaps",
+        "🔍 Competitor analysis",
+        "📱 Mobile-optimized reports",
+        "🔔 Performance alerts",
+        "📊 Export to PowerBI/Tableau"
+    ]
+    
+    for i, feature in enumerate(features):
+        if i % 2 == 0:
+            col1, col2 = st.columns(2)
+        
+        with col1 if i % 2 == 0 else col2:
+            st.info(feature)
     
-    # Footer
     st.markdown("---")
-    st.markdown(
-        "<div style='text-align: center; color: #666;'>"
-        "<p>🚀 Built with Streamlit & Mistral-7B | 💡 Use quality company info for best results</p>"
-        "<p>⚡ Powered by advanced AI with intelligent fallbacks for 100% success rate</p>"
-        "</div>",
-        unsafe_allow_html=True
-    )
+    st.success("🚀 **Ready to unlock full analytics?** Get unlimited access + advanced reporting!")
+    
+    if st.button("🚀 Upgrade to Premium Analytics", use_container_width=True, type="primary"):
+        st.markdown("**[🔗 Get Cold Email Assistant Pro →](https://gumroad.com/l/cold-email-assistant)**")
 
-if __name__ == "__main__":
-    main()
+# Footer with upgrade CTA
+st.markdown("---")
+st.markdown("""
+<div style='text-align: center; padding: 2rem; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); border-radius: 10px; color: white; margin-top: 2rem;'>
+    <h3>🚀 Ready for Unlimited Access?</h3>
+    <p>You've experienced the premium features - now get unlimited access!</p>
+    <p><strong>✅ Unlimited emails ✅ Unlimited research ✅ Advanced analytics ✅ Priority support</strong></p>
+    <p><a href="https://gumroad.com/l/cold-email-assistant" style="color: #FFD700; font-weight: bold; text-decoration: none;">Get Lifetime Access for $19 →</a></p>
+</div>
+""", unsafe_allow_html=True)