#!/usr/bin/env python3
"""X Account Monitor — Scan Chunk 1 (first 22 accounts) — 2026-06-14"""

import urllib.request, json, time, os, sys
from datetime import datetime, timezone

API_KEY = "get-x-api-6157f8edb420c3d5e50e062287389aa55635cd7c9630c81f"
BASE_URL = "https://api.getxapi.com"
DATE_STR = "2026-06-14"
OUTPUT_FILE = f"/home/kiro/trend-engine/trends/x/account-monitor/scan_results_{DATE_STR}_chunk1.json"
CUTOFF = datetime(2026, 6, 11, 0, 0, 0, tzinfo=timezone.utc)

# Chunk 1: First 22 handles
HANDLES = [
    "runwayml", "CuriousRefuge", "nofilmschool", "venturetwins",
    "Kling_ai", "paultrillo", "c_valenzuelab", "CorridorDigital",
    "karenxcheng", "higgsfield", "pika_labs", "EHuanglu",
    "azed_ai", "JeffSynthesized", "ai_filmmaker", "visiblemaker",
    "Magiermogul", "WuxiaRocks", "JiamingSuen", "moonvalley",
    "higgsfield_ai", "Chandan_Perla",
]

def parse_date(created_at):
    if not created_at:
        return None
    try:
        return datetime.strptime(created_at, "%a %b %d %H:%M:%S %z %Y")
    except Exception:
        return None

def fetch_tweets(handle):
    url = f"{BASE_URL}/twitter/user/tweets?userName={handle}&count=5"
    req = urllib.request.Request(url, headers={"Authorization": f"Bearer {API_KEY}"})
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            body = resp.read().decode("utf-8", errors="replace")
    except Exception as e:
        return {"error": str(e)}
    
    # Try to salvage truncated JSON
    try:
        data = json.loads(body, strict=False)
    except json.JSONDecodeError:
        return {"error": f"JSON decode failed: {body[:200]}"}
    
    # Response may be {tweets: [...]} or flat [...]
    if isinstance(data, dict):
        raw_tweets = data.get("tweets", data.get("data", []))
    elif isinstance(data, list):
        raw_tweets = data
    else:
        return {"error": f"Unexpected response type: {type(data).__name__}"}
    
    processed = []
    for t in raw_tweets:
        # Extract fields
        text = t.get("text", t.get("full_text", ""))
        tweet_id = t.get("id", t.get("tweet_id", ""))
        like_count = int(t.get("likeCount", t.get("favorite_count", 0)) or 0)
        retweet_count = int(t.get("retweetCount", t.get("retweet_count", 0)) or 0)
        reply_count = int(t.get("replyCount", t.get("reply_count", 0)) or 0)
        view_count = int(t.get("viewCount", t.get("view_count", 0)) or 0)
        bookmark_count = int(t.get("bookmarkCount", t.get("bookmark_count", 0)) or 0)
        created_at = t.get("createdAt", "")
        is_rt = text.startswith("RT @")
        
        # Author info
        author = t.get("author", {})
        author_handle = author.get("userName", handle)
        followers = author.get("followers", 0)
        
        tweet_date = parse_date(created_at)
        date_str = tweet_date.strftime("%Y-%m-%d") if tweet_date else ""
        
        # Score
        score = like_count + (retweet_count * 2) + reply_count + (view_count // 100)
        
        processed.append({
            "id": tweet_id,
            "text": text,
            "likes": like_count,
            "retweets": retweet_count,
            "replies": reply_count,
            "views": view_count,
            "bookmarks": bookmark_count,
            "createdAt": created_at,
            "date": date_str,
            "score": score,
            "is_rt": is_rt,
            "author": author_handle,
            "followers": followers,
        })
    
    return {"tweets": processed}

# Load existing results if any (resume support)
all_results = {"accounts": [], "errors": [], "scan_date": f"{DATE_STR} 06:00 UTC", "chunk": 1}
done_handles = set()
if os.path.exists(OUTPUT_FILE):
    try:
        with open(OUTPUT_FILE) as f:
            existing = json.load(f)
        for a in existing.get("accounts", []):
            done_handles.add(a["handle"])
        all_results["accounts"] = existing.get("accounts", [])
        all_results["errors"] = existing.get("errors", [])
    except Exception:
        pass

for i, handle in enumerate(HANDLES):
    if handle in done_handles:
        print(f"[{i+1}/{len(HANDLES)}] {handle} — already scanned, skipping")
        continue
    
    print(f"[{i+1}/{len(HANDLES)}] Fetching @{handle}...", end=" ", flush=True)
    result = fetch_tweets(handle)
    
    if "error" in result:
        print(f"ERROR: {result['error'][:80]}")
        all_results["errors"].append({"handle": handle, "error": str(result["error"])[:200]})
        all_results["accounts"].append({
            "handle": handle,
            "tweets": [],
            "recent_count": 0,
            "qualifying_count": 0,
            "error": str(result["error"])[:200],
        })
    else:
        raw_tweets = result["tweets"]
        
        # Apply date filter
        recent = [t for t in raw_tweets if parse_date(t.get("createdAt", "")) is not None 
                  and parse_date(t.get("createdAt", "")) >= CUTOFF]
        
        # Apply engagement thresholds
        qualifying = [t for t in recent if 
            t["likes"] >= 50 or t["retweets"] >= 10 or t["views"] >= 1000]
        qualifying.sort(key=lambda x: x["score"], reverse=True)
        
        print(f"{len(raw_tweets)} tweets, {len(recent)} recent, {len(qualifying)} qualifying")
        
        all_results["accounts"].append({
            "handle": handle,
            "tweets": qualifying,
            "recent_count": len(recent),
            "qualifying_count": len(qualifying),
        })
    
    # Incremental save
    with open(OUTPUT_FILE + ".tmp", "w") as f:
        json.dump(all_results, f, indent=2)
    
    time.sleep(1)

# Final save
os.rename(OUTPUT_FILE + ".tmp", OUTPUT_FILE)
print(f"\nChunk 1 complete. {len(all_results['accounts'])} accounts scanned. {len(all_results['errors'])} errors.")
print(f"Saved to {OUTPUT_FILE}")