import os, re, json, time, sys
from datetime import datetime, timezone, timedelta
import requests

# --- API key from ~/.hermes/.env ---
env_path = os.path.expanduser("~/.hermes/.env")
API_KEY = None
with open(env_path) as f:
    for line in f:
        if line.startswith("GETXAPI_KEY="):
            API_KEY = line.strip().split("=", 1)[1]
            break
if not API_KEY:
    print("NO API KEY"); sys.exit(1)

# --- Watchlist ---
wl = open("/home/kiro/trend-engine/trends/x/raw/rising-accounts.md").read()

# Extract @handles. Also capture markdown reference plaintext handles so we can
# cross-check nothing valid was filtered.
handles = re.findall(r"@(\w+)", wl)
handles = list(dict.fromkeys(handles))  # dedupe preserving order

# SKIP_WORDS: noise tokens. Explicitly do NOT include nofilmschool / curiousrefuge.
SKIP_WORDS = {"x", "youtube", "facebook", "marketingbrew", "theankler", "xo2",
              "besttwitteraccounts", "pixflow", "blogs", "etcjournal",
              "letsdatascience", "nofilmschoolcom", "curiousrefugecom"}

# IRRELEVANT_HANDLES (from skill)
IRRELEVANT = {
    # AI news aggregators
    "AIBuzzNews","AIGuideHQ","AITECHio","AIFrontliner","AIWarper","TheAIColony","AITOPIAai",
    # Non-filmmaking auto-discoveries
    "GoogleLabs","GoogleAI","DonutAI","cladlabs","4aibsc","FaithJaiye2187","KammelaBala","MyStageAI","AlexStudio44",
    # Content repost accounts
    "AI_Video_Dumps","AI_with_jasmin","Ai_Vaidehi","CharaspowerAI","ChrisLaubAI",
    # Other non-core
    "CINEMA505","Chandan_Perla",
}

CORE = {"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"}

clean = [h for h in handles if h not in SKIP_WORDS]

# Safety: ensure no CORE handle was dropped by filtering
missing_core = [c for c in CORE if c not in clean]
if missing_core:
    print("WARNING missing core:", missing_core)
    clean += missing_core

clean = list(dict.fromkeys(clean))
print(f"Scanning {len(clean)} handles")

ENDPOINT = "https://api.getxapi.com/twitter/user/tweets?userName={handle}&count=5"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def scan_handle(handle):
    url = ENDPOINT.format(handle=handle)
    try:
        r = requests.get(url, headers=HEADERS, timeout=60)
        if r.status_code != 200:
            return None, f"HTTP {r.status_code}"
        data = r.json()
        tweets = data.get("tweets") or data.get("data") or []
        return tweets, None
    except Exception as e:
        return None, str(e)

def parse_date(s):
    try:
        return datetime.strptime(s, "%a %b %d %H:%M:%S %z %Y")
    except Exception:
        try:
            return datetime.fromisoformat(s.replace("Z", "+00:00"))
        except Exception:
            return None

now = datetime.now(timezone.utc)
cutoff = (now - timedelta(days=3)).replace(hour=0, minute=0, second=0, microsecond=0)
today = now.strftime("%Y-%m-%d")

all_results = {}
failed = []

for h in clean:
    tweets, err = scan_handle(h)
    if err:
        failed.append((h, err))
        time.sleep(0.8)
        continue
    all_results[h] = tweets
    time.sleep(0.8)

# save raw
os.makedirs("/home/kiro/trend-engine/trends/x/raw", exist_ok=True)
with open(f"/home/kiro/trend-engine/trends/x/raw/scan_results_{today}_FULL.json", "w") as f:
    json.dump({"results": {k: v for k, v in all_results.items() if v}, "failed": failed}, f, default=str)

# --- Score ---
qualifying = []   # relevant, qualifying
filtered = []     # irrelevant, qualifying
inactive_core = []

for h, tweets in all_results.items():
    if not tweets:
        continue
    is_irrelevant = h in IRRELEVANT
    best = None
    for t in tweets:
        if t.get("retweeted_tweet"):
            continue  # skip RTs
        created = parse_date(t.get("createdAt") or t.get("created_at") or "")
        if created is None or created < cutoff:
            continue
        likes = t.get("likeCount") or 0
        rts = t.get("retweetCount") or 0
        reps = t.get("replyCount") or 0
        views = t.get("viewCount") or 0
        score = likes + (rts * 2) + (reps * 3) + (views / 100.0)
        if likes >= 50 or rts >= 10 or views >= 1000:
            rec = {"handle": h, "id": t.get("id"), "url": f"https://x.com/{h}/status/{t.get('id')}",
                   "text": (t.get("text") or "").strip(), "likes": likes, "rts": rts,
                   "reps": reps, "views": views, "score": score, "date": created}
            if best is None or score > best["score"]:
                best = rec
    if best:
        if is_irrelevant:
            filtered.append(best)
        else:
            qualifying.append(best)
    else:
        # track inactivity only for core high-value accounts
        if h in CORE:
            # check most recent tweet date
            newest = None
            for t in tweets:
                d = parse_date(t.get("createdAt") or t.get("created_at") or "")
                if d and (newest is None or d > newest):
                    newest = d
            inactive_core.append((h, newest))

qualifying.sort(key=lambda x: -x["score"])
filtered.sort(key=lambda x: -x["score"])

print("\n===== QUALIFYING (relevant) =====")
for q in qualifying:
    print(q["handle"], q["views"], q["score"])

print("\n===== FILTERED (irrelevant) =====")
for q in filtered:
    print(q["handle"], q["views"], q["score"])

print("\n===== FAILED =====")
for h, e in failed:
    print(h, e)

print("\n===== INACTIVE CORE =====")
for h, d in inactive_core:
    print(h, d)

# persist structured results for report generation
report = {"today": today, "qualifying": qualifying, "filtered": filtered,
          "failed": failed, "inactive_core": [(h, str(d)) for h, d in inactive_core]}
with open(f"/home/kiro/trend-engine/trends/x/raw/scan_scored_{today}.json", "w") as f:
    json.dump(report, f, default=str)
print("\nDONE")