#!/var/www/html/eventheodds/.venv-scraper/bin/python
"""
Fetch Betting Splits (Public Betting Percentages)
Scrapes Action Network for public betting data.

Captures: spread %, moneyline %, total % for each side
Stores in BettingSplits table.

Run: Every 2 hours during active betting windows
"""
import psycopg2
import re
import json
import os
from datetime import datetime, timezone
from dotenv import load_dotenv

# Import proxy utilities with fallback support
try:
    from proxy_config import make_request
    USE_PROXY_CONFIG = True
except ImportError:
    import requests
    USE_PROXY_CONFIG = False
    PROXY_CONFIG = {
        'http': 'socks5h://goDRdyJf:1aIFz9LNOW@82.163.172.166:50101',
        'https': 'socks5h://goDRdyJf:1aIFz9LNOW@82.163.172.166:50101'
    }

HEADERS = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml',
}

LEAGUES = {
    'nba': {'url': 'https://www.actionnetwork.com/nba/public-betting', 'league_id': 4},
    'nfl': {'url': 'https://www.actionnetwork.com/nfl/public-betting', 'league_id': 1},
    'nhl': {'url': 'https://www.actionnetwork.com/nhl/public-betting', 'league_id': 6},
}


def load_db_url():
    load_dotenv('/var/www/html/eventheodds/.env')
    url = os.environ.get('SPORTS_DATABASE_URL', '')
    return url.split('?')[0] if '?' in url else url


def ensure_table(cur):
    """Create table if it doesn't exist"""
    cur.execute('''
        CREATE TABLE IF NOT EXISTS "BettingSplits" (
            id SERIAL PRIMARY KEY,
            league VARCHAR(20) NOT NULL,
            "externalGameId" VARCHAR(100) NOT NULL,
            "gameDate" TIMESTAMP WITH TIME ZONE,
            "homeTeam" VARCHAR(100),
            "awayTeam" VARCHAR(100),
            "spreadHomePct" FLOAT,
            "spreadAwayPct" FLOAT,
            "mlHomePct" FLOAT,
            "mlAwayPct" FLOAT,
            "totalOverPct" FLOAT,
            "totalUnderPct" FLOAT,
            source VARCHAR(50) DEFAULT 'actionnetwork',
            "capturedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
            "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
        )
    ''')
    cur.execute('''
        CREATE INDEX IF NOT EXISTS idx_betting_splits_league_game
        ON "BettingSplits" (league, "externalGameId")
    ''')


def fetch_action_network(league_config):
    try:
        if USE_PROXY_CONFIG:
            # Use proxy_config with automatic datacenter->residential fallback
            r = make_request(
                league_config['url'],
                proxy_type='datacenter',
                retry_with_residential=True,
                timeout=30,
                headers=HEADERS,
                delay_range=(1, 2)
            )
        else:
            import requests
            r = requests.get(
                league_config['url'],
                proxies=PROXY_CONFIG,
                headers=HEADERS,
                timeout=30
            )

        if r is None:
            print(f"  Request failed (all proxies)")
            return []

        if r.status_code != 200:
            print(f"  HTTP {r.status_code}")
            return []

        match = re.search(
            r'<script id="__NEXT_DATA__"[^>]*>(.*?)</script>',
            r.text,
            re.DOTALL
        )

        if not match:
            print("  No __NEXT_DATA__ found")
            return []

        data = json.loads(match.group(1))
        props = data.get('props', {}).get('pageProps', {})
        scoreboard = props.get('scoreboardResponse', {})
        games = scoreboard.get('games', [])

        results = []

        for game in games:
            if game.get('status') == 'complete':
                continue

            teams = game.get('teams', [])
            if len(teams) < 2:
                continue
                
            away_team = teams[0]
            home_team = teams[1]

            game_data = {
                'external_id': str(game.get('id', '')),
                'game_date': game.get('start_time'),
                'home_team': home_team.get('full_name', 'Unknown'),
                'away_team': away_team.get('full_name', 'Unknown'),
                'num_bets': game.get('num_bets', 0),
                'markets': {},
            }

            markets = game.get('markets', {})
            for book_id, book_data in markets.items():
                event_markets = book_data.get('event', {})

                for market_type in ['spread', 'moneyline', 'total']:
                    market_data = event_markets.get(market_type, [])

                    if market_data and market_type not in game_data['markets']:
                        home_pct = None
                        away_pct = None
                        over_pct = None
                        under_pct = None

                        for outcome in market_data:
                            pct = outcome.get('public_pct') or outcome.get('tickets_pct')
                            side = outcome.get('side', '')

                            if pct:
                                if side == 'home':
                                    home_pct = pct
                                elif side == 'away':
                                    away_pct = pct
                                elif side == 'over':
                                    over_pct = pct
                                elif side == 'under':
                                    under_pct = pct

                        game_data['markets'][market_type] = {
                            'home_pct': home_pct,
                            'away_pct': away_pct,
                            'over_pct': over_pct,
                            'under_pct': under_pct,
                        }

                break

            if game_data['markets']:
                results.append(game_data)

        return results

    except Exception as e:
        print(f"  Error fetching: {e}")
        return []


def store_splits(conn, league, games_data):
    cur = conn.cursor()
    stored = 0

    for game in games_data:
        # Collect all market data for a single insert
        spread_data = game.get('markets', {}).get('spread', {})
        ml_data = game.get('markets', {}).get('moneyline', {})
        total_data = game.get('markets', {}).get('total', {})

        try:
            cur.execute('''
                INSERT INTO "BettingSplits"
                (league, "externalGameId", "gameDate", "homeTeam", "awayTeam",
                 "spreadHomePct", "spreadAwayPct",
                 "mlHomePct", "mlAwayPct",
                 "totalOverPct", "totalUnderPct",
                 source, "capturedAt", "createdAt")
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, NOW(), NOW())
            ''', (
                league,
                game['external_id'],
                game['game_date'],
                game['home_team'],
                game['away_team'],
                spread_data.get('home_pct'),
                spread_data.get('away_pct'),
                ml_data.get('home_pct'),
                ml_data.get('away_pct'),
                total_data.get('over_pct'),
                total_data.get('under_pct'),
                'actionnetwork',
            ))
            stored += 1
        except Exception as e:
            print(f"    Error storing: {e}")
            conn.rollback()

    conn.commit()
    cur.close()
    return stored


def main():
    print("=" * 60)
    print("FETCH BETTING SPLITS (Action Network)")
    print(f"Time: {datetime.now(timezone.utc).isoformat()}")
    print("=" * 60)

    db_url = load_db_url()
    if not db_url:
        print("ERROR: No database URL found")
        return

    conn = psycopg2.connect(db_url)
    cur = conn.cursor()
    ensure_table(cur)
    conn.commit()
    cur.close()

    total_stored = 0

    for league, config in LEAGUES.items():
        print(f"\n{league.upper()}: Fetching from Action Network...")

        games = fetch_action_network(config)
        print(f"  Found {len(games)} upcoming games")

        if games:
            stored = store_splits(conn, league, games)
            total_stored += stored
            print(f"  Stored {stored} market records")

    conn.close()

    print("\n" + "=" * 60)
    print(f"TOTAL: {total_stored} betting split records captured")
    print("=" * 60)


if __name__ == '__main__':
    main()