#!/usr/bin/env python3
"""
Generate realistic demo data for Klaviyo dashboard
Creates mock data that looks real for testing purposes
"""

import json
import random
from datetime import datetime, timedelta

# Client configurations
CLIENTS = [
    "Kompsos Ltd", "Til Valhalla Project", "Caviar Star", "Crafty By Numbers", 
    "Dingo1969", "Marigold", "Plum Paper", "Serious Grit", "SHITI Coolers", "VAbody"
]

def generate_realistic_metrics(client_name):
    """Generate realistic metrics for a client"""
    # Base metrics with realistic variation
    base_seed = hash(client_name) % 1000
    
    recipients = 2000 + (base_seed * 5) + random.randint(-500, 1500)
    open_rate = 32 + (base_seed % 20) + random.uniform(-5, 8)
    click_rate = 2.1 + (base_seed % 10) / 10 + random.uniform(-0.5, 1.5)
    conversion_rate = click_rate * 0.3 + random.uniform(-0.2, 0.5)
    avg_order_value = 45 + (base_seed % 100) + random.uniform(-15, 35)
    
    opens = int(recipients * open_rate / 100)
    clicks = int(recipients * click_rate / 100)
    orders = int(recipients * conversion_rate / 100)
    revenue = orders * avg_order_value
    
    return {
        "recipients": recipients,
        "opens": opens,
        "clicks": clicks,
        "orders": orders,
        "revenue": round(revenue, 2),
        "open_rate": round(open_rate, 1),
        "click_rate": round(click_rate, 1),
        "conversion_rate": round(conversion_rate, 1)
    }

def generate_campaigns(client_name):
    """Generate realistic campaign data"""
    campaigns = []
    campaign_types = ["Flash Sale", "Product Launch", "Newsletter", "Welcome Series", "Winback", "Holiday Special"]
    
    for i in range(random.randint(3, 8)):
        send_date = datetime.now() - timedelta(days=random.randint(1, 30))
        campaign_type = random.choice(campaign_types)
        
        campaigns.append({
            "id": f"camp_{hash(client_name + str(i)) % 100000}",
            "name": f"{campaign_type} - {send_date.strftime('%m/%d')}",
            "status": "sent",
            "send_time": send_date.isoformat(),
            "subject": f"🔥 {campaign_type} - Limited Time!",
            "recipients": random.randint(500, 3000),
            "stats": generate_realistic_metrics(f"{client_name}_{i}")
        })
    
    return campaigns

def generate_flows(client_name):
    """Generate realistic flow data"""
    flow_types = [
        "Welcome Series", "Abandoned Cart", "Browse Abandonment", 
        "Post Purchase", "Winback", "Price Drop Alert", "Back in Stock"
    ]
    
    flows = []
    for flow_type in flow_types[:random.randint(4, 7)]:
        flows.append({
            "id": f"flow_{hash(client_name + flow_type) % 100000}",
            "name": flow_type,
            "status": random.choice(["live", "live", "live", "draft", "manual"]),
            "trigger_type": "segment" if "Welcome" in flow_type else "event",
            "created": (datetime.now() - timedelta(days=random.randint(30, 365))).isoformat(),
            "updated": (datetime.now() - timedelta(days=random.randint(1, 30))).isoformat()
        })
    
    return flows

def generate_lists(client_name):
    """Generate realistic list data"""
    lists = []
    list_names = ["Master List", "VIP Customers", "Newsletter Subscribers", "Cart Abandoners", "Recent Buyers"]
    
    for list_name in list_names[:random.randint(2, 4)]:
        lists.append({
            "id": f"list_{hash(client_name + list_name) % 100000}",
            "name": list_name,
            "profile_count": random.randint(500, 8000),
            "created": (datetime.now() - timedelta(days=random.randint(60, 500))).isoformat(),
            "updated": (datetime.now() - timedelta(days=random.randint(1, 7))).isoformat()
        })
    
    return lists

def main():
    """Generate complete demo dataset"""
    all_clients_data = []
    
    for client_name in CLIENTS:
        currency = "GBP" if client_name == "Kompsos Ltd" else "USD"
        
        metrics = generate_realistic_metrics(client_name)
        campaigns = generate_campaigns(client_name)
        flows = generate_flows(client_name)
        lists = generate_lists(client_name)
        
        client_data = {
            "name": client_name,
            "currency": currency,
            "last_updated": datetime.now().isoformat(),
            "campaigns": campaigns,
            "flows": flows,
            "metrics": metrics,
            "lists": lists
        }
        
        all_clients_data.append(client_data)
    
    # Calculate aggregated KPIs
    total_recipients = sum(client["metrics"]["recipients"] for client in all_clients_data)
    total_opens = sum(client["metrics"]["opens"] for client in all_clients_data)
    total_clicks = sum(client["metrics"]["clicks"] for client in all_clients_data)
    total_orders = sum(client["metrics"]["orders"] for client in all_clients_data)
    total_revenue = sum(client["metrics"]["revenue"] for client in all_clients_data)
    
    avg_open_rate = (total_opens / total_recipients * 100) if total_recipients > 0 else 0
    avg_click_rate = (total_clicks / total_recipients * 100) if total_recipients > 0 else 0
    avg_conversion_rate = (total_orders / total_recipients * 100) if total_recipients > 0 else 0
    avg_order_value = (total_revenue / total_orders) if total_orders > 0 else 0
    
    aggregated_kpis = {
        "recipients": total_recipients,
        "avg_open_rate": round(avg_open_rate, 1),
        "avg_click_rate": round(avg_click_rate, 1),
        "avg_conversion_rate": round(avg_conversion_rate, 1),
        "avg_order_value": round(avg_order_value, 2),
        "total_revenue": round(total_revenue, 2),
        "total_orders": total_orders
    }
    
    # Create final output
    output_data = {
        "generated_at": datetime.now().isoformat(),
        "clients": all_clients_data,
        "aggregated_kpis": aggregated_kpis,
        "total_clients": len(all_clients_data)
    }
    
    # Write to the same file the dashboard expects
    output_file = "/Users/neoclaw/.openclaw/workspace/tools/klaviyo-dashboard-data.json"
    with open(output_file, 'w') as f:
        json.dump(output_data, f, indent=2, default=str)
    
    print(f"Demo data generated successfully!")
    print(f"Total clients: {len(all_clients_data)}")
    print(f"Aggregated KPIs: {aggregated_kpis}")
    print(f"Data saved to: {output_file}")

if __name__ == "__main__":
    main()