import gradio as gr
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LogisticRegression
import pickle
import os

# Set the visual style
plt.style.use('ggplot')
sns.set_context("talk")
plt.rcParams['figure.figsize'] = (12, 8)

# Function to generate synthetic meeting data
def generate_meeting_data(n_meetings=500):
    """Generate synthetic meeting data with various parameters."""
    
    np.random.seed(42)  # For reproducibility
    
    # Generate random meeting features
    data = {
        'meeting_id': range(1, n_meetings + 1),
        'duration_minutes': np.random.choice(
            [15, 30, 45, 60, 90, 120], 
            size=n_meetings, 
            p=[0.1, 0.25, 0.2, 0.3, 0.1, 0.05]
        ),
        'n_participants': np.random.randint(2, 15, size=n_meetings),
        'presenter_talk_percent': np.random.uniform(30, 95, size=n_meetings),
        'questions_asked': np.random.randint(0, 12, size=n_meetings),
        'actionable_items': np.random.randint(0, 8, size=n_meetings),
        'silence_percent': np.random.uniform(0, 40, size=n_meetings),
        'topic_changes': np.random.randint(1, 10, size=n_meetings),
        'slides_count': np.random.randint(0, 40, size=n_meetings)
    }
    
    # Add meeting types
    meeting_topics = [
        "Weekly Status Update", "Quarterly Planning", "Project Kickoff",
        "Brainstorming Session", "Customer Feedback Review", "Budget Review",
        "Team Building", "Product Demo", "Strategic Alignment", "Post-Mortem",
        "OKR Review", "All-Hands", "Happy Hour Planning"
    ]
    
    data['meeting_type'] = np.random.choice(meeting_topics, size=n_meetings)
    
    # Convert to dataframe
    df = pd.DataFrame(data)
    
    # Calculate the "email score" based on various factors
    df['email_score'] = (
        # Longer meetings get lower scores (less email-able)
        -0.2 * df['duration_minutes'] +
        # More participants = less email-able
        -0.5 * df['n_participants'] +
        # If one person does all the talking, could be an email
        0.3 * df['presenter_talk_percent'] +
        # Few questions = could be an email
        -3 * df['questions_asked'] +
        # Few action items = could be an email
        -5 * df['actionable_items'] +
        # Lots of silence = waste of time
        0.5 * df['silence_percent'] +
        # Lots of topic changes = less email-able
        -2 * df['topic_changes'] +
        # Many slides = information dump, could be emailed
        0.2 * df['slides_count'] +
        # Random noise
        np.random.normal(0, 15, size=n_meetings)
    )
    
    # Normalize to 0-100 scale
    df['email_score'] = (df['email_score'] - df['email_score'].min()) / (df['email_score'].max() - df['email_score'].min()) * 100
    df['email_score'] = df['email_score'].round(1)
    
    # Add binary classification (could have been an email or not)
    df['could_be_email'] = (df['email_score'] > 65).astype(int)
    
    return df

# Function to train the model
def train_model(df):
    # Select features
    features = [
        'duration_minutes', 'n_participants', 'presenter_talk_percent',
        'questions_asked', 'actionable_items', 'silence_percent',
        'topic_changes', 'slides_count'
    ]
    
    X = df[features]
    y = df['could_be_email']
    
    # Train model
    model = LogisticRegression(random_state=42)
    model.fit(X, y)
    
    return model, features

# Function to predict whether a meeting could be an email
def predict_meeting(
    duration, participants, presenter_talk, questions, 
    action_items, silence, topic_changes, slides
):
    # Create a dataframe with the input values
    input_data = pd.DataFrame({
        'duration_minutes': [duration],
        'n_participants': [participants],
        'presenter_talk_percent': [presenter_talk],
        'questions_asked': [questions],
        'actionable_items': [action_items],
        'silence_percent': [silence],
        'topic_changes': [topic_changes],
        'slides_count': [slides]
    })
    
    # Make prediction
    probability = model.predict_proba(input_data)[0][1] * 100
    is_email = model.predict(input_data)[0]
    
    # Calculate wasted time
    wasted_minutes = duration * participants if is_email else duration * participants * 0.2
    wasted_workdays = wasted_minutes / (8 * 60)  # assuming 8-hour workday
    
    # Generate visualization
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
    
    # Email-ability gauge chart
    import matplotlib.patches as mpatches
    
    # Create a semicircular gauge
    theta = np.linspace(0, np.pi, 100)
    r = 1.0
    
    # Convert email probability to color (red for high, green for low)
    from matplotlib.colors import LinearSegmentedColormap
    colors = [(0.0, 0.7, 0.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0)]  # green -> yellow -> red
    cmap = LinearSegmentedColormap.from_list('email_cmap', colors, N=100)
    gauge_color = cmap(probability / 100)
    
    # Draw the gauge
    ax1.plot(r * np.cos(theta), r * np.sin(theta), color='gray', linewidth=3)
    
    # Calculate the position for the needle
    needle_theta = np.pi * probability / 100
    ax1.plot([0, r * np.cos(needle_theta)], [0, r * np.sin(needle_theta)], color='black', linewidth=4)
    
    # Draw colored arc for the current probability
    theta_prob = np.linspace(0, needle_theta, 100)
    ax1.fill_between(r * np.cos(theta_prob), 0, r * np.sin(theta_prob), color=gauge_color, alpha=0.7)
    
    # Add probability text
    ax1.text(0, -0.2, f"{probability:.1f}% Email-able", ha='center', fontsize=24, fontweight='bold')
    
    # Add labels
    ax1.text(-1, 0.1, "Meeting", fontsize=16)
    ax1.text(1, 0.1, "Email", fontsize=16)
    
    # Decision text
    if is_email:
        decision_text = "VERDICT: This could have been an email!"
    else:
        decision_text = "VERDICT: This meeting seems necessary."
    
    ax1.text(0, -0.4, decision_text, ha='center', fontsize=20, 
             fontweight='bold', color='red' if is_email else 'green')
    
    # Set axis limits and remove ticks
    ax1.set_xlim(-1.2, 1.2)
    ax1.set_ylim(-0.5, 1.2)
    ax1.axis('off')
    ax1.set_title("Meeting Email-ability Meter", fontsize=18)
    
    # Second chart: Wasted time visualization
    labels = ['This Meeting', 'Annual Impact\n(if weekly)']
    values = [wasted_minutes, wasted_minutes * 52]  # Weekly for a year
    
    ax2.bar(labels, values, color=['#ff9999', '#ff5555'])
    
    # Add value labels on top of bars
    for i, v in enumerate(values):
        if i == 0:
            ax2.text(i, v + 5, f"{v:.0f} person-minutes", ha='center', fontsize=14)
        else:
            hours = v / 60
            days = hours / 8
            ax2.text(i, v + 5, f"{hours:.0f} hours\n({days:.1f} workdays)", ha='center', fontsize=14)
    
    ax2.set_title("Time Impact Analysis", fontsize=18)
    ax2.set_ylabel("Wasted Time (person-minutes)", fontsize=14)
    
    plt.tight_layout()
    
    return fig, probability, is_email, wasted_minutes, wasted_workdays

# Create a personalized report
def generate_report(
    meeting_type, duration, participants, presenter_talk, questions, 
    action_items, silence, topic_changes, slides, is_email, probability,
    wasted_minutes, wasted_workdays
):
    if is_email:
        title = "📧 THIS MEETING COULD HAVE BEEN AN EMAIL 📧"
        color = "red"
    else:
        title = "✅ This meeting appears to be necessary"
        color = "green"
    
    report = f"""
    <div style="font-family: Arial, sans-serif; padding: 20px; max-width: 800px; margin: 0 auto;">
        <h1 style="color: {color}; text-align: center;">{title}</h1>
        
        <div style="background-color: #f5f5f5; border-radius: 10px; padding: 20px; margin-top: 20px;">
            <h2>Meeting Analysis</h2>
            <p><strong>Meeting Type:</strong> {meeting_type}</p>
            <p><strong>Duration:</strong> {duration} minutes</p>
            <p><strong>Participants:</strong> {participants} people</p>
            <p><strong>Email-ability Score:</strong> <span style="font-size: 1.2em; font-weight: bold;">{probability:.1f}%</span></p>
        </div>
        
        <div style="background-color: #fff3f3; border-radius: 10px; padding: 20px; margin-top: 20px;">
            <h2>Economic Impact</h2>
            <p><strong>Time Wasted in This Meeting:</strong> {wasted_minutes:.0f} person-minutes</p>
            <p><strong>Equivalent Workdays:</strong> {wasted_workdays:.2f} days</p>
            <p><strong>Annual Impact (if held weekly):</strong> {wasted_workdays * 52:.1f} workdays</p>
            <p><strong>Estimated Annual Cost:</strong> ${wasted_minutes * 52 * 0.5:.0f}</p>
        </div>
    """
    
    # Add recommendations based on the analysis
    report += """
        <div style="background-color: #f0f8ff; border-radius: 10px; padding: 20px; margin-top: 20px;">
            <h2>Recommendations</h2>
    """
    
    if is_email:
        report += """
            <ul>
                <li>Convert this meeting to an async email or Slack thread</li>
                <li>If a meeting is necessary, reduce the participant count by 50%</li>
                <li>Consider recording a 5-minute video update instead</li>
                <li>Create a shared document for status updates</li>
            </ul>
        """
    else:
        report += """
            <ul>
                <li>This meeting seems justified, but consider reducing duration</li>
                <li>Send an agenda in advance to increase focus</li>
                <li>Use a timer to keep discussions on track</li>
                <li>End with clear action items and owners</li>
            </ul>
        """
    
    report += """
        </div>
        
        <div style="text-align: center; font-style: italic; margin-top: 30px; color: #666;">
            <p>Analysis generated by the Meeting-That-Could-Have-Been-An-Email Detector</p>
            <p>Results are for entertainment purposes. Actual productivity may vary.</p>
        </div>
    </div>
    """
    
    return report

# Generate dataset and train model when the app starts
print("Generating synthetic data and training model...")
df = generate_meeting_data()
model, features = train_model(df)

# Create Gradio interface
with gr.Blocks(title="Meeting Email Detector") as demo:
    gr.Markdown(
        """
        # 📧 The Meeting-That-Could-Have-Been-An-Email Detector
        
        Have you ever sat through a meeting thinking "this could have been an email"?
        Now you can scientifically prove it! Enter your meeting details below to analyze
        whether your meeting is necessary or could be replaced with an email.
        
        *Note: This is a humor project using synthetic data. Results are meant to be entertaining, not prescriptive.*
        """
    )
    
    with gr.Row():
        with gr.Column():
            meeting_type = gr.Dropdown(
                choices=[
                    "Weekly Status Update", "Quarterly Planning", "Project Kickoff",
                    "Brainstorming Session", "Customer Feedback Review", "Budget Review",
                    "Team Building", "Product Demo", "Strategic Alignment", "Post-Mortem",
                    "OKR Review", "All-Hands", "Happy Hour Planning"
                ],
                label="Meeting Type",
                value="Weekly Status Update"
            )
            
            duration = gr.Slider(
                minimum=15, maximum=120, value=60, step=15,
                label="Duration (minutes)"
            )
            
            participants = gr.Slider(
                minimum=2, maximum=20, value=6, step=1,
                label="Number of Participants"
            )
            
            presenter_talk = gr.Slider(
                minimum=10, maximum=100, value=70, step=5,
                label="Presenter Talk Percentage (%)"
            )
            
            questions = gr.Slider(
                minimum=0, maximum=15, value=4, step=1,
                label="Expected Questions from Audience"
            )
    
        with gr.Column():
            action_items = gr.Slider(
                minimum=0, maximum=10, value=3, step=1,
                label="Actionable Items Expected"
            )
            
            silence = gr.Slider(
                minimum=0, maximum=50, value=15, step=5,
                label="Expected Silence/Awkward Pauses (%)"
            )
            
            topic_changes = gr.Slider(
                minimum=1, maximum=15, value=4, step=1,
                label="Number of Distinct Topics"
            )
            
            slides = gr.Slider(
                minimum=0, maximum=50, value=10, step=1,
                label="Number of Slides/Visual Aids"
            )
    
    analyze_btn = gr.Button("Analyze This Meeting", variant="primary")
    
    with gr.Row():
        with gr.Column():
            result_plot = gr.Plot(label="Analysis Results")
        
        with gr.Column():
            with gr.Row():
                email_score = gr.Number(label="Email-ability Score (%)")
                is_email = gr.Checkbox(label="Could Be An Email?")
            
            with gr.Row():
                wasted_time = gr.Number(label="Time Wasted (person-minutes)")
                wasted_days = gr.Number(label="Equivalent Workdays")
    
    report_html = gr.HTML(label="Detailed Report")
    
    analyze_btn.click(
        fn=lambda *args: predict_meeting(*args) + (args[0],),  # Include meeting_type in output
        inputs=[
            duration, participants, presenter_talk, questions,
            action_items, silence, topic_changes, slides
        ],
        outputs=[result_plot, email_score, is_email, wasted_time, wasted_days]
    ).then(
        fn=generate_report,
        inputs=[
            meeting_type, duration, participants, presenter_talk, questions,
            action_items, silence, topic_changes, slides, is_email, email_score,
            wasted_time, wasted_days
        ],
        outputs=report_html
    )
    
    gr.Markdown(
        """
        ## How It Works
        
        This tool uses a machine learning model trained on synthetic data representing thousands of meetings.
        The model analyzes meeting characteristics to determine whether the meeting could be replaced with asynchronous communication.
        
        Key factors that make a meeting "email-able":
        - High presenter talk percentage (one-way information flow)
        - Few questions from participants
        - Few actionable outcomes
        - Many participants relative to the decisions being made
        
        ## About This Project
        
        This is a humor project that pokes fun at corporate meeting culture. While the analysis uses real data science techniques,
        the underlying data is synthetic. The tool is meant to be entertaining while making us think about how we use our time at work.
        
        Created as a data science portfolio project to demonstrate data visualization, interactive web apps, and a bit of workplace humor.
        """
    )

# Launch the app
if __name__ == "__main__":
    demo.launch()