#!/usr/bin/env python3
"""
Research Pipeline Orchestrator
Runs all pipeline stages: fetch signals, aggregate, format, and send.
"""

import os
import sys
import json
import argparse
from datetime import datetime
import subprocess

# Add sources to path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "sources"))

from reddit_poller import get_reddit_signals
from brave_scanner import get_brave_signals
from youtube_rss import get_youtube_signals
from aggregator import aggregate_signals
from formatter import create_telegram_brief


WORKSPACE_DIR = os.path.expanduser("~/.openclaw/workspace")
PIPELINE_DIR = os.path.join(WORKSPACE_DIR, "scripts", "research-pipeline")
OUTPUT_FILE = os.path.join(PIPELINE_DIR, "latest-brief.md")
TRIGGER_FILE = os.path.join(PIPELINE_DIR, "send-trigger.json")


def main(dry_run=False):
    """
    Main orchestrator function.
    Fetches signals, aggregates, formats, and sends brief.
    """
    print("[*] Research Pipeline Starting...")
    
    # Get API key
    api_key = os.getenv("BRAVE_API_KEY")
    if not api_key:
        print("[ERROR] BRAVE_API_KEY not found in environment")
        return False
    
    # Stage 1: Fetch signals from all sources
    print("[*] Stage 1: Fetching signals from Reddit...")
    reddit_signals = []
    niches = [
        "USMC / Military",
        "Military Family", 
        "Reformed Christian",
        "Patriotic",
        "Print on Demand",
        "AI Services / Small Business"
    ]
    for niche in niches:
        try:
            signals = get_reddit_signals(niche)
            reddit_signals.extend(signals)
            print(f"  ✓ {niche}: {len(signals)} signals")
        except Exception as e:
            print(f"  ✗ {niche}: {e}")
    
    print("[*] Stage 2: Fetching signals from Brave Search...")
    brave_signals = []
    for niche in niches:
        try:
            signals = get_brave_signals(niche, api_key)
            brave_signals.extend(signals)
            print(f"  ✓ {niche}: {len(signals)} signals")
        except Exception as e:
            print(f"  ✗ {niche}: {e}")
    
    print("[*] Stage 3: Fetching signals from YouTube RSS...")
    try:
        youtube_signals = get_youtube_signals()
        print(f"  ✓ YouTube: {len(youtube_signals)} signals")
    except Exception as e:
        print(f"  ✗ YouTube: {e}")
        youtube_signals = []
    
    # Stage 2: Aggregate
    print("[*] Stage 4: Aggregating and ranking signals...")
    all_signals = aggregate_signals(reddit_signals, brave_signals, youtube_signals)
    print(f"  ✓ Aggregated to {len(all_signals)} top signals")
    
    if len(all_signals) < 5:
        print(f"[WARN] Only {len(all_signals)} signals found (min quality bar: 5)")
    
    # Stage 3: Format
    print("[*] Stage 5: Formatting brief...")
    brief = create_telegram_brief(all_signals)
    word_count = len(brief.split())
    print(f"  ✓ Brief formatted: {word_count} words")
    
    # Stage 4: Write output
    print(f"[*] Writing output to {OUTPUT_FILE}...")
    with open(OUTPUT_FILE, "w") as f:
        f.write(brief)
    print(f"  ✓ Brief saved")
    
    # Stage 5: Create trigger file
    trigger_data = {
        "ready": True,
        "brief": brief,
        "timestamp": datetime.now().isoformat(),
        "signal_count": len(all_signals),
        "word_count": word_count
    }
    
    with open(TRIGGER_FILE, "w") as f:
        json.dump(trigger_data, f, indent=2)
    print(f"  ✓ Trigger file created")
    
    # If not dry-run, send via message tool
    if not dry_run:
        print("[*] Stage 6: Sending via Telegram...")
        send_telegram_brief(brief)
    else:
        print("[*] [DRY-RUN] Skipping Telegram send")
    
    print("[✓] Pipeline complete!")
    return True


def send_telegram_brief(brief: str):
    """
    Send brief via OpenClaw message tool.
    """
    try:
        # Use the message tool via subprocess
        cmd = [
            "openclaw",
            "message",
            "send",
            "--channel", "telegram",
            "--account", "private",
            "--to", "1193456137",
            "--message", brief
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        if result.returncode == 0:
            print("  ✓ Telegram message sent")
        else:
            print(f"  ✗ Telegram send failed: {result.stderr}")
            print("  → Falling back to trigger file (daemon will pick up)")
    except Exception as e:
        print(f"  ✗ Telegram send error: {e}")
        print("  → Trigger file created; daemon will deliver")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Research Pipeline Orchestrator")
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Dry-run: fetch and format but don't send"
    )
    args = parser.parse_args()
    
    success = main(dry_run=args.dry_run)
    sys.exit(0 if success else 1)