#!/usr/bin/env python3
"""
Manual script to distribute packs to all human-controlled teams
"""
import argparse
import asyncio
import logging
import os
import sys
from api_calls import db_get, db_post, DB_URL

# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger('manual_pack_dist')


def check_environment():
    """Check that required environment variables are set"""
    api_token = os.getenv('API_TOKEN')
    database_env = os.getenv('DATABASE', 'dev')

    if not api_token:
        logger.error("ERROR: API_TOKEN environment variable is not set!")
        logger.error("Please set it with: export API_TOKEN='your-token-here'")
        sys.exit(1)

    logger.info(f"Using database environment: {database_env}")
    logger.info(f"API URL: {DB_URL}")
    logger.info(f"API Token: {'*' * (len(api_token) - 4)}{api_token[-4:] if len(api_token) > 4 else '****'}")
    logger.info("")


async def distribute_packs(num_packs: int = 5, exclude_team_abbrev: list[str] = None):
    """Distribute packs to all human-controlled teams

    Args:
        num_packs: Number of packs to give to each team (default: 5)
        exclude_team_abbrev: List of team abbreviations to exclude (default: None)
    """
    if exclude_team_abbrev is None:
        exclude_team_abbrev = []

    # Convert to uppercase for case-insensitive matching
    exclude_team_abbrev = [abbrev.upper() for abbrev in exclude_team_abbrev]

    # Step 1: Get current season
    logger.info("Fetching current season...")
    current = await db_get('current')
    if current is None:
        logger.error("Failed to fetch current season from API. Check your API_TOKEN and DATABASE environment variables.")
        logger.error(f"API URL: {DB_URL}")
        logger.error("Make sure the API endpoint is accessible and your token is valid.")
        raise ValueError("Could not connect to the database API")

    logger.info(f"Current season: {current['season']}")

    # Step 2: Get all teams for current season
    logger.info(f"Fetching all teams for season {current['season']}...")
    all_teams = await db_get('teams', params=[('season', current['season'])])
    if all_teams is None:
        logger.error("Failed to fetch teams from API")
        raise ValueError("Could not fetch teams from the database API")

    logger.info(f"Found {all_teams['count']} total teams")

    # Step 3: Filter for human-controlled teams only
    qualifying_teams = []
    for team in all_teams['teams']:
        if not team['is_ai'] and 'gauntlet' not in team['abbrev'].lower():
            # Check if team is in exclusion list
            if team['abbrev'].upper() in exclude_team_abbrev:
                logger.info(f"  - {team['abbrev']}: {team['sname']} (EXCLUDED)")
                continue
            qualifying_teams.append(team)
            logger.info(f"  - {team['abbrev']}: {team['sname']}")

    logger.info(f"\nFound {len(qualifying_teams)} human-controlled teams")
    if exclude_team_abbrev:
        logger.info(f"Excluded teams: {', '.join(exclude_team_abbrev)}")

    # Step 4: Distribute packs
    pack_type_id = 1  # Standard packs

    logger.info(f"\nDistributing {num_packs} standard packs to each team...")

    for team in qualifying_teams:
        logger.info(f"Giving {num_packs} packs to {team['abbrev']} ({team['sname']})...")

        # Create pack payload
        pack_payload = {
            'packs': [{
                'team_id': team['id'],
                'pack_type_id': pack_type_id,
                'pack_cardset_id': None
            } for _ in range(num_packs)]
        }

        try:
            result = await db_post('packs', payload=pack_payload)
            logger.info(f"  ✓ Successfully gave packs to {team['abbrev']}")
        except Exception as e:
            logger.error(f"  ✗ Failed to give packs to {team['abbrev']}: {e}")

    logger.info(f"\n🎉 All done! Distributed {num_packs} packs to {len(qualifying_teams)} teams")


if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Distribute packs to all human-controlled teams',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Give 5 packs to all teams (default)
  python manual_pack_distribution.py

  # Give 10 packs to all teams
  python manual_pack_distribution.py --num-packs 10

  # Give 5 packs, excluding certain teams
  python manual_pack_distribution.py --exclude-team-abbrev NYY BOS

  # Give 3 packs, excluding one team
  python manual_pack_distribution.py --num-packs 3 --exclude-team-abbrev LAD

Environment Variables:
  API_TOKEN    - Required: API authentication token
  DATABASE     - Optional: 'dev' (default) or 'prod'
        """
    )
    parser.add_argument(
        '--num-packs',
        type=int,
        default=5,
        help='Number of packs to give to each team (default: 5)'
    )
    parser.add_argument(
        '--exclude-team-abbrev',
        nargs='*',
        default=[],
        help='Team abbreviations to exclude (space-separated, e.g., NYY BOS LAD)'
    )

    args = parser.parse_args()

    # Check environment before running
    check_environment()

    asyncio.run(distribute_packs(num_packs=args.num_packs, exclude_team_abbrev=args.exclude_team_abbrev))