"""
Discover HT 1X2 market IDs/keys for scrapers not yet implemented.

Targets: Bet9ja, NairaBet, MSport, BetKing, Betpawa, Bangbet, Stake, BCGame, SportyBet
Prints all seen market IDs/names alongside their outcome names so we can
identify which one is Half-Time 1X2.

Run: python tools/discover_ht_markets.py
"""
import sys, os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

import json, time, logging
import requests

logging.basicConfig(level=logging.WARNING)

SEP = '-' * 70


# ── Bet9ja ────────────────────────────────────────────────────────────────────

def discover_bet9ja():
    print(f'\n{SEP}\nBet9ja — scanning S_ key prefixes in GetEvent response\n{SEP}')
    try:
        r = requests.get(
            'https://sports.bet9ja.com/desktop/feapi/PalimpsestAjax/GetSports?DISP=1000',
            headers={
                'User-Agent': 'Mozilla/5.0',
                'X-Requested-With': 'XMLHttpRequest',
                'Referer': 'https://sports.bet9ja.com/',
            },
            timeout=15,
        )
        data = r.json()
        # Get first soccer event id
        sports = data.get('D', {}).get('PAL', {})
        soccer = sports.get('1', {})
        event_id = None
        for sg in soccer.get('SG', {}).values():
            for gid, g in sg.get('G', {}).items():
                for eid in (g.get('E') or {}).keys():
                    event_id = eid
                    break
                if event_id:
                    break
            if event_id:
                break

        if not event_id:
            print('  No event found')
            return

        print(f'  Probing event {event_id}')
        r2 = requests.get(
            'https://sports.bet9ja.com/desktop/feapi/PalimpsestAjax/GetEvent',
            params={'EVENTID': event_id},
            headers={'User-Agent': 'Mozilla/5.0', 'Referer': 'https://sports.bet9ja.com/'},
            timeout=15,
        )
        odds = r2.json().get('D', {}).get('O', {})
        # Group keys by prefix (before last _)
        prefixes = {}
        for key in odds.keys():
            parts = key.rsplit('_', 1)
            prefix = parts[0] if len(parts) == 2 else key
            prefixes.setdefault(prefix, []).append(key)

        # Print prefixes that look like market families
        for pfx, keys in sorted(prefixes.items()):
            # Filter to only print ones we don't already know
            known = {'S_1X2', 'S_DC', 'S_GGNG', 'S_DNB'}
            if any(k.startswith(kn) for k in keys for kn in known):
                continue
            if pfx.startswith('S_OU'):
                continue
            if pfx.startswith('S_AH'):
                continue
            sample_odds = {k: odds[k] for k in keys[:3]}
            print(f'  {pfx:30s}  keys={keys}  odds={sample_odds}')
    except Exception as ex:
        print(f'  ERROR: {ex}')


# ── NairaBet ──────────────────────────────────────────────────────────────────

def discover_nairabet():
    print(f'\n{SEP}\nNairaBet — scanning market type IDs in GetEvents response\n{SEP}')
    try:
        r = requests.get(
            'https://sb2frontend-altenar2.biahosted.com/api/Widget/GetEvents',
            params={
                'token':      'null',
                'languageId': '1',
                'timezoneOffset': '0',
                'scopeId':    '3',
                'siteId':     '27',
                'sportId':    '1',
                'ip':         '1.1.1.1',
                'countryCode': 'NG',
                'toDate':     '',
            },
            headers={
                'User-Agent': 'Mozilla/5.0',
                'Origin':  'https://www.nairabet.com',
                'Referer': 'https://www.nairabet.com/',
            },
            timeout=15,
        )
        events = r.json().get('Result', {}).get('Items', [])
        if not events:
            print('  No events')
            return

        ev = events[0]
        event_id = ev.get('Id')
        print(f'  Event: {ev.get("HomeCompetitorName")} vs {ev.get("AwayCompetitorName")}  id={event_id}')

        # Scan all markets
        seen = {}
        for market in (ev.get('Markets') or []):
            mtype = market.get('MarketTypeId')
            mname = market.get('MarketTypeName', '')
            if mtype not in seen:
                seen[mtype] = mname
        for mtype, mname in sorted(seen.items(), key=lambda x: x[0]):
            # Only print unknown ones
            known_ids = {1, 10, 11, 18, 26, 29}
            if mtype not in known_ids:
                print(f'  MarketTypeId={mtype:5d}  name={mname!r}')
    except Exception as ex:
        print(f'  ERROR: {ex}')


# ── MSport ────────────────────────────────────────────────────────────────────

def discover_msport():
    print(f'\n{SEP}\nMSport — scanning market IDs in facts-center response\n{SEP}')
    try:
        r = requests.get(
            'https://www.msport.com/api/ng/facts-center/query/frontend',
            params={
                'marketId': '1,10,11,18,26,29',  # known markets
                'sportId': '1',
                'count': '5',
                'lang': 'en',
            },
            headers={
                'User-Agent': 'Mozilla/5.0',
                'Referer': 'https://www.msport.com/ng/web',
                'Origin': 'https://www.msport.com',
            },
            timeout=15,
        )
        data = r.json()
        events = data.get('data', data.get('events', []))
        if not events:
            print('  No events (might need different params)')
            return
        ev = events[0]
        print(f'  Event found. Keys: {list(ev.keys())[:10]}')
        # Look for market structures
        for market in (ev.get('markets') or ev.get('Markets') or [])[:20]:
            mid = market.get('id') or market.get('marketId') or market.get('typeId')
            mname = market.get('name') or market.get('typeName') or ''
            print(f'  marketId={mid}  name={mname!r}')
    except Exception as ex:
        print(f'  ERROR: {ex}')

    # Try broader fetch with all market IDs
    try:
        r2 = requests.get(
            'https://www.msport.com/api/ng/facts-center/query/frontend',
            params={'sportId': '1', 'count': '3', 'lang': 'en'},
            headers={'User-Agent': 'Mozilla/5.0', 'Referer': 'https://www.msport.com/ng/web'},
            timeout=15,
        )
        data2 = r2.json()
        events2 = data2.get('data', data2.get('events', []))
        if events2:
            ev2 = events2[0]
            markets2 = ev2.get('markets') or ev2.get('Markets') or []
            seen = {}
            for m in markets2:
                mid = m.get('id') or m.get('marketId') or m.get('typeId')
                mname = m.get('name') or m.get('typeName') or ''
                if mid not in seen:
                    seen[mid] = mname
            print('  All market IDs in event:')
            for mid, mname in sorted(seen.items(), key=lambda x: str(x[0])):
                print(f'    {str(mid):10s}  {mname!r}')
    except Exception as ex:
        print(f'  Broad fetch ERROR: {ex}')


# ── BetKing ───────────────────────────────────────────────────────────────────

def discover_betking():
    print(f'\n{SEP}\nBetKing — scanning market IDs in prematch feed\n{SEP}')
    try:
        import datetime
        r = requests.get(
            'https://sportsapicdn-desktop.betking.com/api/feeds/prematch/mostpopularsports/en/1/2/50/',
            headers={
                'User-Agent': 'Mozilla/5.0',
                'Referer': 'https://www.betking.com/sports/s/football/',
                'Origin': 'https://www.betking.com',
            },
            timeout=15,
        )
        data = r.json()
        events = data if isinstance(data, list) else data.get('data', data.get('events', []))
        if not events:
            print('  No events')
            return
        ev = events[0]
        print(f'  Event: {ev.get("HomeTeam")} vs {ev.get("AwayTeam")}')
        seen = {}
        for market in (ev.get('MatchOdds') or ev.get('Markets') or ev.get('Odds') or []):
            mid = market.get('MarketId') or market.get('Id') or market.get('TypeId')
            mname = market.get('MarketName') or market.get('Name') or market.get('TypeName') or ''
            if mid is not None and mid not in seen:
                seen[mid] = mname
        known_ids = {110, 146, 147, 160, 302}
        for mid, mname in sorted(seen.items(), key=lambda x: x[0]):
            if mid not in known_ids:
                print(f'  MarketId={mid:5}  name={mname!r}')
    except Exception as ex:
        print(f'  ERROR: {ex}')


# ── Betpawa ───────────────────────────────────────────────────────────────────

def discover_betpawa():
    print(f'\n{SEP}\nBetpawa — need browser context; showing known market type IDs only\n{SEP}')
    print('  Betpawa requires Playwright (page.evaluate). Known IDs:')
    print('    3743 = 1X2     3742 = DC     5000 = O/U')
    print('    3795 = BTTS    4703 = DNB    3774 = AH')
    print('  HT 1X2 candidate IDs to try: 3741, 3740, 3750, 3760')
    print('  → To discover: add marketTypes=[3741,3740,3750,3760] to _paginate()')
    print('    and log any non-empty responses.')


# ── Bangbet ───────────────────────────────────────────────────────────────────

def discover_bangbet():
    print(f'\n{SEP}\nBangbet — probing group indices 4-8 for football\n{SEP}')
    url = 'https://bet-api.bangbet.com/api/bet/match/list'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Content-Type': 'application/json',
        'Origin': 'https://www.bangbet.com',
        'Referer': 'https://www.bangbet.com/',
    }
    for gi in range(4, 9):
        try:
            body = {
                'sportId': 'sr:sport:1',
                'producer': 3,
                'groupIndex': gi,
                'country': 'ng',
                'pageNo': 1,
                'pageSize': 3,
                'highLight': True,
            }
            r = requests.post(url, json=body, headers=headers, timeout=10)
            data = r.json()
            matches = (data.get('data') or {}).get('data') or []
            if matches:
                m = matches[0]
                markets = m.get('marketList', [])
                mkt_names = [mk.get('name') or mk.get('marketName') for ml in markets
                             for mk in (ml.get('markets') or [ml])]
                print(f'  groupIndex={gi}: {len(matches)} matches, market names={mkt_names[:5]}')
            else:
                print(f'  groupIndex={gi}: empty')
        except Exception as ex:
            print(f'  groupIndex={gi}: ERROR {ex}')


# ── Stake ─────────────────────────────────────────────────────────────────────

def discover_stake():
    print(f'\n{SEP}\nStake — HT market extId discovery via GraphQL (needs browser)\n{SEP}')
    print('  Stake uses GraphQL + Cloudflare. Known football extIds:')
    print('    1=1X2  10=DC  26=DNB  18=O/U  29=BTTS  11=AH')
    print('  HT 1X2 candidate extId: 60 or 17')
    print('  → Add extId 60 and 17 to the football SPORT_MARKETS and run the bot.')
    print('    If either returns 3-outcome markets, that is HT 1X2.')


# ── BCGame ────────────────────────────────────────────────────────────────────

def discover_bcgame():
    print(f'\n{SEP}\nBCGame — probing market IDs 60 and 17 for HT 1X2\n{SEP}')
    try:
        brand = '2103509236163162112'
        r = requests.get(
            f'https://api-k-c7818b61-623.sptpub.com/api/v4/prematch/brand/{brand}/en/0',
            headers={'User-Agent': 'Mozilla/5.0', 'Origin': 'https://bc.game', 'Referer': 'https://bc.game/'},
            timeout=15,
        )
        idx = r.json()
        versions = idx.get('top_events_versions', []) + idx.get('rest_events_versions', [])
        if not versions:
            print('  No versions in index')
            return

        # Fetch first chunk
        ver = versions[0]
        r2 = requests.get(
            f'https://api-k-c7818b61-623.sptpub.com/api/v4/prematch/brand/{brand}/en/{ver}',
            headers={'User-Agent': 'Mozilla/5.0', 'Origin': 'https://bc.game'},
            timeout=15,
        )
        chunk = r2.json()
        events = chunk.get('events') or {}

        # Find a football event
        for ev_id, ev in events.items():
            sport = (ev.get('desc') or {}).get('sport')
            if sport == '1':  # football
                markets = ev.get('markets') or {}
                print(f'  Football event {ev_id} — market IDs present: {sorted(markets.keys())}')
                for mid in ('17', '60'):
                    if mid in markets:
                        specs = markets[mid]
                        print(f'    market {mid}: {list(specs.keys())[:3]}')
                        for spec, outcomes in list(specs.items())[:1]:
                            print(f'      specifier={spec!r}  outcomes={list(outcomes.keys())}')
                    else:
                        print(f'    market {mid}: NOT present')
                break
    except Exception as ex:
        print(f'  ERROR: {ex}')


# ── SportyBet ─────────────────────────────────────────────────────────────────

def discover_sportybet():
    print(f'\n{SEP}\nSportyBet — probing market IDs 60 and 17 for HT 1X2\n{SEP}')
    try:
        ts = int(time.time() * 1000)
        # Add market IDs 17 and 60 to the request
        r = requests.get(
            'https://www.sportybet.com/api/ng/factsCenter/pcUpcomingEvents',
            params={
                'sportId': 'sr%3Asport%3A1',
                'marketIds': '1%2C17%2C60',
                'pageSize': '5',
                'pageNum': '1',
                '_t': ts,
            },
            headers={
                'User-Agent': 'Mozilla/5.0',
                'Referer': 'https://www.sportybet.com/ng/sport/football',
                'Origin': 'https://www.sportybet.com',
            },
            timeout=15,
        )
        data = r.json()
        events_list = (data.get('data') or {}).get('events') or data.get('events') or []
        if not events_list:
            print('  No events returned')
            return
        ev = events_list[0]
        home = ev.get('homeTeamName', '?')
        away = ev.get('awayTeamName', '?')
        print(f'  Event: {home} vs {away}')
        for mkt in (ev.get('markets') or []):
            mid = mkt.get('id')
            mname = mkt.get('name', '')
            outcomes = [o.get('desc') or o.get('name') for o in (mkt.get('outcomes') or [])]
            print(f'    marketId={mid}  name={mname!r}  outcomes={outcomes}')
    except Exception as ex:
        print(f'  ERROR: {ex}')


if __name__ == '__main__':
    discover_bet9ja()
    discover_nairabet()
    discover_bcgame()
    discover_sportybet()
    discover_bangbet()
    discover_betking()
    discover_msport()
    discover_betpawa()
    discover_stake()