import json
import sys
import pandas as pd
from nba_api.stats.endpoints import playergamelog, leaguegamefinder
from nba_api.stats.static import players

def get_season_data_maps(season: str, season_type: str):
    """Récupère tous les scores et les logos des équipes pour un type de saison en un seul appel."""
    try:
        finder = leaguegamefinder.LeagueGameFinder(
            season_nullable=season,
            season_type_nullable=season_type
        )
        df = finder.get_data_frames()[0]
        if df.empty:
            return {}, {}
        
        # Normalisation des colonnes en majuscules
        df.columns = [str(c).upper() for c in df.columns]
        
        score_map = {}
        logos_map = {}
        
        if 'GAME_ID' in df.columns and 'PTS' in df.columns and 'TEAM_ID' in df.columns:
            team_col = None
            for col in ['TEAM_ABBREVIATION', 'TEAM_ABBREV', 'TEAM_NAME']:
                if col in df.columns:
                    team_col = col
                    break
            
            if team_col:
                for game_id, group in df.groupby('GAME_ID'):
                    if len(group) >= 2:
                        row1 = group.iloc[0]
                        row2 = group.iloc[1]
                        
                        t1_id = int(row1['TEAM_ID'])
                        t2_id = int(row2['TEAM_ID'])
                        t1_pts = int(row1['PTS'])
                        t2_pts = int(row2['PTS'])
                        t1_abbr = row1[team_col]
                        t2_abbr = row2[team_col]
                        
                        # Format du score
                        score_map[game_id] = f"{t1_abbr} {t1_pts} - {t2_pts} {t2_abbr}"
                        
                        # URLs des logos officiels NBA
                        logos_map[game_id] = {
                            "team_home_or_first": {
                                "abbreviation": t1_abbr,
                                "score": t1_pts,
                                "logo_url": f"https://cdn.nba.com/logos/nba/{t1_id}/global/L/logo.svg"
                            },
                            "team_away_or_second": {
                                "abbreviation": t2_abbr,
                                "score": t2_pts,
                                "logo_url": f"https://cdn.nba.com/logos/nba/{t2_id}/global/L/logo.svg"
                            }
                        }
        return score_map, logos_map
    except Exception:
        return {}, {}

def get_player_logs(player_name: str, season: str = "2025-26"):
    nba_players = players.get_players()
    matching_players = [
        p for p in nba_players
        if p["full_name"].lower() == player_name.strip().lower()
    ]

    if not matching_players:
        return {"error": f"Joueur '{player_name}' introuvable."}

    player_id = matching_players[0]["id"]
    found_name = matching_players[0]["full_name"]

    dfs = []
    global_scores = {}
    global_logos = {}

    for season_type in ["Regular Season", "Playoffs"]:
        try:
            gamelog = playergamelog.PlayerGameLog(
                player_id=player_id, 
                season=season, 
                season_type_all_star=season_type
            )
            df = gamelog.get_data_frames()[0]
            if not df.empty:
                df["SEASON_TYPE"] = season_type
                dfs.append(df)
                
                scores, logos = get_season_data_maps(season, season_type)
                global_scores.update(scores)
                global_logos.update(logos)
        except Exception:
            pass

    if not dfs:
        return {"error": f"Aucun match trouvé pour {found_name} pour la saison {season}."}

    df_combined = pd.concat(dfs, ignore_index=True)
    df_combined.columns = [str(c).upper() for c in df_combined.columns]
    game_id_col = 'GAME_ID' if 'GAME_ID' in df_combined.columns else 'Game_ID'

    # Association des scores et des logos
    if game_id_col in df_combined.columns:
        df_combined["SCORE"] = df_combined[game_id_col].map(global_scores).fillna("N/A")
        df_combined["TEAMS_INFO"] = df_combined[game_id_col].map(global_logos).fillna({})
    else:
        df_combined["SCORE"] = "N/A"
        df_combined["TEAMS_INFO"] = {}

    display_cols = [
        "GAME_DATE",
        "MATCHUP",
        "WL",
        "SCORE",
        "TEAMS_INFO",
        "MIN",
        "PTS",
        "REB",
        "AST",
        "STL",
        "BLK",
	"FGA",
	"FGM",
	"FG3A",
	"FG3M",
        "FG_PCT",
        "FG3_PCT",
        "SEASON_TYPE"
    ]
    
    df_filtered = df_combined[[c for c in display_cols if c in df_combined.columns]].copy()
    df_filtered.insert(0, "PLAYER_NAME", found_name)

    date_col = 'GAME_DATE' if 'GAME_DATE' in df_filtered.columns else 'Game_Date'
    if date_col in df_filtered.columns:
        df_filtered[date_col] = pd.to_datetime(df_filtered[date_col])
        df_filtered = df_filtered.sort_values(by=date_col, ascending=False)
        df_filtered[date_col] = df_filtered[date_col].dt.strftime('%Y-%m-%d')

    return df_filtered.to_dict(orient="records")

if __name__ == "__main__":
    player_input = sys.argv[1] if len(sys.argv) > 1 else "Stephen Curry"
    season_input = sys.argv[2] if len(sys.argv) > 2 else "2025-26"
    
    results = get_player_logs(player_input, season_input)
    print(json.dumps(results))