Sports Ticker

# Config with personal teams
config.json

# State file
.live_state.json

# Python
__pycache__/
*.pyc
*.pyo

# IDE
.vscode/
.idea/

# Environment files
.env
.env.*
!.env.example
.cache/
.data/

{
  "teams": [
    {
      "name": "Tottenham Hotspur",
      "short_name": "Spurs",
      "emoji": "🐓",
      "sport": "soccer",
      "espn_id": "367",
      "espn_leagues": ["eng.1", "uefa.champions"],
      "enabled": true
    },
    {
      "name": "Bayern Munich",
      "short_name": "Bayern",
      "emoji": "🔴⚪",
      "sport": "soccer",
      "espn_id": "132",
      "espn_leagues": ["ger.1", "uefa.champions"],
      "enabled": true
    },
    {
      "name": "Los Angeles Lakers",
      "short_name": "Lakers",
      "emoji": "🏀💜💛",
      "sport": "basketball",
      "espn_id": "13",
      "espn_leagues": ["nba"],
      "enabled": false
    },
    {
      "name": "Kansas City Chiefs",
      "short_name": "Chiefs",
      "emoji": "🏈",
      "sport": "football",
      "espn_id": "12",
      "espn_leagues": ["nfl"],
      "enabled": false
    },
    {
      "name": "New York Rangers",
      "short_name": "Rangers",
      "emoji": "🏒",
      "sport": "hockey",
      "espn_id": "4",
      "espn_leagues": ["nhl"],
      "enabled": false
    }
  ],
  "alerts": {
    "goals": true,
    "red_cards": true,
    "halftime": true,
    "fulltime": true,
    "kickoff": true
  }
}

MIT License

Copyright (c) 2026 Sports Ticker Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

{
  "name": "@openclaw/sports-ticker",
  "version": "3.2.0",
  "description": "Live sports alerts with FREE ESPN API. Track soccer, football, basketball, hockey, baseball, F1 and more with real-time scoring, key events, and multi-team support. No API keys required!",
  "keywords": [
    "openclaw",
    "skill",
    "sports",
    "football",
    "soccer",
    "basketball",
    "hockey",
    "baseball",
    "f1",
    "espn",
    "live-scores",
    "alerts",
    "real-time"
  ],
  "author": "robbyczgw-cla",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/robbyczgw-cla/sports-ticker.git"
  },
  "homepage": "https://clawhub.ai/robbyczgw-cla/sports-ticker",
  "bugs": {
    "url": "https://github.com/robbyczgw-cla/sports-ticker/issues"
  },
  "openclaw": {
    "skill": true,
    "triggers": ["sports", "score", "match", "game"],
    "capabilities": [
      "live-alerts",
      "multi-sport",
      "real-time"
    ],
    "sports": ["soccer", "nfl", "nba", "nhl", "mlb", "f1"],
    "requirements": {
      "bins": ["python3"],
      "env": {}
    }
  },
  "files": [
    "SKILL.md",
    "README.md",
    "scripts/",
    "config/"
  ]
}

#!/usr/bin/env python3
"""
Auto Setup Crons - Generate cron configurations for upcoming fixtures.

Generates cron jobs for:
1. Pre-match reminder (30 mins before kickoff)
2. Live ticker activation (5 mins before kickoff)
3. Match monitoring (every 2 mins during match)

Usage:
    auto_setup_crons.py                     # All teams, next 7 days
    auto_setup_crons.py --days 14           # Next 14 days
    auto_setup_crons.py --team spurs        # Specific team
    auto_setup_crons.py --team spurs --output crons.json
"""

import sys
import json
import argparse
from pathlib import Path
from datetime import datetime, timedelta, timezone

sys.path.insert(0, str(Path(__file__).parent))
from config import get_teams, get_team_by_name

# Import schedule functions
from schedule import get_team_schedule, get_all_fixtures_json


def fixture_to_crons(fixture: dict, reminder_mins: int = 30, 
                     ticker_before_mins: int = 5, ticker_duration_mins: int = 180) -> list:
    """Generate cron configurations for a single fixture.
    
    Args:
        fixture: Fixture dict from schedule
        reminder_mins: Minutes before kickoff for reminder
        ticker_before_mins: Minutes before kickoff to start ticker
        ticker_duration_mins: How long to run ticker (default 3 hours)
    
    Returns:
        List of cron config dicts ready for OpenClaw cron API
    """
    crons = []
    
    date_str = fixture.get("date", "")
    if not date_str:
        return []
    
    try:
        kickoff = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
    except:
        return []
    
    # Skip if already in the past
    now = datetime.now(timezone.utc)
    if kickoff <= now:
        return []
    
    team_name = fixture.get("team_name", "Team")
    team_short = fixture.get("team_short", team_name.split()[0])
    opponent = fixture.get("opponent_short", fixture.get("opponent", "Opponent"))
    comp = fixture.get("competition", "Match")
    is_home = fixture.get("is_home", True)
    event_id = fixture.get("event_id", "")
    league = fixture.get("league", "eng.1")
    sport = fixture.get("sport", "soccer")
    
    # Match description
    home_away = "vs" if is_home else "@"
    match_desc = f"{team_short} {home_away} {opponent} ({comp})"
    
    # Date parts for cron expression
    kickoff_date = kickoff.strftime("%Y-%m-%d")
    
    # 1. Pre-match reminder
    reminder_time = kickoff - timedelta(minutes=reminder_mins)
    if reminder_time > now:
        reminder_cron = f"{reminder_time.minute} {reminder_time.hour} {reminder_time.day} {reminder_time.month} *"
        crons.append({
            "name": f"{team_short.lower()}-reminder-{kickoff_date}",
            "description": f"Pre-match reminder: {match_desc}",
            "schedule": reminder_cron,
            "oneshot": True,
            "enabled": True,
            "message": f"⏰ **Match Reminder!**\n\n{fixture.get('team_emoji', '⚽')} {match_desc}\n\n🕐 Kickoff in {reminder_mins} minutes!\n📍 {fixture.get('venue', 'TBD')}",
            "metadata": {
                "type": "reminder",
                "fixture_id": event_id,
                "kickoff": date_str,
                "team": team_short
            }
        })
    
    # 2. Live ticker start (one-shot to enable the monitoring)
    ticker_start = kickoff - timedelta(minutes=ticker_before_mins)
    if ticker_start > now:
        ticker_start_cron = f"{ticker_start.minute} {ticker_start.hour} {ticker_start.day} {ticker_start.month} *"
        
        # End time for ticker (kickoff + duration)
        ticker_end = kickoff + timedelta(minutes=ticker_duration_mins)
        
        crons.append({
            "name": f"{team_short.lower()}-ticker-start-{kickoff_date}",
            "description": f"Start live ticker: {match_desc}",
            "schedule": ticker_start_cron,
            "oneshot": True,
            "enabled": True,
            "message": f"Start live monitoring for {match_desc}. Run `python3 scripts/live_monitor.py` every 2 minutes until match ends. Event ID: {event_id}, League: {league}, Sport: {sport}",
            "metadata": {
                "type": "ticker_start",
                "fixture_id": event_id,
                "league": league,
                "sport": sport,
                "kickoff": date_str,
                "end_time": ticker_end.isoformat(),
                "team": team_short
            }
        })
    
    # 3. Live ticker (repeating during match)
    # This runs every 2 minutes for the duration of the match
    # Uses a different approach: window-based cron
    crons.append({
        "name": f"{team_short.lower()}-ticker-{kickoff_date}",
        "description": f"Live updates: {match_desc}",
        "schedule": "*/2 * * * *",  # Every 2 minutes
        "oneshot": False,
        "enabled": False,  # Disabled by default, enabled by ticker_start
        "window": {
            "start": (kickoff - timedelta(minutes=ticker_before_mins)).isoformat(),
            "end": (kickoff + timedelta(minutes=ticker_duration_mins)).isoformat()
        },
        "message": f"Check for updates on {match_desc}. Run `python3 scripts/live_monitor.py --event {event_id} --league {league} --sport {sport}`. Only report new events.",
        "metadata": {
            "type": "ticker",
            "fixture_id": event_id,
            "league": league,
            "sport": sport,
            "kickoff": date_str,
            "team": team_short
        }
    })
    
    return crons


def generate_cron_configs(fixtures: list, reminder_mins: int = 30) -> list:
    """Generate cron configs for a list of fixtures."""
    all_crons = []
    
    for fixture in fixtures:
        crons = fixture_to_crons(fixture, reminder_mins=reminder_mins)
        all_crons.extend(crons)
    
    return all_crons


def format_cron_summary(crons: list) -> str:
    """Format a human-readable summary of cron configs."""
    if not crons:
        return "No cron jobs to generate (no upcoming fixtures found)."
    
    lines = ["📅 **Generated Cron Jobs**\n"]
    
    # Group by fixture
    fixtures = {}
    for cron in crons:
        fixture_id = cron.get("metadata", {}).get("fixture_id", "unknown")
        if fixture_id not in fixtures:
            fixtures[fixture_id] = {
                "desc": cron.get("description", ""),
                "crons": []
            }
        fixtures[fixture_id]["crons"].append(cron)
    
    for fixture_id, data in fixtures.items():
        lines.append(f"\n🎯 **{data['desc'].split(': ')[-1]}**")
        for cron in data["crons"]:
            cron_type = cron.get("metadata", {}).get("type", "?")
            enabled = "✅" if cron.get("enabled") else "⏸️"
            schedule = cron.get("schedule", "?")
            lines.append(f"  {enabled} `{cron['name']}` ({cron_type})")
            lines.append(f"      Schedule: `{schedule}`")
    
    lines.append(f"\n**Total: {len(crons)} cron jobs for {len(fixtures)} fixtures**")
    
    return "\n".join(lines)


def output_openclaw_commands(crons: list) -> str:
    """Generate cron job JSON configs for the agent to use with the cron tool.
    
    NOTE: Does NOT execute any commands. Outputs JSON that the agent
    should pass to the platform cron tool (cron action=add).
    """
    if not crons:
        return json.dumps({"message": "No crons to add"})
    
    return json.dumps({
        "instructions": "Use the cron tool (action=add) to create these jobs. Do NOT use subprocess or CLI.",
        "crons": crons
    }, indent=2)


def main():
    parser = argparse.ArgumentParser(
        description="Generate cron configurations for upcoming fixtures",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  %(prog)s                           # All teams, next 7 days
  %(prog)s --days 14                 # Next 14 days
  %(prog)s --team spurs              # Only Spurs
  %(prog)s --output crons.json       # Save to file
  %(prog)s --commands                # Output as CLI commands
        """
    )
    parser.add_argument("--days", "-d", type=int, default=7,
                       help="Days to look ahead (default: 7)")
    parser.add_argument("--team", "-t", type=str,
                       help="Filter by team name")
    parser.add_argument("--reminder", "-r", type=int, default=30,
                       help="Reminder minutes before kickoff (default: 30)")
    parser.add_argument("--output", "-o", type=str,
                       help="Output JSON file path")
    parser.add_argument("--commands", "-c", action="store_true",
                       help="Output as OpenClaw CLI commands")
    parser.add_argument("--json", "-j", action="store_true",
                       help="Output as JSON")
    parser.add_argument("--summary", "-s", action="store_true",
                       help="Show human-readable summary (default)")
    
    args = parser.parse_args()
    
    # Get fixtures
    fixtures = get_all_fixtures_json(days=args.days, team_name=args.team)
    
    if not fixtures:
        print("No upcoming fixtures found.")
        sys.exit(0)
    
    # Generate cron configs
    crons = generate_cron_configs(fixtures, reminder_mins=args.reminder)
    
    # Output
    if args.output:
        Path(args.output).write_text(json.dumps(crons, indent=2))
        print(f"✅ Wrote {len(crons)} cron configs to {args.output}")
    elif args.commands:
        print(output_openclaw_commands(crons))
    elif args.json:
        print(json.dumps(crons, indent=2))
    else:
        # Default: summary
        print(format_cron_summary(crons))
        print("\n💡 Use --json or --commands for machine-readable output")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Score cache — persists last known results for all tracked teams.
Used by ticker.py and live_monitor.py.
"""

import json
from datetime import datetime, timezone
from pathlib import Path

CACHE_FILE = Path(__file__).parent.parent / ".score_cache.json"


def load_cache() -> dict:
    """Load full cache from disk."""
    if CACHE_FILE.exists():
        try:
            return json.loads(CACHE_FILE.read_text())
        except Exception:
            return {}
    return {}


def save_cache(cache: dict):
    """Write cache to disk."""
    CACHE_FILE.write_text(json.dumps(cache, indent=2))


def write_to_cache(team_key: str, result: str, source: str = "web_search"):
    """Store a result in the cache (creates or updates entry)."""
    cache = load_cache()
    now = datetime.now(timezone.utc)
    cache[team_key] = {
        "last_result": result,
        "match_date": now.strftime("%Y-%m-%d"),
        "source": source,
        "cached_at": now.isoformat(),
    }
    save_cache(cache)


def read_from_cache(team_key: str) -> dict | None:
    """Get cached entry for a team, or None if not cached."""
    return load_cache().get(team_key)


def format_cached_result(team_key: str) -> str:
    """Return a human-readable 'Last result: …' string, or empty string if no cache."""
    entry = read_from_cache(team_key)
    if not entry:
        return ""
    result = entry.get("last_result", "")
    date_str = entry.get("match_date", "")
    if date_str:
        try:
            date_label = datetime.strptime(date_str, "%Y-%m-%d").strftime("%d.%m.")
        except ValueError:
            date_label = date_str
        return f"Last result: {result} ({date_label})"
    return f"Last result: {result}"

#!/usr/bin/env python3
"""Configuration handler for sports-ticker."""

import json
from pathlib import Path
from typing import Optional

SKILL_DIR = Path(__file__).parent.parent
CONFIG_FILE = SKILL_DIR / "config.json"
CONFIG_EXAMPLE = SKILL_DIR / "config.example.json"

def load_config() -> dict:
    """Load configuration from config.json."""
    try:
        if CONFIG_FILE.exists():
            return json.loads(CONFIG_FILE.read_text())
        elif CONFIG_EXAMPLE.exists():
            print(f"⚠️  No config.json found. Copy config.example.json to config.json and customize it.")
            return json.loads(CONFIG_EXAMPLE.read_text())
        else:
            return {"teams": [], "alerts": {}}
    except json.JSONDecodeError as e:
        print(f"⚠️  Invalid JSON in config file: {e}")
        return {"teams": [], "alerts": {}}

def save_config(config: dict):
    """Save configuration to config.json."""
    CONFIG_FILE.write_text(json.dumps(config, indent=2))

def get_teams() -> list:
    """Get list of enabled teams."""
    config = load_config()
    return [t for t in config.get("teams", []) if t.get("enabled", True)]

def get_team_by_name(name: str) -> Optional[dict]:
    """Find a team by name (case-insensitive)."""
    name_lower = name.lower()
    for team in get_teams():
        if name_lower in team.get("name", "").lower() or name_lower in team.get("short_name", "").lower():
            return team
    return None

def get_alert_settings() -> dict:
    """Get alert configuration."""
    config = load_config()
    return config.get("alerts", {
        "goals": True,
        "red_cards": True,
        "halftime": True,
        "fulltime": True,
        "kickoff": True
    })

def add_team(name: str, espn_id: str = None, thesportsdb_id: str = None, 
             leagues: list = None, emoji: str = "⚽", short_name: str = None, sport: str = "soccer"):
    """Add a team to config."""
    config = load_config()
    
    team = {
        "name": name,
        "short_name": short_name or name.split()[0],
        "emoji": emoji,
        "sport": sport,
        "enabled": True
    }
    
    if espn_id:
        team["espn_id"] = espn_id
        # Default leagues based on sport
        if leagues:
            team["espn_leagues"] = leagues
        elif sport == "soccer":
            team["espn_leagues"] = ["eng.1", "uefa.champions"]
        elif sport == "football":
            team["espn_leagues"] = ["nfl"]
        elif sport == "basketball":
            team["espn_leagues"] = ["nba"]
        elif sport == "hockey":
            team["espn_leagues"] = ["nhl"]
        elif sport == "baseball":
            team["espn_leagues"] = ["mlb"]
        elif sport == "racing":
            team["espn_leagues"] = ["f1"]
        else:
            team["espn_leagues"] = []
    
    if thesportsdb_id:
        team["thesportsdb_id"] = thesportsdb_id
    
    config.setdefault("teams", []).append(team)
    save_config(config)
    print(f"✅ Added {name} to config.json")

if __name__ == "__main__":
    import sys
    
    if len(sys.argv) < 2:
        print("Config Manager")
        print("\nUsage:")
        print("  config.py show       - Show current config")
        print("  config.py teams      - List configured teams")
        sys.exit(0)
    
    cmd = sys.argv[1]
    
    if cmd == "show":
        print(json.dumps(load_config(), indent=2))
    elif cmd == "teams":
        teams = get_teams()
        print(f"Configured teams ({len(teams)}):\n")
        for t in teams:
            emoji = t.get("emoji", "⚽")
            name = t.get("name")
            espn = t.get("espn_id", "-")
            tsdb = t.get("thesportsdb_id", "-")
            print(f"  {emoji} {name:25} ESPN:{espn:6} TSDB:{tsdb}")

#!/usr/bin/env python3
"""
ESPN Sports API - FREE live scores with goal scorers, cards, and more!

No API key required. Works for:
- Football/Soccer (Premier League, Champions League, La Liga, Serie A, etc.)
- NFL, NBA, MLB, NHL (American sports)
- And many more...

Base URL: https://site.api.espn.com/apis/site/v2/sports/{sport}/{league}
"""

import urllib.request
import json
import sys
from typing import Optional
from pathlib import Path

# ESPN API Base
BASE_URL = "https://site.api.espn.com/apis/site/v2/sports"

# Sport-to-URL mapping
SPORT_MAPPING = {
    "soccer": "soccer",
    "football": "football",  # American football
    "basketball": "basketball",
    "hockey": "hockey",
    "baseball": "baseball",
    "racing": "racing",
}

# League display names by sport
LEAGUES = {
    "soccer": {
        # European
        "eng.1": "Premier League",
        "eng.2": "Championship",
        "esp.1": "La Liga",
        "ger.1": "Bundesliga",
        "ita.1": "Serie A",
        "fra.1": "Ligue 1",
        "ned.1": "Eredivisie",
        "por.1": "Primeira Liga",
        "ger.1": "German Bundesliga",
        # European competitions
        "uefa.champions": "Champions League",
        "uefa.europa": "Europa League",
        "uefa.europa.conf": "Conference League",
        # Americas
        "usa.1": "MLS",
        "mex.1": "Liga MX",
        "bra.1": "Brasileirão",
        "arg.1": "Argentine Primera",
        # International
        "fifa.world": "World Cup",
        "uefa.euro": "Euros",
    },
    "football": {
        "nfl": "NFL",
    },
    "basketball": {
        "nba": "NBA",
        "wnba": "WNBA",
        "mens-college-basketball": "NCAA Basketball (M)",
        "womens-college-basketball": "NCAA Basketball (W)",
    },
    "hockey": {
        "nhl": "NHL",
    },
    "baseball": {
        "mlb": "MLB",
    },
    "racing": {
        "f1": "Formula 1",
    },
}

# Backward compatibility
FOOTBALL_LEAGUES = LEAGUES["soccer"]

def api_request(endpoint: str) -> dict:
    """Make request to ESPN API (no auth needed!)."""
    import re
    # Validate endpoint contains only safe characters (alphanumeric, slashes, dots, hyphens, query params)
    if not re.match(r'^[a-zA-Z0-9/_.\-?&=]+$', endpoint):
        raise ValueError(f"Invalid endpoint: {endpoint}")
    url = f"{BASE_URL}/{endpoint}"
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
    return json.loads(urllib.request.urlopen(req, timeout=15).read())

def get_scoreboard(sport: str = "soccer", league: str = "eng.1") -> dict:
    """Get current scoreboard for a league."""
    return api_request(f"{sport}/{league}/scoreboard")

def get_match_details(event_id: str, sport: str = "soccer", league: str = "eng.1") -> dict:
    """Get detailed match info including events."""
    return api_request(f"{sport}/{league}/summary?event={event_id}")

def get_all_teams(league: str = "eng.1", sport: str = "soccer") -> list:
    """Get ALL teams in a league (not just today's matches)."""
    sport_url = SPORT_MAPPING.get(sport, sport)
    data = api_request(f"{sport_url}/{league}/teams")
    teams = data.get("sports", [{}])[0].get("leagues", [{}])[0].get("teams", [])
    return [t.get("team", {}) for t in teams]

def search_team(team_name: str, sport: str = "soccer", leagues: list = None) -> list:
    """Search for a team across leagues using the teams endpoint."""
    if leagues is None:
        # Default leagues based on sport
        if sport == "soccer":
            leagues = ["eng.1", "esp.1", "ger.1", "ita.1", "fra.1", "uefa.champions"]
        elif sport == "football":
            leagues = ["nfl"]
        elif sport == "basketball":
            leagues = ["nba"]
        elif sport == "hockey":
            leagues = ["nhl"]
        elif sport == "baseball":
            leagues = ["mlb"]
        elif sport == "racing":
            leagues = ["f1"]
        else:
            leagues = []
    
    team_lower = team_name.lower()
    results = []
    sport_leagues = LEAGUES.get(sport, {})
    
    for league in leagues:
        try:
            teams = get_all_teams(league, sport)
            for team in teams:
                if team_lower in team.get("displayName", "").lower() or \
                   team_lower in team.get("shortDisplayName", "").lower() or \
                   team_lower in team.get("nickname", "").lower():
                    results.append({
                        "id": team.get("id"),
                        "name": team.get("displayName"),
                        "short": team.get("shortDisplayName"),
                        "sport": sport,
                        "league": league,
                        "league_name": sport_leagues.get(league, league)
                    })
        except Exception:
            continue
    
    return results

def find_team_match(team_id: str, leagues: list = None, sport: str = "soccer", today_only: bool = True) -> Optional[dict]:
    """Find a match for a specific team.
    
    If today_only=True (default), only returns matches scheduled for today (UTC).
    """
    from datetime import datetime, timezone
    if leagues is None:
        leagues = ["eng.1", "uefa.champions"]
    
    today_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
    
    for league in leagues:
        try:
            data = get_scoreboard(sport, league)
            for event in data.get("events", []):
                # Check date if today_only
                if today_only:
                    event_date = event.get("date", "")[:10]  # "2026-03-10T..."[:10] = "2026-03-10"
                    if event_date != today_str:
                        continue
                for comp in event.get("competitions", []):
                    for competitor in comp.get("competitors", []):
                        if str(competitor.get("team", {}).get("id")) == str(team_id):
                            return {
                                "event": event,
                                "league": league,
                                "event_id": event.get("id"),
                                "sport": sport
                            }
        except Exception:
            continue
    
    return None

def get_match_events(event_id: str, sport: str = "soccer", league: str = "eng.1") -> list:
    """Get key events (goals, cards) from a match."""
    details = get_match_details(event_id, sport, league)
    return details.get("keyEvents", [])

def format_event(event: dict, sport: str = "soccer") -> str:
    """Format a match/game event for display."""
    event_type = event.get("type", {}).get("text", "")
    clock = event.get("clock", {}).get("displayValue", "?'")
    team = event.get("team", {}).get("displayName", "")
    
    participants = event.get("participants", [])
    player = participants[0].get("athlete", {}).get("displayName", "") if participants else ""
    
    # Soccer events
    if sport == "soccer":
        if "Goal" in event_type:
            detail = ""
            if "Own Goal" in event_type:
                detail = " (OG)"
            elif "Penalty" in event_type:
                detail = " (pen)"
            return f"⚽ {clock} {player}{detail} ({team})"
        elif "Yellow" in event_type:
            return f"🟨 {clock} {player} ({team})"
        elif "Red" in event_type:
            return f"🟥 {clock} {player} ({team})"
        elif "Substitution" in event_type:
            return f"🔄 {clock} {player} ({team})"
    
    # American Football events
    elif sport == "football":
        if "Touchdown" in event_type:
            return f"🏈 {clock} TOUCHDOWN - {player} ({team})"
        elif "Field Goal" in event_type:
            return f"🎯 {clock} Field Goal - {player} ({team})"
        elif "Interception" in event_type:
            return f"🔒 {clock} INT - {player} ({team})"
    
    # Basketball events
    elif sport == "basketball":
        if "Three Point" in event_type or "3PT" in event_type:
            return f"🎯 {clock} 3-pointer - {player} ({team})"
        elif "Dunk" in event_type:
            return f"💪 {clock} DUNK - {player} ({team})"
    
    # Hockey events
    elif sport == "hockey":
        if "Goal" in event_type:
            return f"🏒 {clock} GOAL - {player} ({team})"
        elif "Penalty" in event_type:
            return f"⏱️ {clock} Penalty - {player} ({team})"
    
    # Baseball events
    elif sport == "baseball":
        if "Home Run" in event_type or "HR" in event_type:
            return f"⚾ {clock} HOME RUN - {player} ({team})"
    
    return f"📋 {clock} {event_type}: {player}"

def format_match(event: dict, include_events: bool = True, sport: str = "soccer", league: str = "eng.1") -> str:
    """Format a full match/game summary."""
    lines = []
    
    status = event.get("status", {})
    status_desc = status.get("type", {}).get("description", "Unknown")
    clock = status.get("displayClock", "")
    
    # Status header (sport-specific terminology)
    if status_desc == "In Progress":
        lines.append(f"🔴 LIVE {clock}")
    elif status_desc == "Halftime":
        if sport in ["football", "basketball"]:
            lines.append("⏸️ HALFTIME")
        else:
            lines.append("⏸️ HALFTIME")
    elif "End of" in status_desc:  # Basketball/Hockey periods
        lines.append(f"⏸️ {status_desc}")
    elif status_desc == "Final":
        if sport == "soccer":
            lines.append("🏁 FULL TIME")
        else:
            lines.append("🏁 FINAL")
    else:
        lines.append(f"📅 {status_desc}")
    
    # Teams and score
    competitions = event.get("competitions", [{}])[0]
    competitors = competitions.get("competitors", [])
    
    home = away = ""
    home_score = away_score = "0"
    
    for c in competitors:
        team_name = c.get("team", {}).get("displayName", "?")
        score = c.get("score", "0")
        if c.get("homeAway") == "home":
            home, home_score = team_name, score
        else:
            away, away_score = team_name, score
    
    lines.append(f"**{home} {home_score} - {away_score} {away}**")
    
    # Events
    if include_events:
        event_id = event.get("id")
        if event_id:
            try:
                events = get_match_events(event_id, sport, league)
                if events:
                    lines.append("")
                    for e in events[-8:]:
                        lines.append(format_event(e, sport))
            except Exception:
                pass
    
    return "\n".join(lines)

def get_fixtures_for_date(date_str: str, sport: str = "soccer", league: str = "eng.1") -> list:
    """Get fixtures for a specific date (YYYYMMDD format).
    
    Returns list of events for that date.
    """
    try:
        data = api_request(f"{sport}/{league}/scoreboard?dates={date_str}")
        return data.get("events", [])
    except Exception:
        return []

def get_team_fixtures(team_id: str, days: int = 30, sport: str = "soccer", 
                      leagues: list = None) -> list:
    """Get upcoming fixtures for a team across leagues.
    
    Args:
        team_id: ESPN team ID
        days: Number of days to look ahead (default 30)
        sport: Sport type
        leagues: List of leagues to check (defaults based on sport)
    
    Returns:
        List of fixture dicts with date, opponent, competition, venue, event_id
    """
    from datetime import datetime, timedelta, timezone
    
    if leagues is None:
        if sport == "soccer":
            leagues = ["eng.1", "esp.1", "ger.1", "ita.1", "fra.1", 
                      "uefa.champions", "uefa.europa"]
        elif sport == "football":
            leagues = ["nfl"]
        elif sport == "basketball":
            leagues = ["nba"]
        elif sport == "hockey":
            leagues = ["nhl"]
        elif sport == "baseball":
            leagues = ["mlb"]
        elif sport == "racing":
            leagues = ["f1"]
        else:
            leagues = []
    
    fixtures = []
    team_id_str = str(team_id)
    now = datetime.now(timezone.utc)
    
    # Check each day for the next N days
    checked_dates = set()
    for day_offset in range(days + 1):  # Include today
        date = now + timedelta(days=day_offset)
        date_str = date.strftime("%Y%m%d")
        
        for league in leagues:
            cache_key = f"{date_str}_{league}"
            if cache_key in checked_dates:
                continue
            checked_dates.add(cache_key)
            
            events = get_fixtures_for_date(date_str, sport, league)
            for event in events:
                # Check if this team is in the match
                for comp in event.get("competitions", []):
                    competitors = comp.get("competitors", [])
                    team_in_match = False
                    home_team = away_team = None
                    
                    for c in competitors:
                        team = c.get("team", {})
                        if c.get("homeAway") == "home":
                            home_team = team
                        else:
                            away_team = team
                        if str(team.get("id")) == team_id_str:
                            team_in_match = True
                    
                    if team_in_match and home_team and away_team:
                        # Determine opponent
                        if str(home_team.get("id")) == team_id_str:
                            opponent = away_team
                            is_home = True
                        else:
                            opponent = home_team
                            is_home = False
                        
                        sport_leagues = LEAGUES.get(sport, {})
                        fixtures.append({
                            "event_id": event.get("id"),
                            "date": event.get("date"),
                            "date_str": event.get("date", "")[:10],
                            "opponent": opponent.get("displayName"),
                            "opponent_short": opponent.get("shortDisplayName", opponent.get("displayName")),
                            "opponent_id": opponent.get("id"),
                            "is_home": is_home,
                            "competition": sport_leagues.get(league, league),
                            "league": league,
                            "venue": comp.get("venue", {}).get("fullName", "TBD"),
                            "sport": sport,
                            "status": event.get("status", {}).get("type", {}).get("name", "scheduled")
                        })
    
    # Sort by date and remove duplicates (same event in multiple leagues)
    seen_ids = set()
    unique_fixtures = []
    for f in sorted(fixtures, key=lambda x: x["date"]):
        if f["event_id"] not in seen_ids:
            seen_ids.add(f["event_id"])
            unique_fixtures.append(f)
    
    return unique_fixtures

def format_fixture(fixture: dict, include_venue: bool = True) -> str:
    """Format a fixture for display."""
    from datetime import datetime, timezone
    
    date_str = fixture.get("date", "")
    opponent = fixture.get("opponent_short", fixture.get("opponent", "?"))
    comp = fixture.get("competition", "")
    is_home = fixture.get("is_home", True)
    venue = fixture.get("venue", "")
    
    # Parse date
    try:
        dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
        date_fmt = dt.strftime("%a %d %b")
        time_fmt = dt.strftime("%H:%M")
    except:
        date_fmt = date_str[:10]
        time_fmt = "TBD"
    
    # Home/Away indicator
    location = "vs" if is_home else "@"
    
    result = f"📅 {date_fmt} {time_fmt} UTC | {location} {opponent} ({comp})"
    if include_venue and venue:
        result += f"\n   📍 {venue}"
    
    return result

def list_leagues(sport: str = None):
    """List available leagues by sport."""
    if sport:
        if sport in LEAGUES:
            print(f"Available {sport.title()} Leagues:\n")
            for code, name in sorted(LEAGUES[sport].items(), key=lambda x: x[1]):
                print(f"  {code:20} {name}")
        else:
            print(f"Sport '{sport}' not found. Available: {', '.join(LEAGUES.keys())}")
    else:
        print("Available Leagues by Sport:\n")
        for sport_name, leagues in LEAGUES.items():
            print(f"\n{sport_name.upper()}:")
            for code, name in sorted(leagues.items(), key=lambda x: x[1]):
                print(f"  {code:20} {name}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("ESPN Sports API - Free live data!")
        print("\nUsage:")
        print("  espn.py leagues [sport]           - List available leagues")
        print("  espn.py scoreboard [league] [sport] - Get scoreboard (default: eng.1 soccer)")
        print("  espn.py search <team> [sport]     - Search for a team (default: soccer)")
        print("  espn.py match <event_id> [league] [sport] - Get match details")
        print("\nSupported sports: soccer, football, basketball, hockey, baseball, racing")
        sys.exit(0)
    
    cmd = sys.argv[1]
    
    if cmd == "leagues":
        sport = sys.argv[2] if len(sys.argv) > 2 else None
        list_leagues(sport)
    
    elif cmd == "scoreboard":
        league = sys.argv[2] if len(sys.argv) > 2 else "eng.1"
        sport = sys.argv[3] if len(sys.argv) > 3 else "soccer"
        data = get_scoreboard(sport, league)
        sport_leagues = LEAGUES.get(sport, {})
        print(f"=== {sport_leagues.get(league, league)} ===\n")
        for event in data.get("events", []):
            print(format_match(event, include_events=False, sport=sport, league=league))
            print()
    
    elif cmd == "search":
        if len(sys.argv) < 3:
            print("Usage: espn.py search <team_name> [sport]")
            sys.exit(1)
        # Find where sport might be (last arg if it's a known sport)
        args = sys.argv[2:]
        sport = "soccer"
        if args and args[-1] in SPORT_MAPPING:
            sport = args[-1]
            team = " ".join(args[:-1])
        else:
            team = " ".join(args)
        
        results = search_team(team, sport)
        if results:
            print(f"Found teams matching '{team}' in {sport}:\n")
            for r in results:
                print(f"  ID: {r['id']:6} | {r['name']:30} | {r['league_name']}")
        else:
            print(f"No teams found matching '{team}' in {sport}")
    
    elif cmd == "match":
        if len(sys.argv) < 3:
            print("Usage: espn.py match <event_id> [league] [sport]")
            sys.exit(1)
        event_id = sys.argv[2]
        league = sys.argv[3] if len(sys.argv) > 3 else "eng.1"
        sport = sys.argv[4] if len(sys.argv) > 4 else "soccer"
        details = get_match_details(event_id, sport, league)
        event = details.get("header", {}).get("competitions", [{}])[0]
        # Reconstruct event format
        print(f"Match details for event {event_id}")

#!/usr/bin/env python3
"""
Live Match Monitor - Checks for live matches and outputs alerts.

Uses ESPN API for real-time events including:
- ⚽ Goals with scorer names
- 🟥 Red cards
- ⏸️ Halftime
- 🏁 Full-time results

Run via cron during match windows. Only outputs when there are new events.
"""

import json
import sys
import os
import urllib.request
import urllib.parse
from datetime import datetime, timezone
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
from espn import find_team_match, get_match_events, FOOTBALL_LEAGUES
from config import get_teams, get_alert_settings
from cache import write_to_cache, read_from_cache, format_cached_result

STATE_FILE = Path(__file__).parent.parent / ".live_state.json"


def _web_search_live(team_name: str, team_key: str) -> list:
    """Search for live score info for a team without ESPN ID.
    
    Returns a list of alert strings (may be empty if nothing found or no API key).
    Writes result to score cache when something is found.
    """
    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
    queries = [
        f"{team_name} live score today",
        f"{team_name} Ergebnis heute live",
    ]

    def _try_brave(query: str) -> str:
        brave_key = os.environ.get("BRAVE_SEARCH_API_KEY", "")
        if not brave_key:
            return ""
        try:
            params = urllib.parse.urlencode({"q": query, "count": 3})
            req = urllib.request.Request(
                f"https://api.search.brave.com/res/v1/web/search?{params}",
                headers={"Accept": "application/json", "X-Subscription-Token": brave_key},
            )
            data = json.loads(urllib.request.urlopen(req, timeout=10).read())
            snippets = []
            for r in data.get("web", {}).get("results", [])[:3]:
                snippet = r.get("description", "")
                title = r.get("title", "")
                if snippet:
                    snippets.append(f"{title}: {snippet[:120]}")
            return "\n".join(snippets)
        except Exception:
            return ""

    def _try_serper(query: str) -> str:
        # Load key from env or web-search-plus .env
        serper_key = os.environ.get("SERPER_API_KEY", "")
        if not serper_key:
            env_paths = [
                Path(__file__).parent.parent.parent / "web-search-plus" / ".env",
                Path(os.environ.get("HOME", "/root")) / "clawd/skills/web-search-plus/.env",
            ]
            for ep in env_paths:
                if ep.exists():
                    for line in ep.read_text().splitlines():
                        if "SERPER_API_KEY" in line and "=" in line:
                            serper_key = line.split("=", 1)[-1].strip().strip("'\"")
                            break
        if not serper_key:
            return ""
        try:
            import json as _json
            payload = _json.dumps({"q": query, "num": 3}).encode()
            req = urllib.request.Request(
                "https://google.serper.dev/search",
                data=payload,
                headers={"X-API-KEY": serper_key, "Content-Type": "application/json"},
            )
            data = _json.loads(urllib.request.urlopen(req, timeout=10).read())
            snippets = []
            for r in data.get("organic", [])[:3]:
                snippet = r.get("snippet", "")
                title = r.get("title", "")
                if snippet:
                    snippets.append(f"{title}: {snippet[:120]}")
            return "\n".join(snippets)
        except Exception:
            return ""

    alerts = []
    for query in queries:
        result = _try_brave(query) or _try_serper(query)
        if result:
            # Check if result changed from cache
            cached = read_from_cache(team_key)
            cached_result = cached.get("last_result", "") if cached else ""
            if result != cached_result:
                write_to_cache(team_key, result, source="web_search")
                alerts.append(f"🔍 **{team_name}** (web)\n{result}")
            break  # Found something — stop trying queries

    return alerts

def load_state() -> dict:
    if STATE_FILE.exists():
        return json.loads(STATE_FILE.read_text())
    return {}

def save_state(state: dict):
    STATE_FILE.write_text(json.dumps(state, indent=2))

def check_team(team: dict, state: dict, alerts_config: dict) -> tuple[list, dict]:
    """Check a single team for updates. Returns (alerts, updated_state)."""
    alerts = []
    team_name = team.get("name", "Unknown")
    team_emoji = team.get("emoji", "⚽")
    espn_id = team.get("espn_id")
    sport = team.get("sport", "soccer")  # Default to soccer for backward compatibility
    
    if not espn_id:
        # No ESPN ID — fall back to web search for live score
        team_key = team.get("short_name", team_name)
        web_alerts = _web_search_live(team_name, team_key)
        return web_alerts, state
    
    leagues = team.get("espn_leagues", ["eng.1", "uefa.champions"])
    match = find_team_match(espn_id, leagues, sport)
    
    if not match:
        return [], state
    
    event = match["event"]
    event_id = str(match["event_id"])
    league = match["league"]
    
    status = event.get("status", {}).get("type", {}).get("description", "")
    
    # Get scores
    competitions = event.get("competitions", [{}])[0]
    competitors = competitions.get("competitors", [])
    
    home_team = away_team = ""
    home_score = away_score = 0
    is_home = False
    
    for c in competitors:
        t_name = c.get("team", {}).get("displayName", "?")
        t_id = str(c.get("team", {}).get("id", ""))
        # Safely parse score - ESPN returns string, empty string, or int
        raw_score = c.get("score", 0)
        try:
            score = int(raw_score) if raw_score not in (None, "", "-") else 0
        except (ValueError, TypeError):
            score = 0
        
        if c.get("homeAway") == "home":
            home_team, home_score = t_name, score
            if t_id == espn_id:
                is_home = True
        else:
            away_team, away_score = t_name, score
    
    # Previous state for this match
    prev = state.get(event_id, {})
    prev_status = prev.get("status", "")
    prev_events = set(prev.get("event_ids", []))
    
    # Kick-off / Game start
    if alerts_config.get("kickoff", True):
        # Check if game is live (covers "In Progress", "First Half", "Second Half", etc.)
        is_live = status in ("In Progress", "First Half", "Second Half", "1st Quarter", "2nd Quarter", 
                            "3rd Quarter", "4th Quarter", "1st Period", "2nd Period", "3rd Period")
        was_live = prev_status in ("In Progress", "First Half", "Second Half", "1st Quarter", "2nd Quarter",
                                   "3rd Quarter", "4th Quarter", "1st Period", "2nd Period", "3rd Period")
        
        if is_live and not was_live and prev_status != "Halftime":
            from espn import LEAGUES
            sport_leagues = LEAGUES.get(sport, {})
            opponent = away_team if is_home else home_team
            start_emoji = "🏟️" if sport == "soccer" else "🎮"
            start_text = "KICK OFF!" if sport == "soccer" else "GAME ON!"
            alerts.append(f"{start_emoji} **{start_text}** {team_emoji}\n{home_team} vs {away_team}\n{sport_leagues.get(league, league)}")
    
    # Get detailed events
    try:
        key_events = get_match_events(event_id, sport, league)
    except:
        key_events = []
    
    current_event_ids = []
    
    for e in key_events:
        e_id = str(e.get("id", e.get("clock", {}).get("value", "")))
        current_event_ids.append(e_id)
        
        if e_id in prev_events:
            continue  # Already seen
        
        event_type = e.get("type", {}).get("text", "")
        clock = e.get("clock", {}).get("displayValue", "?'")
        e_team = e.get("team", {}).get("displayName", "")
        
        participants = e.get("participants", [])
        player = participants[0].get("athlete", {}).get("displayName", "Unknown") if participants else "Unknown"
        
        is_our_team = team_name.lower() in e_team.lower()
        
        # Scoring events (sport-specific)
        if alerts_config.get("goals", True):
            scored = False
            score_line = f"{home_team} {home_score}-{away_score} {away_team}"
            emoji = "🎉" if is_our_team else "😬"
            
            if sport == "soccer":
                if "Goal" in event_type:
                    scored = True
                    if "Own Goal" in event_type:
                        alerts.append(f"{emoji} **OWN GOAL!** {clock}\n⚽ {player} ({e_team})\n**{score_line}**")
                    elif "Penalty" in event_type:
                        alerts.append(f"{emoji} **PENALTY!** {clock}\n⚽ {player} ({e_team})\n**{score_line}**")
                    else:
                        alerts.append(f"{emoji} **GOAL!** {clock}\n⚽ {player} ({e_team})\n**{score_line}**")
            
            elif sport == "football":
                if "Touchdown" in event_type:
                    scored = True
                    alerts.append(f"{emoji} **TOUCHDOWN!** {clock}\n🏈 {player} ({e_team})\n**{score_line}**")
                elif "Field Goal" in event_type:
                    scored = True
                    alerts.append(f"{emoji} **FIELD GOAL!** {clock}\n🎯 {player} ({e_team})\n**{score_line}**")
            
            elif sport == "basketball":
                if "Three Point" in event_type or "3PT" in event_type:
                    scored = True
                    alerts.append(f"{emoji} **3-POINTER!** {clock}\n🎯 {player} ({e_team})\n**{score_line}**")
            
            elif sport == "hockey":
                if "Goal" in event_type:
                    scored = True
                    alerts.append(f"{emoji} **GOAL!** {clock}\n🏒 {player} ({e_team})\n**{score_line}**")
            
            elif sport == "baseball":
                if "Home Run" in event_type or "HR" in event_type:
                    scored = True
                    alerts.append(f"{emoji} **HOME RUN!** {clock}\n⚾ {player} ({e_team})\n**{score_line}**")
        
        # Red cards / Ejections (mainly for soccer and hockey)
        if alerts_config.get("red_cards", True):
            if sport == "soccer" and "Red" in event_type:
                emoji = "😱" if is_our_team else "😈"
                alerts.append(f"{emoji} 🟥 **RED CARD!** {clock}\n{player} ({e_team})")
            elif sport == "hockey" and "Major Penalty" in event_type:
                emoji = "😱" if is_our_team else "😈"
                alerts.append(f"{emoji} **MAJOR PENALTY!** {clock}\n{player} ({e_team})")
    
    # Halftime / Period breaks
    if alerts_config.get("halftime", True):
        if status == "Halftime" and prev_status != "Halftime":
            alerts.append(f"⏸️ **HALFTIME** {team_emoji}\n{home_team} {home_score}-{away_score} {away_team}")
        elif "End of" in status and "End of" not in prev_status:
            # Basketball/Hockey period breaks
            alerts.append(f"⏸️ **{status.upper()}** {team_emoji}\n{home_team} {home_score}-{away_score} {away_team}")
    
    # Full time / Final
    if alerts_config.get("fulltime", True):
        if status == "Final" and prev_status not in ("Final", ""):
            our_goals = home_score if is_home else away_score
            their_goals = away_score if is_home else home_score
            
            if our_goals > their_goals:
                result_emoji = "🎉✅"
                result = "WIN!"
            elif our_goals < their_goals:
                result_emoji = "😢❌"
                result = "LOSS"
            else:
                result_emoji = "🤝"
                result = "DRAW"
            
            final_text = "FULL TIME" if sport == "soccer" else "FINAL"
            score_str = f"{home_team} {home_score}-{away_score} {away_team}"
            alerts.append(f"🏁 **{final_text} - {result}** {result_emoji} {team_emoji}\n{score_str}")
            # Persist the final score to cache so ticker.py can show it later
            team_key = team.get("short_name", team_name)
            write_to_cache(team_key, score_str, source="espn")
    
    # Update state
    state[event_id] = {
        "status": status,
        "home_score": home_score,
        "away_score": away_score,
        "event_ids": current_event_ids
    }
    
    return alerts, state

def check_all_teams() -> list:
    """Check all configured teams for updates."""
    all_alerts = []
    state = load_state()
    teams = get_teams()
    alerts_config = get_alert_settings()
    
    for team in teams:
        alerts, state = check_team(team, state, alerts_config)
        all_alerts.extend(alerts)
    
    save_state(state)
    return all_alerts

if __name__ == "__main__":
    alerts = check_all_teams()
    
    if alerts:
        for alert in alerts:
            print(alert)
            print("---")
    elif "--verbose" in sys.argv:
        print("No live updates.")

#!/usr/bin/env python3
"""
Schedule - Show upcoming fixtures for configured teams.

Usage:
    schedule.py                     # All teams, next 14 days
    schedule.py --days 30           # All teams, next 30 days  
    schedule.py --team spurs        # Specific team
    schedule.py --team spurs --days 7 --json   # JSON output
"""

import sys
import json
import argparse
from pathlib import Path
from datetime import datetime, timezone

sys.path.insert(0, str(Path(__file__).parent))
from espn import get_team_fixtures, format_fixture, LEAGUES
from config import get_teams, get_team_by_name


def get_team_schedule(team: dict, days: int = 14) -> list:
    """Get schedule for a single team."""
    espn_id = team.get("espn_id")
    if not espn_id:
        return []
    
    leagues = team.get("espn_leagues", ["eng.1"])
    sport = team.get("sport", "soccer")
    
    return get_team_fixtures(espn_id, days=days, sport=sport, leagues=leagues)


def format_team_schedule(team: dict, fixtures: list, compact: bool = False) -> str:
    """Format schedule output for a team."""
    name = team.get("name", "Unknown")
    emoji = team.get("emoji", "⚽")
    
    lines = [f"{emoji} **{name}** - Upcoming Fixtures\n"]
    
    if not fixtures:
        lines.append("No fixtures found in the next period.")
    else:
        for f in fixtures:
            if compact:
                # Compact one-liner
                date_str = f.get("date", "")
                try:
                    dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
                    date_fmt = dt.strftime("%d/%m %H:%M")
                except:
                    date_fmt = date_str[:10]
                
                loc = "vs" if f.get("is_home") else "@"
                opp = f.get("opponent_short", f.get("opponent", "?"))
                comp = f.get("competition", "")
                lines.append(f"  {date_fmt} {loc} {opp} ({comp})")
            else:
                lines.append(format_fixture(f, include_venue=True))
                lines.append("")
    
    return "\n".join(lines)


def all_teams_schedule(days: int = 14, compact: bool = False) -> str:
    """Get schedule for all configured teams."""
    teams = get_teams()
    
    if not teams:
        return "No teams configured. Run setup.py first!"
    
    parts = []
    for team in teams:
        if team.get("espn_id"):
            fixtures = get_team_schedule(team, days)
            parts.append(format_team_schedule(team, fixtures, compact))
    
    if not parts:
        return "No teams with ESPN IDs configured."
    
    return ("\n" + "─" * 40 + "\n").join(parts)


def get_all_fixtures_json(days: int = 14, team_name: str = None) -> list:
    """Get all fixtures as JSON-serializable list."""
    teams = get_teams()
    all_fixtures = []
    
    for team in teams:
        if not team.get("espn_id"):
            continue
        
        # Filter by team name if specified
        if team_name:
            name_lower = team_name.lower()
            if name_lower not in team.get("name", "").lower() and \
               name_lower not in team.get("short_name", "").lower():
                continue
        
        fixtures = get_team_schedule(team, days)
        for f in fixtures:
            f["team_name"] = team.get("name")
            f["team_short"] = team.get("short_name")
            f["team_emoji"] = team.get("emoji", "⚽")
            f["team_espn_id"] = team.get("espn_id")
            all_fixtures.append(f)
    
    # Sort all fixtures by date
    all_fixtures.sort(key=lambda x: x.get("date", ""))
    
    return all_fixtures


def main():
    parser = argparse.ArgumentParser(description="Show upcoming fixtures for your teams")
    parser.add_argument("--days", "-d", type=int, default=14, 
                       help="Number of days to look ahead (default: 14)")
    parser.add_argument("--team", "-t", type=str,
                       help="Filter by team name")
    parser.add_argument("--compact", "-c", action="store_true",
                       help="Compact output (one line per fixture)")
    parser.add_argument("--json", "-j", action="store_true",
                       help="Output as JSON")
    
    args = parser.parse_args()
    
    if args.json:
        fixtures = get_all_fixtures_json(days=args.days, team_name=args.team)
        print(json.dumps(fixtures, indent=2))
    elif args.team:
        team = get_team_by_name(args.team)
        if team:
            fixtures = get_team_schedule(team, days=args.days)
            print(format_team_schedule(team, fixtures, compact=args.compact))
        else:
            print(f"Team '{args.team}' not found in config.")
            sys.exit(1)
    else:
        print(all_teams_schedule(days=args.days, compact=args.compact))


if __name__ == "__main__":
    main()