import requests
import os
from datetime import datetime, timedelta
from dotenv import load_dotenv
from db import get_connection
from config import TICKERS

load_dotenv()

API_KEY = os.getenv("FMP_API_KEY")
BASE_URL = "https://financialmodelingprep.com/stable"

def get_analyst_grades(ticker, days=90):
    url = f"{BASE_URL}/grades?symbol={ticker}&limit=20&apikey={API_KEY}"
    r = requests.get(url, timeout=10)
    if r.status_code != 200:
        return []
    data = r.json()
    cutoff = datetime.now() - timedelta(days=days)
    return [g for g in data if datetime.strptime(g["date"], "%Y-%m-%d") >= cutoff]

def get_insider_trades(ticker, days=90):
    url = f"{BASE_URL}/insider-trading/search?symbol={ticker}&limit=20&apikey={API_KEY}"
    r = requests.get(url, timeout=10)
    if r.status_code != 200:
        return []
    data = r.json()
    cutoff = datetime.now() - timedelta(days=days)
    return [t for t in data if datetime.strptime(t["transactionDate"], "%Y-%m-%d") >= cutoff]

def analyze_grades(grades):
    if not grades:
        return 0, 0
    upgrades = sum(1 for g in grades if g.get("action") in ("upgrade", "Upgrade", "initiated", "Initiated"))
    downgrades = sum(1 for g in grades if g.get("action") in ("downgrade", "Downgrade"))
    return upgrades, downgrades

def analyze_insider_buying(trades):
    buys = [t for t in trades if t.get("transactionType") in ("P-Purchase", "Purchase")]
    sells = [t for t in trades if t.get("transactionType") in ("S-Sale", "Sale")]
    buy_value = sum(abs(t.get("securitiesTransacted", 0) * t.get("price", 0)) for t in buys)
    sell_value = sum(abs(t.get("securitiesTransacted", 0) * t.get("price", 0)) for t in sells)
    return len(buys), len(sells), round(buy_value, 2), round(sell_value, 2)

def get_company_id(ticker):
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute("SELECT id FROM companies WHERE ticker=%s", (ticker,))
    row = cursor.fetchone()
    cursor.close()
    conn.close()
    return row[0] if row else None

def save_catalyst(company_id, ticker, data):
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute("""
        INSERT INTO catalysts
        (company_id, catalyst_date, type, description, source, score_points)
        VALUES (%s, CURDATE(), %s, %s, %s, %s)
    """, (
        company_id,
        data["type"],
        data["description"],
        "FMP",
        data["score_points"]
    ))
    conn.commit()
    cursor.close()
    conn.close()

def process_ticker(ticker):
    print(f"Procesando {ticker}...")
    try:
        grades = get_analyst_grades(ticker)
        trades = get_insider_trades(ticker)

        upgrades, downgrades = analyze_grades(grades)
        buy_count, sell_count, buy_value, sell_value = analyze_insider_buying(trades)

        company_id = get_company_id(ticker)
        if not company_id:
            print(f"  {ticker}: company_id no encontrado")
            return

        if upgrades > 0:
            save_catalyst(company_id, ticker, {
                "type": "analyst_upgrade",
                "description": f"{upgrades} upgrade(s), {downgrades} downgrade(s) en últimos 90 días",
                "score_points": min(upgrades * 2, 10)
            })

        if buy_count > 0 and buy_value > sell_value:
            save_catalyst(company_id, ticker, {
                "type": "insider_buying",
                "description": f"{buy_count} compra(s) insider — ${buy_value:,.0f} vs ${sell_value:,.0f} ventas",
                "score_points": min(buy_count * 2, 10)
            })

        print(f"  {ticker}: OK — Upgrades: {upgrades} | Downgrades: {downgrades} | Insider buys: {buy_count} (${buy_value:,.0f})")

    except Exception as e:
        print(f"  {ticker}: ERROR — {e}")

if __name__ == "__main__":
    for ticker in TICKERS:
        process_ticker(ticker)
    print("\nIngesta de catalizadores completada.")