#!/usr/bin/env python
"""
Real-time market monitoring for congressional tickers.
Run this continuously or on a schedule to detect unusual activity.
"""

import logging
import time
from datetime import datetime
from pathlib import Path

import click

from pote.db import get_session
from pote.monitoring.alert_manager import AlertManager
from pote.monitoring.market_monitor import MarketMonitor

logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)


@click.command()
@click.option("--tickers", help="Comma-separated list of tickers (default: congressional watchlist)")
@click.option("--interval", default=300, help="Scan interval in seconds (default: 300 = 5 minutes)")
@click.option("--once", is_flag=True, help="Run once and exit (no continuous monitoring)")
@click.option("--min-severity", default=5, help="Minimum severity to report (1-10)")
@click.option("--save-report", help="Save report to file")
@click.option("--lookback", default=5, help="Days of history to analyze (default: 5)")
def main(tickers, interval, once, min_severity, save_report, lookback):
    """Monitor market for unusual activity in congressional tickers."""

    session = next(get_session())
    monitor = MarketMonitor(session)
    alert_mgr = AlertManager(session)

    # Parse tickers if provided
    ticker_list = None
    if tickers:
        ticker_list = [t.strip().upper() for t in tickers.split(",")]
        logger.info(f"Monitoring {len(ticker_list)} specified tickers")
    else:
        logger.info("Monitoring congressional watchlist")

    def run_scan():
        """Run a single scan."""
        logger.info("=" * 80)
        logger.info(f"Starting market scan at {datetime.now()}")
        logger.info("=" * 80)

        try:
            # Scan for unusual activity
            alerts = monitor.scan_watchlist(tickers=ticker_list, lookback_days=lookback)

            if alerts:
                logger.info(f"\n🔔 Found {len(alerts)} alerts!")

                # Save to database
                monitor.save_alerts(alerts)

                # Get MarketAlert objects for reporting
                from pote.db.models import MarketAlert

                alert_objects = (
                    session.query(MarketAlert)
                    .order_by(MarketAlert.timestamp.desc())
                    .limit(len(alerts))
                    .all()
                )

                # Filter by severity
                filtered = alert_mgr.filter_alerts(alert_objects, min_severity=min_severity)

                if filtered:
                    # Generate report
                    report = alert_mgr.generate_summary_report(filtered, format="text")
                    print("\n" + report)

                    # Save report if requested
                    if save_report:
                        Path(save_report).write_text(report)
                        logger.info(f"Report saved to {save_report}")
                else:
                    logger.info(f"No alerts above severity {min_severity}")
            else:
                logger.info("✅ No unusual activity detected")

        except Exception as e:
            logger.error(f"Error during scan: {e}", exc_info=True)

        logger.info("=" * 80)
        logger.info(f"Scan complete at {datetime.now()}")
        logger.info("=" * 80)

    # Run scan
    run_scan()

    # Continuous monitoring mode
    if not once:
        logger.info(f"\n🔄 Continuous monitoring enabled (interval: {interval}s)")
        logger.info("Press Ctrl+C to stop\n")

        try:
            while True:
                time.sleep(interval)
                run_scan()
        except KeyboardInterrupt:
            logger.info("\n\n⏹️  Monitoring stopped by user")
    else:
        logger.info("\n✅ Single scan complete (use --interval for continuous monitoring)")


if __name__ == "__main__":
    main()