Bet Grading System

class UnifiedGradingScheduler:
    def __init__(self, mongo_uri, db_name, api_token, bot_type='player'):
        # Initialize processors
        self.result_processor = UnifiedResultProcessor(
            mongo_uri=mongo_uri,
            database_name=db_name,
            api_token=api_token,  # Deprecated (kept for compatibility)
            bot_type=bot_type
        )
        
        self.sheets_sync = UnifiedSheetsSync(
            credentials_path=credentials_path,
            spreadsheet_name=spreadsheet_name,
            bot_type=bot_type,
            collection=self.result_processor.collection
        )
        
        # Adaptive scheduling
        self.grading_interval = 120  # 2 minutes default
        self.sync_interval = 60      # 1 minute
        
        # Threads
        self.grading_thread = threading.Thread(target=self._grading_loop)
        self.sync_thread = threading.Thread(target=self._syncing_loop)

def batch_fetch_fixtures(self, fixture_ids: List[str]) -> Dict[str, Dict]:
    """
    Fetch FotMob data for multiple fixtures.
    Uses cache (fixture_api_cache_fm) to minimize API calls.
    """
    all_fixtures = {}
    
    for fixture_id in fixture_ids:
        # Check cache first
        cached = self._get_cached_fixture_details(fixture_id)
        if cached:
            all_fixtures[fixture_id] = cached
            continue
        
        # Fetch from FotMob API
        try:
            details = self.fotmob.get_fixture_details(int(fixture_id))
            if details:
                all_fixtures[fixture_id] = details
                
                # Cache result
                self.fixture_api_cache_fm.update_one(
                    {'match_id': str(fixture_id)},
                    {'$set': {'data': details, 'cached_at': datetime.now()}},
                    upsert=True
                )
        except Exception as e:
            logger.error(f"Error fetching fixture {fixture_id}: {e}")
            
            # Try fixture ID resolution (mapping collections)
            resolved_id = self._lookup_fotmob_fixture_id_from_mappings(
                alert=None,
                failed_fixture_id=fixture_id
            )
            
            if resolved_id and resolved_id != fixture_id:
                # Retry with resolved ID
                details = self.fotmob.get_fixture_details(int(resolved_id))
                if details:
                    all_fixtures[fixture_id] = details
    
    return all_fixtures

def calculate_returns(self, bet_doc: Dict, result_status: str) -> Dict:
    """
    Calculate returns and profit/loss based on result.
    """
    stake = bet_doc.get('actual_stake', 0.0)
    units_staked = bet_doc.get('units_staked', stake)
    odds = bet_doc.get('odds', 1.0)
    
    if result_status == 'won':
        returns = units_staked * odds
        profit_loss = returns - units_staked
    
    elif result_status == 'refund':
        returns = units_staked
        profit_loss = 0.0
    
    elif result_status == 'half_win':
        # Asian handicap half win
        returns = (units_staked / 2) * odds + (units_staked / 2)
        profit_loss = returns - units_staked
    
    elif result_status == 'half_loss':
        # Asian handicap half loss
        returns = units_staked / 2
        profit_loss = returns - units_staked
    
    else:  # lost
        returns = 0.0
        profit_loss = -units_staked
    
    bet_doc['status'] = result_status
    bet_doc['returns'] = returns
    bet_doc['profit_loss'] = profit_loss
    bet_doc['settled_at'] = datetime.now(timezone.utc)
    
    return bet_doc

def check_player_lineup_status(self, fixture_id, player_id, fixture_data):
    """
    Check if player started or was on bench.
    
    Returns:
        (should_refund, reason)
    """
    lineup = fixture_data.get('content', {}).get('lineup', {})
    
    if not lineup:
        return False, "unknown_lineup"
    
    # Check both teams
    for side in ['homeTeam', 'awayTeam']:
        # Check starters
        for player in lineup[side].get('starters', []):
            if str(player.get('id')) == str(player_id):
                return False, "started"  # Don't refund
        
        # Check bench
        for player in lineup[side].get('bench', []):
            if str(player.get('id')) == str(player_id):
                return True, "bench"  # Refund (didn't start)
    
    # Player not found in lineup at all
    return True, "not_in_lineup"

def _lookup_fotmob_fixture_id_from_mappings(self, alert, failed_fixture_id):
    """
    Resolve FotMob fixture ID from legacy/odds IDs.
    """
    # Collect candidate IDs
    candidates = [
        failed_fixture_id,
        alert.get('fixture_id'),
        alert.get('odds_fixture_id'),
        alert.get('original_id')
    ]
    
    # Try team_fixture_mappings_fm
    mapping = self.team_fixture_mappings_fm.find_one({
        '$or': [
            {'odds_fixture_id': {'$in': candidates}},
            {'projection_fixture_id': {'$in': candidates}}
        ]
    })
    
    if mapping:
        fotmob_id = mapping.get('fotmob_fixture_id')
        logger.info(f"Resolved {failed_fixture_id} -> {fotmob_id}")
        return str(fotmob_id)
    
    # Try fixture_mappings_fm (legacy)
    mapping = self.fixture_mappings_fm.find_one({
        '$or': [
            {'odds_fixture_id': {'$in': candidates}},
            {'fotmob_fixture_id': {'$in': candidates}}
        ]
    })
    
    if mapping:
        return str(mapping.get('fotmob_fixture_id'))
    
    return None

def _find_correct_fixture_id(self, home_team: str, away_team: str, date_str: str) -> Optional[str]:
    """
    Search FotMob for fixture by team names and date.
    """
    # Calculate date range
    dt = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
    start_date = (dt - timedelta(days=2)).strftime('%Y-%m-%d')
    end_date = (dt + timedelta(days=2)).strftime('%Y-%m-%d')
    
    # Sanitize team names
    clean_home = self._sanitize_team_name(home_team)
    clean_away = self._sanitize_team_name(away_team)
    
    # Search FotMob
    match_name = f"{clean_home} vs {clean_away}"
    fixtures = self.fotmob.search_fixture_by_name(match_name)
    
    # Filter by date
    for fixture in fixtures:
        fixture_date = fixture.get('matchDate', '')[:10]
        if start_date <= fixture_date <= end_date:
            # Verify opponent match
            if self._is_fuzzy_match(clean_away, fixture.get('awayTeamName')):
                return str(fixture['id'])
    
    return None

def run_sync_logic(self):
    """
    Rotate through graded alerts using 'last_sync_check' timestamp.
    """
    query = {
        'result_tracking.result_status': {'$nin': ['pending', None, '']},
        'result_tracking.stat_type': {'$ne': 'untrackable'},
        **self.config['filter']
    }
    
    # Sort by last_sync_check (oldest first)
    # Alerts never synced (null) come first
    graded_batch = list(self.collection.find(query)
        .sort('last_sync_check', ASCENDING)
        .limit(self.sync_batch_size)
    )
    
    if not graded_batch:
        return
    
    # Sync to sheet (deduplicates against current sheet content)
    synced_count = self.sheets_sync.sync_alerts(graded_batch)
    
    # Update last_sync_check for all processed alerts
    now = datetime.utcnow()
    alert_ids = [a['_id'] for a in graded_batch]
    self.collection.update_many(
        {'_id': {'$in': alert_ids}},
        {'$set': {'last_sync_check': now}}
    )