streaming_simulator/simulator.py

"""
Olist E-commerce Streaming Simulator (Kaggle Dataset Version)
===============================================================
Reads static CSV files from Kaggle's Brazilian E-Commerce dataset
and replays them as time-ordered events to Kafka topics.
Simulates the full order lifecycle: ORDER → ITEMS → PAYMENT → SHIP → DELIVER → REVIEW

Usage:
    python simulator.py --speed 1000 --data-dir ./data

    speed=1     → real-time (25 months)
    speed=100   → ~6 hours
    speed=1000  → ~36 minutes
    speed=10000 → ~3.6 minutes
"""

import os
import sys
import json
import time
import logging
import argparse
from datetime import datetime, timedelta
from dataclasses import dataclass, asdict
from typing import List, Optional
from pathlib import Path

import pandas as pd

# Lazy import Kafka to allow data loading/testing without running Kafka server
try:
    from confluent_kafka import Producer
    from confluent_kafka.serialization import SerializationContext, MessageField
    from confluent_kafka.schema_registry import SchemaRegistryClient
    from confluent_kafka.schema_registry.avro import AvroSerializer
    _KAFKA_AVAILABLE = True
except ImportError:
    _KAFKA_AVAILABLE = False
    Producer = None
    SerializationContext = None
    MessageField = None
    SchemaRegistryClient = None
    AvroSerializer = None

# ============================================================
# CONFIGURATION
# ============================================================

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger(__name__)

# Kafka Topics
TOPICS = {
    'order_created': 'ecom.orders.created',
    'order_items': 'ecom.orders.items',
    'order_payments': 'ecom.orders.payments',
    'order_status': 'ecom.orders.status_changed',
    'order_delivered': 'ecom.orders.delivered',
    'review_submitted': 'ecom.reviews.submitted',
}

# ============================================================
# EVENT DATACLASSES
# ============================================================

@dataclass
class Event:
    """Base event to be sent to Kafka"""
    timestamp: str  # ISO format string
    topic: str
    key: str  # order_id
    payload: dict
    event_type: str

    def __lt__(self, other):
        return self.timestamp < other.timestamp


# ============================================================
# STREAMING SIMULATOR
# ============================================================

class OlistStreamSimulator:
    """
    Reads Olist CSV files from Kaggle dataset and replays events
    in chronological order through Kafka topics, simulating real-time
    e-commerce data flow.
    """

    def __init__(
        self,
        data_dir: str,
        kafka_bootstrap: str = 'localhost:9092',
        schema_registry_url: str = 'http://localhost:8081',
        speed_factor: float = 1000.0,
    ):
        self.data_dir = Path(data_dir)
        self.speed_factor = speed_factor
        self.events: List[Event] = []
        self.stats = {topic: 0 for topic in TOPICS.values()}

        # Kafka Producer
        if _KAFKA_AVAILABLE:
            self.producer = Producer({
                'bootstrap.servers': kafka_bootstrap,
                'client.id': 'olist-simulator',
                'linger.ms': 5,
                'batch.num.messages': 1000,
                'queue.buffering.max.messages': 100000,
                'compression.type': 'snappy',
            })
        else:
            logger.warning("Kafka library not available. Data loading will work, but streaming to Kafka will fail.")
            self.producer = None

        logger.info(f"Simulator initialized: speed={speed_factor}x, data_dir={data_dir}")

    def _delivery_callback(self, err, msg):
        """Callback for Kafka producer delivery reports"""
        if err:
            logger.error(f"Message delivery failed: {err}")

    def load_data(self):
        """Load all CSV files from Kaggle dataset and build the event timeline"""
        logger.info("Loading Olist CSV files from Kaggle dataset...")

        # Kaggle dataset file paths (olist_*_dataset.csv naming convention)
        orders_path = self.data_dir / 'olist_orders_dataset.csv'
        items_path = self.data_dir / 'olist_order_items_dataset.csv'
        payments_path = self.data_dir / 'olist_order_payments_dataset.csv'
        reviews_path = self.data_dir / 'olist_order_reviews_dataset.csv'
        customers_path = self.data_dir / 'olist_customers_dataset.csv'
        products_path = self.data_dir / 'olist_products_dataset.csv'
        sellers_path = self.data_dir / 'olist_sellers_dataset.csv'

        # Validate required files exist
        required_files = [orders_path, items_path, payments_path, reviews_path]
        for f in required_files:
            if not f.exists():
                raise FileNotFoundError(
                    f"Required file not found: {f}\n"
                    f"Please download the dataset from Kaggle:\n"
                    f"  kaggle datasets download -d olistbr/brazilian-ecommerce\n"
                    f"  unzip brazilian-ecommerce.zip -d {self.data_dir}"
                )

        # Load CSVs with timestamp parsing
        orders = pd.read_csv(
            orders_path,
            parse_dates=[
                'order_purchase_timestamp', 'order_approved_at',
                'order_delivered_carrier_date', 'order_delivered_customer_date',
                'order_estimated_delivery_date'
            ]
        )
        items = pd.read_csv(
            items_path,
            parse_dates=['shipping_limit_date']
        )
        payments = pd.read_csv(payments_path)
        reviews = pd.read_csv(
            reviews_path,
            parse_dates=['review_creation_date', 'review_answer_timestamp']
        )
        customers = pd.read_csv(customers_path)
        products = pd.read_csv(products_path)
        sellers = pd.read_csv(sellers_path)

        logger.info(
            f"Loaded: {len(orders)} orders, {len(items)} items, "
            f"{len(payments)} payments, {len(reviews)} reviews, "
            f"{len(customers)} customers, {len(products)} products, "
            f"{len(sellers)} sellers"
        )

        # Build event timeline
        logger.info("Building event timeline...")

        # Pre-index for faster lookups
        items_by_order = items.groupby('order_id')
        payments_by_order = payments.groupby('order_id')
        reviews_by_order = reviews.groupby('order_id')

        # Sort orders by purchase timestamp
        orders = orders.sort_values('order_purchase_timestamp').dropna(
            subset=['order_purchase_timestamp']
        )

        total = len(orders)
        for idx, (_, order) in enumerate(orders.iterrows()):
            if idx % 10000 == 0:
                logger.info(f"Processing order {idx}/{total} ({idx/total*100:.1f}%)")

            order_id = order['order_id']
            purchase_ts = order['order_purchase_timestamp']

            if pd.isna(purchase_ts):
                continue

            # ---- Event 1: ORDER CREATED ----
            self.events.append(Event(
                timestamp=purchase_ts.isoformat(),
                topic=TOPICS['order_created'],
                key=order_id,
                payload={
                    'order_id': order_id,
                    'customer_id': str(order['customer_id']),
                    'order_status': str(order.get('order_status', 'created')),
                    'order_purchase_timestamp': purchase_ts.isoformat(),
                    'event_type': 'ORDER_CREATED',
                    'event_time': purchase_ts.isoformat(),
                },
                event_type='ORDER_CREATED'
            ))

            # ---- Event 2: ITEMS ADDED (30 seconds after order) ----
            if order_id in items_by_order.groups:
                order_items = items_by_order.get_group(order_id)
                items_ts = purchase_ts + timedelta(seconds=30)

                for _, item in order_items.iterrows():
                    shipping_limit = item.get('shipping_limit_date')
                    self.events.append(Event(
                        timestamp=items_ts.isoformat(),
                        topic=TOPICS['order_items'],
                        key=order_id,
                        payload={
                            'order_id': order_id,
                            'order_item_id': int(item['order_item_id']),
                            'product_id': str(item['product_id']),
                            'seller_id': str(item['seller_id']),
                            'shipping_limit_date': str(shipping_limit) if pd.notna(shipping_limit) else None,
                            'price': float(item['price']),
                            'freight_value': float(item['freight_value']),
                            'event_type': 'ITEM_ADDED',
                            'event_time': items_ts.isoformat(),
                        },
                        event_type='ITEM_ADDED'
                    ))

            # ---- Event 3: PAYMENT CAPTURED (at approval time) ----
            if pd.notna(order['order_approved_at']) and order_id in payments_by_order.groups:
                approved_ts = order['order_approved_at']
                order_payments = payments_by_order.get_group(order_id)

                for _, pay in order_payments.iterrows():
                    self.events.append(Event(
                        timestamp=approved_ts.isoformat(),
                        topic=TOPICS['order_payments'],
                        key=order_id,
                        payload={
                            'order_id': order_id,
                            'payment_sequential': int(pay['payment_sequential']),
                            'payment_type': str(pay['payment_type']),
                            'payment_installments': int(pay['payment_installments']),
                            'payment_value': float(pay['payment_value']),
                            'event_type': 'PAYMENT_CAPTURED',
                            'event_time': approved_ts.isoformat(),
                        },
                        event_type='PAYMENT_CAPTURED'
                    ))

            # ---- Event 4: ORDER SHIPPED (carrier date) ----
            if pd.notna(order['order_delivered_carrier_date']):
                shipped_ts = order['order_delivered_carrier_date']
                self.events.append(Event(
                    timestamp=shipped_ts.isoformat(),
                    topic=TOPICS['order_status'],
                    key=order_id,
                    payload={
                        'order_id': order_id,
                        'old_status': str(order.get('order_status', 'processing')),
                        'new_status': 'shipped',
                        'timestamp': shipped_ts.isoformat(),
                        'event_type': 'STATUS_CHANGED',
                        'event_time': shipped_ts.isoformat(),
                    },
                    event_type='STATUS_CHANGED'
                ))

            # ---- Event 5: ORDER DELIVERED ----
            if pd.notna(order['order_delivered_customer_date']):
                delivered_ts = order['order_delivered_customer_date']
                estimated = order['order_estimated_delivery_date']

                delay_days = None
                is_late = False
                if pd.notna(estimated):
                    delay_days = int((delivered_ts - estimated).days)
                    is_late = bool(delivered_ts > estimated)

                self.events.append(Event(
                    timestamp=delivered_ts.isoformat(),
                    topic=TOPICS['order_delivered'],
                    key=order_id,
                    payload={
                        'order_id': order_id,
                        'order_delivered_carrier_date': str(order['order_delivered_carrier_date']) if pd.notna(order['order_delivered_carrier_date']) else None,
                        'order_delivered_customer_date': delivered_ts.isoformat(),
                        'order_estimated_delivery_date': str(estimated) if pd.notna(estimated) else None,
                        'delivery_delay_days': delay_days,
                        'is_late': is_late,
                        'event_type': 'ORDER_DELIVERED',
                        'event_time': delivered_ts.isoformat(),
                    },
                    event_type='ORDER_DELIVERED'
                ))

            # ---- Event 6: REVIEW SUBMITTED ----
            if order_id in reviews_by_order.groups:
                order_reviews = reviews_by_order.get_group(order_id)
                for _, review in order_reviews.iterrows():
                    review_ts = review.get('review_answer_timestamp')
                    if pd.notna(review_ts):
                        comment_title = review.get('review_comment_title')
                        comment_msg = review.get('review_comment_message')
                        review_creation = review.get('review_creation_date')

                        self.events.append(Event(
                            timestamp=review_ts.isoformat(),
                            topic=TOPICS['review_submitted'],
                            key=order_id,
                            payload={
                                'review_id': str(review['review_id']),
                                'order_id': order_id,
                                'review_score': int(review['review_score']),
                                'review_comment_title': str(comment_title) if pd.notna(comment_title) else None,
                                'review_comment_message': str(comment_msg) if pd.notna(comment_msg) else None,
                                'review_creation_date': str(review_creation) if pd.notna(review_creation) else None,
                                'review_answer_timestamp': review_ts.isoformat(),
                                'event_type': 'REVIEW_SUBMITTED',
                                'event_time': review_ts.isoformat(),
                            },
                            event_type='REVIEW_SUBMITTED'
                        ))

        # Sort all events by timestamp
        self.events.sort()
        logger.info(f"Timeline built: {len(self.events)} total events")

        # Print event distribution
        event_types = {}
        for e in self.events:
            event_types[e.event_type] = event_types.get(e.event_type, 0) + 1
        for et, count in sorted(event_types.items()):
            logger.info(f"  {et}: {count:,} events")

    def run(self, max_events: Optional[int] = None):
        """
        Replay events with time-scaled delays.

        Args:
            max_events: Optional limit on number of events to send (for testing)
        """
        if not self.events:
            self.load_data()

        total_events = len(self.events)
        if max_events:
            total_events = min(max_events, total_events)

        logger.info(f"Starting replay: {total_events:,} events at {self.speed_factor}x speed")

        # Calculate expected duration
        if len(self.events) >= 2:
            first_ts = datetime.fromisoformat(self.events[0].timestamp)
            last_ts = datetime.fromisoformat(self.events[min(total_events-1, len(self.events)-1)].timestamp)
            real_duration = (last_ts - first_ts).total_seconds()
            simulated_duration = real_duration / self.speed_factor
            logger.info(f"Real time span: {real_duration/86400:.1f} days")
            logger.info(f"Simulated duration: {simulated_duration/60:.1f} minutes")

        start_time = time.time()
        prev_event_time = datetime.fromisoformat(self.events[0].timestamp)
        events_sent = 0

        for i, event in enumerate(self.events[:total_events]):
            # Calculate delay
            current_event_time = datetime.fromisoformat(event.timestamp)
            time_diff = (current_event_time - prev_event_time).total_seconds()

            if time_diff > 0:
                sleep_time = time_diff / self.speed_factor
                # Cap sleep to avoid long pauses
                sleep_time = min(sleep_time, 5.0)
                if sleep_time > 0.001:
                    time.sleep(sleep_time)

            # Send to Kafka
            if self.producer is None:
                # Kafka not available — simulate send (for testing/data loading only)
                self.stats[event.topic] = self.stats.get(event.topic, 0) + 1
                events_sent += 1
                if events_sent % 5000 == 0:
                    elapsed = time.time() - start_time
                    rate = events_sent / elapsed if elapsed > 0 else 0
                    logger.info(
                        f"Progress: {events_sent:,}/{total_events:,} events "
                        f"({events_sent/total_events*100:.1f}%) | "
                        f"Rate: {rate:.0f} events/sec | "
                        f"Simulated time: {current_event_time}"
                    )
                continue

            try:
                self.producer.produce(
                    topic=event.topic,
                    key=event.key.encode('utf-8'),
                    value=json.dumps(event.payload).encode('utf-8'),
                    callback=self._delivery_callback,
                )
                self.stats[event.topic] = self.stats.get(event.topic, 0) + 1
                events_sent += 1

            except BufferError:
                logger.warning("Producer buffer full, flushing...")
                self.producer.flush(timeout=10)
                self.producer.produce(
                    topic=event.topic,
                    key=event.key.encode('utf-8'),
                    value=json.dumps(event.payload).encode('utf-8'),
                    callback=self._delivery_callback,
                )
                events_sent += 1

            # Periodic flush and progress
            if events_sent % 5000 == 0:
                if self.producer is not None:
                    self.producer.flush(timeout=5)
                elapsed = time.time() - start_time
                rate = events_sent / elapsed if elapsed > 0 else 0
                logger.info(
                    f"Progress: {events_sent:,}/{total_events:,} events "
                    f"({events_sent/total_events*100:.1f}%) | "
                    f"Rate: {rate:.0f} events/sec | "
                    f"Simulated time: {current_event_time}"
                )

            prev_event_time = current_event_time

        # Final flush
        if self.producer is not None:
            self.producer.flush(timeout=30)

        elapsed = time.time() - start_time
        logger.info(f"\n{'='*60}")
        logger.info(f"REPLAY COMPLETE")
        logger.info(f"{'='*60}")
        logger.info(f"Total events sent: {events_sent:,}")
        logger.info(f"Total time: {elapsed:.1f} seconds ({elapsed/60:.1f} minutes)")
        logger.info(f"Average rate: {events_sent/elapsed:.0f} events/sec")
        logger.info(f"\nEvents per topic:")
        for topic, count in sorted(self.stats.items()):
            logger.info(f"  {topic}: {count:,}")


# ============================================================
# CLI ENTRY POINT
# ============================================================

def main():
    parser = argparse.ArgumentParser(
        description='Olist E-commerce Streaming Simulator (Kaggle Dataset)',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Quick test (first 1000 events)
  python simulator.py --data-dir ./brazilian-ecommerce --speed 10000 --max-events 1000

  # Full replay at 1000x speed (~36 min)
  python simulator.py --data-dir ./brazilian-ecommerce --speed 1000

  # Real-time replay
  python simulator.py --data-dir ./brazilian-ecommerce --speed 1

Setup:
  1. Download dataset from Kaggle:
     kaggle datasets download -d olistbr/brazilian-ecommerce
     unzip brazilian-ecommerce.zip -d ./brazilian-ecommerce

  2. Ensure Kafka is running (see docker-compose.yml)

  3. Run simulator:
     python streaming_simulator/simulator.py --data-dir ./brazilian-ecommerce
        """
    )

    parser.add_argument(
        '--data-dir', type=str,
        default=os.environ.get('DATA_DIR', './data'),
        help='Directory containing Kaggle Olist CSV files (olist_orders_dataset.csv, etc.)'
    )
    parser.add_argument(
        '--kafka-bootstrap', type=str,
        default=os.environ.get('KAFKA_BOOTSTRAP_SERVERS', 'localhost:9092'),
        help='Kafka bootstrap servers'
    )
    parser.add_argument(
        '--schema-registry', type=str,
        default=os.environ.get('SCHEMA_REGISTRY_URL', 'http://localhost:8081'),
        help='Schema Registry URL'
    )
    parser.add_argument(
        '--speed', type=float,
        default=float(os.environ.get('SPEED_FACTOR', '1000')),
        help='Speed factor (1=real-time, 1000=fast)'
    )
    parser.add_argument(
        '--max-events', type=int, default=None,
        help='Maximum events to send (for testing)'
    )

    args = parser.parse_args()

    simulator = OlistStreamSimulator(
        data_dir=args.data_dir,
        kafka_bootstrap=args.kafka_bootstrap,
        schema_registry_url=args.schema_registry,
        speed_factor=args.speed,
    )

    simulator.load_data()
    simulator.run(max_events=args.max_events)


if __name__ == '__main__':
    main()