app.py

import gradio as gr
import random
import pandas as pd
import numpy as np
import os
from sample_data import generate_sales_data, generate_sql_query
from additional_data import generate_customer_data, generate_product_data, generate_website_analytics, generate_marketing_campaign_data, generate_ml_datasets

# Check if sample data exists, if not generate it
if not os.path.exists('sample_sales_data.csv'):
    sample_df = generate_sales_data(500)  # Generate a smaller dataset for demo
    sample_df.to_csv('sample_sales_data.csv', index=False)

# Check if additional data exists, if not generate it
if not os.path.exists('sample_customer_data.csv'):
    # Generate and save all additional datasets
    customer_df = generate_customer_data(300)
    product_df = generate_product_data(150)
    web_analytics_df = generate_website_analytics(300)
    campaigns_df = generate_marketing_campaign_data(100)
    ml_datasets = generate_ml_datasets()
    
    # Save to CSV
    customer_df.to_csv('sample_customer_data.csv', index=False)
    product_df.to_csv('sample_product_data.csv', index=False)
    web_analytics_df.to_csv('sample_web_analytics.csv', index=False)
    campaigns_df.to_csv('sample_marketing_campaigns.csv', index=False)
    
    # Save ML datasets
    for name, dataset in ml_datasets.items():
        dataset.to_csv(f'sample_{name}_data.csv', index=False)

# Load sample data
sample_sales_data = pd.read_csv('sample_sales_data.csv')
sample_customer_data = pd.read_csv('sample_customer_data.csv')
sample_product_data = pd.read_csv('sample_product_data.csv')
sample_web_analytics = pd.read_csv('sample_web_analytics.csv')
sample_campaigns = pd.read_csv('sample_marketing_campaigns.csv')

# Load ML datasets if they exist
ml_datasets = {}
for name in ['iris', 'wine', 'diabetes']:
    file_path = f'sample_{name}_data.csv'
    if os.path.exists(file_path):
        ml_datasets[name] = pd.read_csv(file_path)

sample_sql_query = generate_sql_query()

# Create relationships between tables for relational queries
# Add customer info to sales data for a sample of orders
customer_ids = sample_customer_data['CustomerID'].sample(len(sample_sales_data)).values
sample_sales_data['CustomerID'] = customer_ids

# Add product info to sales data 
product_ids = sample_product_data['ProductID'].sample(len(sample_sales_data), replace=True).values
sample_sales_data['ProductID'] = product_ids

# Connect products to campaigns for marketing analysis
product_category_map = dict(zip(sample_product_data['ProductID'], sample_product_data['Category']))
sample_campaigns['TargetCategory'] = sample_campaigns['CampaignID'].apply(
    lambda x: random.choice(list(product_category_map.values()))
)

# Sample relational scenarios with multiple tables
relational_scenarios = [
    {
        "title": "Customer Purchase Analysis",
        "description": "You have customer data and sales transaction data. How would you prompt AI to analyze customer purchasing patterns and segment customers based on their buying behavior?",
        "level": "Intermediate",
        "category": "Analytics",
        "tables": ["customer_data", "sales_data"],
        "ideal_prompt": "Analyze the relationship between customer profiles and their purchasing patterns by joining these datasets. Please: 1) Identify which customer segments (by age group and region) have the highest average order value, 2) Determine if there's correlation between customer income level and purchase frequency, 3) Find which product categories are most popular among different customer segments, and 4) Recommend targeted marketing approaches based on these insights.",
        "answer": "An effective analysis would show that income levels positively correlate with average order value but not necessarily purchase frequency. VIP customers from Western regions typically have the highest lifetime value. Electronics are popular among higher-income groups, while Clothing has broad appeal across segments.",
        "sample_data": {
            "customer_data": sample_customer_data.head(10).to_html(),
            "sales_data": sample_sales_data.head(10).to_html()
        },
    },
    {
        "title": "Product Performance and Inventory Optimization",
        "description": "You have product data and sales transaction data. How would you prompt AI to identify best-selling products and optimize inventory levels?",
        "level": "Advanced",
        "category": "Supply Chain",
        "tables": ["product_data", "sales_data"],
        "ideal_prompt": "Analyze the product and sales data to optimize inventory management. Please: 1) Calculate the sales velocity for each product category over the past 3 months, 2) Identify products with inventory levels below their reorder point but high sales velocity, 3) Find products with excess inventory relative to their sales velocity, and 4) Create a prioritized restocking list with recommended order quantities based on historical sales patterns.",
        "answer": "Analysis should identify Electronics and Home categories as having the highest sales velocity. Several products in the Electronics category are below reorder points and require immediate restocking. Clothing items have the most excess inventory. The optimal restocking strategy uses a tiered approach based on category-specific demand patterns.",
        "sample_data": {
            "product_data": sample_product_data.head(10).to_html(),
            "sales_data": sample_sales_data.head(10).to_html()
        },
    },
    {
        "title": "Marketing Campaign ROI and Customer Response",
        "description": "You have marketing campaign data, customer profiles, and sales data. How would you prompt AI to evaluate campaign effectiveness across different customer segments?",
        "level": "Advanced",
        "category": "Marketing",
        "tables": ["campaign_data", "customer_data", "sales_data"],
        "ideal_prompt": "Analyze how different marketing campaigns perform across customer segments using these three datasets. Please: 1) Join the datasets to connect campaigns to customer segments and resulting sales, 2) Calculate ROI by campaign type and customer segment, 3) Identify which types of customers respond best to which campaign types, 4) Analyze if certain product categories perform better with specific campaign types, and 5) Recommend an optimal marketing channel mix for each major customer segment.",
        "answer": "Email campaigns show the highest ROI for existing VIP customers (28% higher than average), while Social campaigns are most effective for new customers. Search campaigns drive the most Electronics sales, and Video campaigns perform best for higher-priced items. The optimal channel mix varies by segment, with a 40/30/20/10 split between Email/Social/Search/Display for VIP customers.",
        "sample_data": {
            "campaign_data": sample_campaigns.head(10).to_html(),
            "customer_data": sample_customer_data.head(10).to_html(),
            "sales_data": sample_sales_data.head(10).to_html()
        },
    },
    {
        "title": "Website Analytics and Sales Conversion Patterns",
        "description": "You have website analytics data and sales transaction data. How would you prompt AI to analyze the customer journey from website visits to purchases?",
        "level": "Advanced",
        "category": "Web Analytics",
        "tables": ["web_analytics", "sales_data"],
        "ideal_prompt": "Analyze the customer journey from website behavior to completed purchases using these datasets. Please: 1) Identify which traffic sources lead to the highest conversion rates, 2) Analyze the relationship between page types visited and product categories purchased, 3) Determine if there are device-specific patterns in purchasing behavior, 4) Calculate the average time from first visit to purchase completion across different customer segments, and 5) Recommend website optimization strategies based on these patterns.",
        "answer": "Organic Search has the highest overall conversion rate (3.2%), while Email traffic converts best for returning customers (4.7%). Product pages for Electronics items receive the most visits but Category pages have better conversion rates. Mobile users show 20% lower average order values but 15% higher purchase frequency than Desktop users. The average time to purchase is 3.2 days, with significant variation by product category.",
        "sample_data": {
            "web_analytics": sample_web_analytics.head(10).to_html(),
            "sales_data": sample_sales_data.head(10).to_html()
        },
    }
]

# Sample scenarios based on PRD
scenarios = [
    {
        "title": "Data Cleaning in Power BI",
        "description": "You have a messy sales dataset with duplicates, missing values, and inconsistent date formats. How would you instruct AI to clean this data in Power BI?",
        "level": "Beginner",
        "category": "Power BI",
        "ideal_prompt": "Clean this sales dataset in Power BI by: 1) Removing duplicate rows based on Order ID, 2) Filling missing values in the 'Revenue' column with the average, 3) Standardizing all date columns to MM/DD/YYYY format, and 4) Creating a calculated column for profit margin (Revenue - Cost)/Revenue.",
        "answer": "First, I'd use the Remove Duplicates function on the OrderID column. Then, create a measure for the average Revenue and use it in a Column From Examples feature to fill missing values. For dates, I'd apply a custom transformation with Text.From(Date) to standardize the format. Finally, I'd add a calculated column with the formula: ProfitMargin = (Revenue - Cost) / Revenue.",
        "sample_data": sample_sales_data.head(10).to_html(),
    },
    {
        "title": "SQL Query Optimization",
        "description": "Your dashboard's SQL query is taking too long to execute. The query joins multiple tables and uses several subqueries. How would you ask AI to optimize it?",
        "level": "Intermediate",
        "category": "SQL",
        "ideal_prompt": "Optimize this SQL query that's running slowly: [paste query]. Specifically: 1) Check for missing indexes on join columns, 2) Rewrite any nested subqueries as CTEs, 3) Identify unnecessary JOINs, and 4) Suggest a query plan that would reduce execution time.",
        "answer": "The query can be optimized by: 1) Adding indexes on customer_id, order_id columns across all tables, 2) The subquery calculating items_per_order should be converted to a CTE, 3) The LEFT JOIN to returns table is unnecessary unless filtering on return data, 4) Move the blacklist filtering earlier in the query logic, and 5) Add WHERE clauses before joining to large tables to reduce the working set size.",
        "sample_data": f"<pre>{sample_sql_query}</pre>",
    },
    {
        "title": "Customer Segmentation Analysis",
        "description": "You need to segment customers based on their purchasing behavior, demographics, and value. How would you prompt AI to help create meaningful customer segments?",
        "level": "Intermediate",
        "category": "Analytics",
        "ideal_prompt": "Analyze this customer dataset to create actionable segments. Please: 1) Identify key variables for segmentation (e.g., purchase frequency, total spent, recency), 2) Suggest appropriate clustering methods (e.g., K-means, hierarchical), 3) Recommend optimal number of segments, and 4) Describe characteristics of each segment with marketing recommendations.",
        "sample_data": sample_customer_data.head(10).to_html(),
    },
    {
        "title": "Product Inventory Optimization",
        "description": "Your e-commerce store has inventory management challenges with some products frequently out of stock while others have excess inventory. How would you ask AI to help optimize your inventory levels?",
        "level": "Advanced",
        "category": "Supply Chain",
        "ideal_prompt": "Analyze this product inventory dataset to optimize stock levels. Please: 1) Calculate optimal reorder points based on historical sales velocity, 2) Identify products with excess inventory that should be discounted, 3) Flag products frequently out of stock that need higher safety stock, and 4) Create a prioritized list of inventory actions needed.",
        "sample_data": sample_product_data.head(10).to_html(),
    },
    {
        "title": "Website Analytics Dashboard",
        "description": "You have website analytics data and need to create an executive dashboard to track key performance indicators. How would you instruct AI to help design and implement this dashboard?",
        "level": "Intermediate",
        "category": "Web Analytics",
        "ideal_prompt": "Help me design a website analytics dashboard in [tool] using this dataset. Include: 1) Key metrics to track (visits, bounce rate, conversion rate), 2) Trend charts showing performance over time, 3) Segment analysis by device type and traffic source, 4) Anomaly detection for unusual traffic patterns, and 5) A clear layout with the most important KPIs prominently displayed.",
        "sample_data": sample_web_analytics.head(10).to_html(),
    },
    {
        "title": "Marketing Campaign ROI Analysis",
        "description": "You've run multiple marketing campaigns across different channels and need to analyze their performance and ROI. How would you prompt AI to help with this analysis?",
        "level": "Advanced",
        "category": "Marketing",
        "ideal_prompt": "Analyze the ROI and effectiveness of these marketing campaigns. Please: 1) Calculate and compare key metrics (CTR, conversion rate, CPA) across campaign types, 2) Identify the highest and lowest performing campaigns based on ROI, 3) Analyze which audience segments responded best to which campaign types, 4) Recommend optimal budget allocation for future campaigns based on performance data.",
        "sample_data": sample_campaigns.head(10).to_html(),
    },
    {
        "title": "Pandas DataFrame Transformation",
        "description": "You need to transform a customer transaction dataset for a churn analysis. The data requires grouping, aggregation, and feature creation. How would you prompt AI to help?",
        "level": "Advanced",
        "category": "Python",
        "ideal_prompt": "Transform this pandas DataFrame of customer transactions for churn analysis. Steps needed: 1) Group transactions by customer_id, 2) Create features for average purchase value, frequency, and recency, 3) Flag customers with declining purchase trends over the last 3 months, 4) Handle outliers using IQR method, and 5) Export the result as a clean CSV file.",
        "sample_data": sample_sales_data.head(10).to_html(),
    }
]

# Combining relational and regular scenarios
all_scenarios = relational_scenarios + scenarios

# AI-generated scenarios templates
ai_scenario_templates = [
    {
        "title_prefix": "Data Analysis with ",
        "tools": ["Power BI", "Tableau", "Excel", "Python", "R", "SQL"],
        "data_types": ["sales", "customer", "financial", "survey", "marketing", "operational"],
        "problems": ["missing values", "outliers", "inconsistent formats", "duplicates", "aggregation needs"],
        "level_options": ["Beginner", "Intermediate", "Advanced"]
    },
    {
        "title_prefix": "Visualization in ",
        "tools": ["Power BI", "Tableau", "Matplotlib", "Seaborn", "D3.js", "Excel"],
        "data_types": ["time series", "categorical", "geospatial", "hierarchical", "correlation", "comparison"],
        "problems": ["finding the right chart type", "color selection", "handling scale issues", "showing too many variables", "highlighting key insights"],
        "level_options": ["Beginner", "Intermediate", "Advanced"]
    },
    {
        "title_prefix": "Query Optimization for ",
        "tools": ["SQL Server", "PostgreSQL", "MySQL", "BigQuery", "Snowflake", "DynamoDB"],
        "data_types": ["relational", "document", "key-value", "graph", "time series", "data warehouse"],
        "problems": ["slow joins", "inefficient filters", "missing indexes", "poor aggregation", "subquery complexity"],
        "level_options": ["Beginner", "Intermediate", "Advanced"]
    },
    {
        "title_prefix": "Machine Learning with ",
        "tools": ["scikit-learn", "TensorFlow", "PyTorch", "KNIME", "RapidMiner", "AutoML"],
        "data_types": ["structured", "unstructured", "image", "text", "time series", "categorical"],
        "problems": ["feature selection", "model tuning", "overfitting", "imbalanced classes", "model interpretation"],
        "level_options": ["Intermediate", "Advanced"]
    },
    {
        "title_prefix": "Customer Analytics using ",
        "tools": ["Python", "R", "Excel", "Power BI", "Tableau", "SQL"],
        "data_types": ["purchase history", "demographics", "behavioral", "survey", "engagement", "loyalty"],
        "problems": ["segmentation", "lifetime value calculation", "churn prediction", "next purchase prediction", "recommendation systems"],
        "level_options": ["Beginner", "Intermediate", "Advanced"]
    }
]

# Generate an AI scenario
def generate_ai_scenario():
    template = random.choice(ai_scenario_templates)
    
    tool = random.choice(template["tools"])
    data_type = random.choice(template["data_types"])
    problem = random.choice(template["problems"])
    level = random.choice(template["level_options"])
    
    title = f"{template['title_prefix']}{tool}"
    
    description = f"You're working with {data_type} data and encountering issues with {problem}. " + \
                 f"How would you instruct an AI assistant to help you solve this problem using {tool}?"
    
    ideal_prompt = f"Help me address {problem} in my {data_type} data using {tool}. " + \
                  f"Please provide a step-by-step approach, including how to identify the issue, " + \
                  f"resolve it efficiently, and verify the solution is working."
    
    # Select appropriate sample data based on the scenario
    if "customer" in data_type or "segmentation" in problem or "churn" in problem:
        sample_data = sample_customer_data.head(10).to_html()
    elif "product" in data_type or "inventory" in problem:
        sample_data = sample_product_data.head(10).to_html()
    elif "web" in data_type or "traffic" in problem or "visitor" in problem:
        sample_data = sample_web_analytics.head(10).to_html()
    elif "campaign" in data_type or "marketing" in data_type or "ROI" in problem:
        sample_data = sample_campaigns.head(10).to_html()
    elif "model" in problem or "machine learning" in tool.lower() or "classification" in problem:
        # Use one of the ML datasets
        if ml_datasets:
            dataset_name = random.choice(list(ml_datasets.keys()))
            sample_data = ml_datasets[dataset_name].head(10).to_html()
        else:
            sample_data = sample_sales_data.head(10).to_html()
    else:
        sample_data = sample_sales_data.head(10).to_html() if random.random() > 0.5 else f"<pre>{sample_sql_query}</pre>"
    
    return {
        "title": title,
        "description": description,
        "level": level,
        "category": tool,
        "ideal_prompt": ideal_prompt,
        "sample_data": sample_data
    }

# Simulated user progress
user_progress = {
    "completed_scenarios": 0,
    "skill_level": "Beginner",
    "badges": [],
    "scores": []
}

# Leaderboard (simulated)
leaderboard = [
    {"username": "data_ninja", "score": 4.8, "completed": 15},
    {"username": "prompt_master", "score": 4.7, "completed": 12},
    {"username": "ai_whisperer", "score": 4.5, "completed": 10},
    {"username": "you", "score": 0, "completed": 0}
]

# Tips for effective prompting
prompt_tips = [
    "Be specific about the exact steps you want the AI to perform",
    "Mention the tools or libraries the AI should use (e.g., Power BI, pandas)",
    "Specify how to handle edge cases like missing values or outliers",
    "Include context about the data structure and your goal",
    "Break complex tasks into numbered steps",
    "Use clear, concise language rather than vague instructions",
    "Provide examples when possible to clarify your expectations",
    "Request explanations when solutions are complex",
    "Ask for alternatives to compare different approaches",
    "Define success criteria so the AI knows what a good result looks like"
]

# Display random tip
def get_random_tip():
    tip = random.choice(prompt_tips)
    return f"**Tip:** {tip}"

# Simulate AI evaluation of prompts
def evaluate_prompt(user_prompt, scenario):
    """Evaluate user's prompt quality"""
    if not user_prompt.strip():
        return {
            "score": 0,
            "feedback": "You haven't provided any prompt. Please try again."
        }
    
    # In a real app, this would use an LLM to evaluate
    # For demo, we're using a simple heuristic
    
    # Check prompt length (too short is likely insufficient)
    length_score = min(len(user_prompt.split()) / 30, 1) * 5
    
    # Check for keywords related to the scenario
    keywords = scenario["ideal_prompt"].lower().split()
    keyword_matches = sum(1 for word in user_prompt.lower().split() if word in keywords)
    keyword_score = min(keyword_matches / 10, 1) * 5
    
    # Calculate overall score (1-5)
    final_score = round((length_score + keyword_score) / 2, 1)
    final_score = max(1, min(5, final_score))  # Clamp between 1-5
    
    # Generate feedback
    if final_score < 2:
        feedback = "Your prompt needs significant improvement. It lacks specificity and clear instructions."
    elif final_score < 3:
        feedback = "Your prompt is basic but could use more detail. Try specifying exact steps and parameters."
    elif final_score < 4:
        feedback = "Good prompt, but consider adding more context about the specific tools and methods to use."
    elif final_score < 4.5:
        feedback = "Very good prompt! Minor improvements could include specifying edge cases."
    else:
        feedback = "Excellent prompt! Clear, specific, and well-structured."
    
    # Update user progress
    user_progress["scores"].append(final_score)
    if len(user_progress["scores"]) >= 3 and sum(user_progress["scores"][-3:]) / 3 > 4:
        if "Prompt Crafting Expert" not in user_progress["badges"]:
            user_progress["badges"].append("Prompt Crafting Expert")
    
    user_progress["completed_scenarios"] += 1
    
    if user_progress["completed_scenarios"] >= 5 and user_progress["skill_level"] == "Beginner":
        user_progress["skill_level"] = "Intermediate"
    elif user_progress["completed_scenarios"] >= 10 and user_progress["skill_level"] == "Intermediate":
        user_progress["skill_level"] = "Advanced"
    
    # Update leaderboard entry
    leaderboard[3]["score"] = sum(user_progress["scores"]) / max(1, len(user_progress["scores"]))
    leaderboard[3]["completed"] = user_progress["completed_scenarios"]
    leaderboard.sort(key=lambda x: x["score"], reverse=True)
    
    return {
        "score": final_score,
        "feedback": feedback
    }

# Show user profile
def show_profile():
    avg_score = sum(user_progress["scores"]) / max(1, len(user_progress["scores"]))
    
    response = f"### User Profile\n\n"
    response += f"**Skill Level:** {user_progress['skill_level']}\n"
    response += f"**Scenarios Completed:** {user_progress['completed_scenarios']}\n"
    response += f"**Average Score:** {avg_score:.1f}/5\n"
    
    if user_progress["badges"]:
        response += f"**Badges Earned:** {', '.join(user_progress['badges'])}\n"
    else:
        response += "**Badges Earned:** None yet! Keep practicing to earn badges.\n"
    
    response += "\n*Complete more scenarios with high scores to level up and earn badges!*"
    
    return response

# Show leaderboard
def display_leaderboard():
    lb_html = "<table width='100%'>"
    lb_html += "<tr><th>Rank</th><th>User</th><th>Avg Score</th><th>Completed</th></tr>"
    
    for i, entry in enumerate(leaderboard):
        lb_html += f"<tr><td>{i+1}</td><td>{'<b>' if entry['username'] == 'you' else ''}{entry['username']}{'</b>' if entry['username'] == 'you' else ''}</td><td>{entry['score']:.1f}</td><td>{entry['completed']}</td></tr>"
    
    lb_html += "</table>"
    return lb_html

# Generate a new scenario (mix of predefined and AI-generated)
def get_new_scenario(use_ai_generated=None):
    # 50% chance to get an AI-generated scenario if not specified
    if use_ai_generated is None:
        use_ai_generated = random.random() > 0.5
    
    if use_ai_generated:
        return load_ai_scenario()
    else:
        return load_regular_scenario()

# Use the same definition for get_ai_scenario but with the updated return types
def get_ai_scenario():
    return load_ai_scenario()

# Use the same definition for get_relational_scenario
def get_relational_scenario():
    return load_relational_scenario()

# Evaluate user input and provide feedback
def submit_prompt(prompt, title, description, level, category, answer_text):
    try:
        # First try to find in predefined scenarios
        scenario = next((s for s in all_scenarios if s["title"] == title), None) if isinstance(all_scenarios, list) else None
        
        # If not found, create a temporary scenario object from inputs
        if scenario is None:
            scenario = {
                "title": title,
                "description": description,
                "level": level,
                "category": category,
                "ideal_prompt": description,  # Use description as a fallback for keywords
                "answer": answer_text
            }
        
        # Evaluate prompt
        evaluation = evaluate_prompt(prompt, scenario)
        
        # Build response
        response = f"### Evaluation Results\n\n"
        response += f"**Score: {evaluation['score']}/5**\n\n"
        response += f"**Feedback:**\n{evaluation['feedback']}\n\n"
        
        # Add progress information
        response += f"### Your Progress\n\n"
        response += f"**Skill Level:** {user_progress['skill_level']}\n"
        response += f"**Scenarios Completed:** {user_progress['completed_scenarios']}\n"
        if user_progress["badges"]:
            response += f"**Badges Earned:** {', '.join(user_progress['badges'])}\n"
        
        # Include the answer section
        response += f"\n### Suggested Solution Approach\n\n"
        response += f"{scenario['answer']}\n" if "answer" in scenario else "No specific solution provided for this scenario."
        
        return response
    except Exception as e:
        # Hata durumunda basit bir yanıt ver
        print(f"Error in submit_prompt: {str(e)}")
        return f"### Evaluation\n\nYour prompt has been received but couldn't be evaluated due to an error.\n\nPlease try with another scenario."

# Helper function to update tables based on scenario type
def update_tables(tables, sample_data, answer):
    try:
        table_labels = ["sample_table1_label", "sample_table2_label", "sample_table3_label"]
        table_elements = [sample_table1, sample_table2, sample_table3]
        table_rows = [table_row, table_row2, table_row3]
        
        # Hide all tables first
        for row in table_rows:
            row.visible = False
        
        # Then show only the necessary tables
        for i, table_name in enumerate(tables[:3]):  # Limit to 3 tables
            if i < len(tables):
                table_rows[i].visible = True
                table_labels[i].value = f"### {table_name.replace('_', ' ').title()}"
                table_elements[i].value = sample_data.get(table_name, "No data available")
        
        return [
            table_rows[0].visible, table_rows[1].visible, table_rows[2].visible,
            table_labels[0].value, table_labels[1].value, table_labels[2].value,
            table_elements[0].value, table_elements[1].value, table_elements[2].value,
            answer
        ]
    except Exception as e:
        print(f"Error in update_tables: {str(e)}")
        # Hata durumunda varsayılan tabloları döndür
        return [
            True, False, False,
            "### Sample Data", "", "",
            "<table><tr><th>Data</th><th>Value</th></tr><tr><td>Sample</td><td>123</td></tr></table>",
            "", "",
            "Example answer"
        ]

def load_sample_data():
    try:
        # Birinci tabloyu yükle
        if 'sample_customer_data' in globals() and hasattr(sample_customer_data, 'head'):
            sample_html1 = sample_customer_data.head(5).to_html()
        else:
            sample_html1 = "<table><tr><th>CustomerID</th><th>Age</th></tr><tr><td>C0001</td><td>35</td></tr></table>"
            
        # İkinci tabloyu yükle
        if 'sample_sales_data' in globals() and hasattr(sample_sales_data, 'head'):
            sample_html2 = sample_sales_data.head(5).to_html()
        else:
            sample_html2 = "<table><tr><th>OrderID</th><th>Amount</th></tr><tr><td>ORD-001</td><td>120.5</td></tr></table>"
        
        return [
            "### Müşteri Verileri",
            sample_html1,
            "### Satış Verileri", 
            sample_html2
        ]
    except Exception as e:
        # Hata durumunda basit bir örnek göster
        print(f"Error in load_sample_data: {str(e)}")
        return [
            "### Örnek Veriler",
            "<table><tr><th>CustomerID</th><th>Age</th></tr><tr><td>C0001</td><td>35</td></tr></table>",
            "### Satış Verileri",
            "<table><tr><th>OrderID</th><th>Amount</th></tr><tr><td>ORD-001</td><td>120.5</td></tr></table>"
        ]

def load_regular_scenario():
    try:
        # Varsayılan normal senaryo
        default_scenario = {
            "title": "Data Cleaning in Power BI",
            "description": "Duplicates, missing values ve inconsistent date formatları içeren karışık bir satış veri setiniz var. Bu veriyi Power BI'da nasıl temizlersiniz?",
            "level": "Beginner",
            "category": "Power BI",
            "sample_data": sample_sales_data.head(10).to_html() if 'sample_sales_data' in globals() and hasattr(sample_sales_data, 'head') else "<table><tr><th>Data</th><th>Value</th></tr><tr><td>Example</td><td>123</td></tr></table>",
            "answer": "Power BI'da Remove Duplicates fonksiyonunu OrderID sütununa uygula, ortalama değerle Revenue sütunundaki eksik değerleri doldur, ve tarih sütunlarını MM/DD/YYYY formatına standardize et."
        }
        
        # Rastgele senaryo seçmeyi dene, başarısız olursa varsayılanı kullan
        if 'scenarios' in globals() and isinstance(scenarios, list) and len(scenarios) > 0:
            scenario = random.choice(scenarios)
        else:
            scenario = default_scenario
            
        if not isinstance(scenario.get("sample_data", ""), str):
            scenario["sample_data"] = default_scenario["sample_data"]
            
        return (
            scenario["title"],
            scenario["description"],
            scenario["level"],
            scenario["category"],
            True, False, False,  # Only first table visible
            "### Sample Data", "", "",  # Only first table has header
            scenario["sample_data"] if isinstance(scenario["sample_data"], str) else default_scenario["sample_data"],
            "", "",  # Empty second and third tables
            scenario.get("answer", "No specific answer for this scenario.")
        )
    except Exception as e:
        # Hata durumunda varsayılan senaryo göster
        print(f"Error in load_regular_scenario: {str(e)}")
        return (
            "Data Analysis",
            "Error loading scenario. Please try another option.",
            "Beginner",
            "Analytics",
            True, False, False,
            "### Sample Data", "", "",
            "<table><tr><th>Data</th><th>Value</th></tr><tr><td>Example</td><td>123</td></tr></table>",
            "", "",
            "Example answer text here."
        )

def load_relational_scenario():
    try:
        # Varsayılan ilişkisel senaryo - bu her zaman çalışacak
        default_scenario = {
            "title": "Customer Purchase Analysis",
            "description": "Müşteri verileriniz ve satış işlem verileriniz var. Müşteri satın alma kalıplarını analiz etmek için nasıl bir yaklaşım önerirsiniz?",
            "level": "Intermediate",
            "category": "Analytics",
            "sample_data": {
                "customer_data": sample_customer_data.head(10).to_html() if 'sample_customer_data' in globals() and hasattr(sample_customer_data, 'head') else "<table><tr><th>CustomerID</th><th>Age</th></tr><tr><td>C0001</td><td>35</td></tr></table>",
                "sales_data": sample_sales_data.head(10).to_html() if 'sample_sales_data' in globals() and hasattr(sample_sales_data, 'head') else "<table><tr><th>OrderID</th><th>Amount</th></tr><tr><td>ORD-001</td><td>120.5</td></tr></table>"
            },
            "answer": "Müşteri satın alma kalıplarını analiz etmek için RFM (Recency, Frequency, Monetary) analizi ile demografik özelliklere göre segmentasyon yapılabilir."
        }
        
        # Rastgele senaryo seçmeyi dene, başarısız olursa varsayılanı kullan
        if 'relational_scenarios' in globals() and isinstance(relational_scenarios, list) and len(relational_scenarios) > 0:
            scenario = random.choice(relational_scenarios)
        else:
            scenario = default_scenario
            
        return (
            scenario["title"],
            scenario["description"],
            scenario["level"],
            scenario["category"],
            True, True, False,  # Table visibility
            "### Customer Data", "### Sales Data", "",  # Table headers
            scenario["sample_data"].get("customer_data", default_scenario["sample_data"]["customer_data"]) if isinstance(scenario["sample_data"], dict) else default_scenario["sample_data"]["customer_data"],
            scenario["sample_data"].get("sales_data", default_scenario["sample_data"]["sales_data"]) if isinstance(scenario["sample_data"], dict) else default_scenario["sample_data"]["sales_data"],
            "",  # Empty third table
            scenario.get("answer", "Example answer text here.")
        )
    except Exception as e:
        # Hata durumunda varsayılan senaryo göster
        print(f"Error in load_relational_scenario: {str(e)}")
        return (
            "Relationship Analysis",
            "Error loading scenario. Please try another option.",
            "Intermediate",
            "Analytics",
            True, True, False,
            "### Sample Data 1", "### Sample Data 2", "",
            "<table><tr><th>CustomerID</th><th>Age</th></tr><tr><td>C0001</td><td>35</td></tr></table>",
            "<table><tr><th>OrderID</th><th>Amount</th></tr><tr><td>ORD-001</td><td>120.5</td></tr></table>",
            "",
            "Example answer text here."
        )

def load_ai_scenario():
    try:
        # Varsayılan başlık ve açıklama
        default_title = "Data Analysis with Python"
        default_description = "Veri setinizdeki eksik değerler için Python kullanarak nasıl bir çözüm önerirsiniz?"
        default_category = "Python"
        
        # Tablo verisi için güvenlik kontrolü
        if 'sample_sales_data' in globals() and hasattr(sample_sales_data, 'head'):
            sample_data = sample_sales_data.head(10).to_html()
        else:
            sample_data = "<table><tr><th>Data</th><th>Value</th></tr><tr><td>Example</td><td>123</td></tr></table>"
        
        # AI template kullanılabilir mi kontrol et
        use_templates = 'ai_scenario_templates' in globals() and isinstance(ai_scenario_templates, list) and len(ai_scenario_templates) > 0
        
        if use_templates:
            try:
                template = random.choice(ai_scenario_templates)
                tool = random.choice(template.get("tools", ["Python"]))
                data_type = random.choice(template.get("data_types", ["sample"]))
                problem = random.choice(template.get("problems", ["analysis"]))
                
                title = f"{template.get('title_prefix', 'Analysis with ')}{tool}"
                description = f"Bu {data_type} veri seti üzerinde {problem} problemini çözmek için {tool} kullanmanız gerekiyor."
                category = tool
            except Exception as template_error:
                print(f"Error creating AI template: {str(template_error)}")
                title = default_title
                description = default_description
                category = default_category
        else:
            title = default_title
            description = default_description
            category = default_category
        
        return (
            title,
            description,
            "Intermediate",
            category,
            True, False, False,  # Sadece ilk tablo görünür
            "### Sample Data", "", "",
            sample_data, "", "",
            "Bu senaryoda temel veri temizleme, analiz ve görselleştirme adımlarını takip edin."
        )
    except Exception as e:
        # Hata durumunda varsayılan senaryo göster
        print(f"Error in load_ai_scenario: {str(e)}")
        return (
            "AI Generated Scenario",
            "Error creating AI scenario. Please try another option.",
            "Intermediate",
            "AI",
            True, False, False,
            "### Sample Data", "", "",
            "<table><tr><th>Data</th><th>Value</th></tr><tr><td>Example</td><td>123</td></tr></table>",
            "", "",
            "Example answer text here."
        )

# Build Gradio interface
with gr.Blocks(theme=gr.themes.Soft(), title="PromptMaster for Data Analytics") as app:
    gr.Markdown("# PromptMaster for Data Analytics")
    gr.Markdown("### Learn to craft effective AI prompts for data analysis tasks")
    
    with gr.Tab("Practice Scenarios"):
        # Scenario display
        title_output = gr.Textbox(label="Scenario Title")
        description_output = gr.Textbox(label="Problem Description", lines=4)
        with gr.Row():
            level_output = gr.Textbox(label="Difficulty Level")
            category_output = gr.Textbox(label="Category")
        
        # Sample data display
        gr.Markdown("### Sample Data")
        
        # Create placeholders for up to 3 tables, hidden by default
        with gr.Row(visible=True) as table_row:
            sample_table1_label = gr.Markdown("### Tablo 1")
            sample_table1 = gr.HTML()
        
        with gr.Row(visible=True) as table_row2:
            sample_table2_label = gr.Markdown("### Tablo 2")
            sample_table2 = gr.HTML()
            
        with gr.Row(visible=False) as table_row3:
            sample_table3_label = gr.Markdown("### Tablo 3")
            sample_table3 = gr.HTML()
        
        # Hidden answer field to store the model answer
        answer_output = gr.Textbox(label="Model Answer", visible=False)
        
        # Switch to toggle showing answers immediately
        show_answer_toggle = gr.Checkbox(label="Show Answer Immediately", value=False)
            
        # Prompt tip box
        tip_output = gr.Markdown(label="Prompt Tip")
        
        # User input
        prompt_input = gr.Textbox(label="Your Prompt", lines=5, placeholder="Write your prompt here...")
        
        # Buttons - sadece submit ve yeni ipucu butonları kaldı
        with gr.Row():
            submit_btn = gr.Button("Submit Prompt", variant="primary")
            new_tip_btn = gr.Button("Get Prompt Tip")
            new_scenario_btn = gr.Button("New Scenario")
        
        # Results
        evaluation_output = gr.Markdown(label="Evaluation Results")

        # Modify the show_answer_toggle functionality
        show_answer_toggle.change(
            lambda show, answer: gr.update(value=f"### Model Solution\n\n{answer}") if show else gr.update(value=""),
            inputs=[show_answer_toggle, answer_output],
            outputs=[evaluation_output]
        )
        
        # Logic - butonların işlevselliği
        new_tip_btn.click(
            get_random_tip,
            outputs=[tip_output]
        )
        
        # Yeni senaryo butonu tek bir işlev kullanır
        new_scenario_btn.click(
            load_sample_data,
            outputs=[
                sample_table1_label, sample_table1,
                sample_table2_label, sample_table2
            ]
        )

        new_scenario_btn.click(
            load_regular_scenario,
            outputs=[
                title_output, description_output, level_output, category_output, 
                table_row, table_row2, table_row3, 
                sample_table1_label, sample_table2_label, sample_table3_label,
                sample_table1, sample_table2, sample_table3, 
                answer_output
            ]
        )
        
        submit_btn.click(
            submit_prompt, 
            inputs=[prompt_input, title_output, description_output, level_output, category_output, answer_output],
            outputs=[evaluation_output]
        )
        
        # Initialize with a scenario and tip
        app.load(
            load_regular_scenario,
            outputs=[
                title_output, description_output, level_output, category_output, 
                table_row, table_row2, table_row3, 
                sample_table1_label, sample_table2_label, sample_table3_label,
                sample_table1, sample_table2, sample_table3, 
                answer_output
            ]
        )

        # Rastgele ipucu yükle
        app.load(
            get_random_tip,
            outputs=[tip_output]
        )
    
    with gr.Tab("Your Profile"):
        profile_btn = gr.Button("View Profile")
        profile_output = gr.Markdown()
        
        profile_btn.click(show_profile, outputs=[profile_output])
    
    with gr.Tab("Leaderboard"):
        leaderboard_output = gr.HTML()
        refresh_lb_btn = gr.Button("Refresh Leaderboard")
        
        refresh_lb_btn.click(display_leaderboard, outputs=[leaderboard_output])
        
        # Initialize leaderboard
        app.load(display_leaderboard, outputs=[leaderboard_output])
    
    with gr.Tab("About"):
        gr.Markdown("""
        ## About PromptMaster
        
        PromptMaster is an AI-powered microlearning platform designed to help data professionals craft effective prompts for AI tools instead of writing manual code Designed by Mustafa Rakım Başar.
        
        ### How It Works
        1. You'll be presented with real-world data scenarios
        2. Craft a prompt as if you're instructing an AI to solve the problem
        3. Get instant feedback on your prompt quality
        4. Track your progress and earn badges as you improve
        
        ### Target Audience
        - Data Analysts
        - BI Developers
        - Data Engineers
        - Business Analysts
        
        Made with ❤️ using Gradio and Hugging Face Spaces
        """)

# Launch the app - Optimize for Hugging Face Spaces
if __name__ == "__main__":
    app.launch(
        server_name="0.0.0.0",  # Bind to all network interfaces for HF Spaces
        server_port=7860,       # Default port for HF Spaces
        share=False,            # No need for sharing links
        debug=False             # Disable debug mode for production
    )