from flask import Flask, render_template, jsonify, request, session, redirect, url_for, send_file, make_response
from datetime import datetime, timedelta
import os
import sys
import traceback
from services.sleeper_api import SleeperAPI
from services.espn_api import ESPNAPI
from config import Config
from faker import Faker

# Force unbuffered output for Docker logs
os.environ['PYTHONUNBUFFERED'] = '1'

print("=== RosterHash Starting ===", flush=True)
print(f"=== Version: {Config.VERSION} ===", flush=True)

app = Flask(__name__)
app.config.from_object(Config)

# Initialize API services
sleeper_api = SleeperAPI()
espn_api = ESPNAPI()

# Simple memory cache for API responses
api_cache = {}
CACHE_DURATION = 300  # 5 minutes in seconds

# Debug time override
debug_time_override = None

def get_debug_time():
    """Get the current time, or debug override time if set"""
    global debug_time_override
    if debug_time_override:
        return debug_time_override
    return datetime.now()

def get_cached_or_fetch(cache_key, fetch_function, *args):
    """Get data from cache or fetch it and cache the result"""
    now = get_debug_time()
    
    if cache_key in api_cache:
        cached_data, cached_time = api_cache[cache_key]
        if (now - cached_time).total_seconds() < CACHE_DURATION:
            print(f"DEBUG: Using cached data for {cache_key}", flush=True)
            return cached_data
    
    print(f"DEBUG: Fetching fresh data for {cache_key}", flush=True)
    try:
        data = fetch_function(*args)
        api_cache[cache_key] = (data, now)
        return data
    except Exception as e:
        print(f"ERROR: Failed to fetch {cache_key}: {str(e)}", flush=True)
        # Return cached data if available, even if stale
        if cache_key in api_cache:
            cached_data, _ = api_cache[cache_key]
            print(f"DEBUG: Using stale cached data for {cache_key}", flush=True)
            return cached_data
        raise

def get_league_color(league_index):
    """Assign colors to leagues in order"""
    colors = app.config['LEAGUE_COLORS']
    return colors[league_index % len(colors)]  # Cycle through colors

def normalize_team_abbreviation(espn_team):
    """Convert ESPN team abbreviation to Sleeper format"""
    team_map = app.config['TEAM_ABBREVIATION_MAP']
    return team_map.get(espn_team, espn_team)

@app.context_processor
def inject_apis():
    """Make API and version available to all templates"""
    global debug_time_override
    is_debug_mode = request.args.get('debug') == 'true'
    return dict(
        sleeper_api=sleeper_api, 
        app_version=app.config['VERSION'],
        current_theme=session.get('theme', 'dark'),
        is_debug_mode=is_debug_mode,
        debug_time_override=debug_time_override
    )

@app.route('/')
def index():
    """Home page with username input"""
    print("DEBUG: Index route accessed", flush=True)
    # Get the last used username from cookie
    last_username = request.cookies.get('last_username', '')
    mySleeperUsername = Faker().user_name()
    print(f"DEBUG: Last username from cookie: '{last_username}'", flush=True)
    
    # Auto-redirect to dashboard if username cookie exists
    if last_username and last_username.strip():
        print(f"DEBUG: Auto-redirecting to dashboard for user: '{last_username}'", flush=True)
        return redirect(url_for('dashboard_current', username=last_username.strip()))
    
    return render_template('index.html', last_username=last_username, mySleeperUsername=mySleeperUsername)

@app.route('/dashboard')
def dashboard_form():
    """Handle form submission from homepage"""
    username = request.args.get('username')
    if username:
        return dashboard_current(username.strip())
    else:
        return redirect(url_for('index'))

# Add theme handling route
@app.route('/toggle_theme', methods=['POST'])
def toggle_theme():
    """Toggle between light and dark theme"""
    current_theme = session.get('theme', 'dark')
    new_theme = 'dark' if current_theme == 'light' else 'light'
    session['theme'] = new_theme
    
    # Get return URL from form or default to index
    return_url = request.form.get('return_url', url_for('index'))
    return redirect(return_url)

# Add timezone handling route
@app.route('/set_timezone', methods=['POST'])
def set_timezone():
    """Set user's timezone preference"""
    timezone = request.form.get('timezone')
    if timezone:
        session['user_timezone'] = timezone
        print(f"DEBUG: Set user timezone to: {timezone}", flush=True)
    
    # Get return URL from form or default to index
    return_url = request.form.get('return_url', url_for('index'))
    return redirect(return_url)

# Add debug time override route
@app.route('/set_debug_time', methods=['POST'])
def set_debug_time():
    """Set debug time override (only in debug mode)"""
    global debug_time_override
    
    # Check if debug mode is enabled
    if not request.args.get('debug') == 'true':
        return jsonify({'error': 'Debug mode not enabled'}), 403
    
    debug_datetime_str = request.form.get('debug_time')
    if debug_datetime_str:
        try:
            # Parse the datetime string from the picker (format: YYYY-MM-DDTHH:MM)
            debug_time_override = datetime.strptime(debug_datetime_str, '%Y-%m-%dT%H:%M')
            print(f"DEBUG: Set debug time override to: {debug_time_override}", flush=True)
            # Clear cache when time changes to get fresh data
            api_cache.clear()
            print("DEBUG: Cleared API cache due to time override", flush=True)
        except ValueError as e:
            print(f"DEBUG: Invalid debug time format: {debug_datetime_str}, error: {e}", flush=True)
            return jsonify({'error': 'Invalid datetime format'}), 400
    else:
        # Clear the override
        debug_time_override = None
        api_cache.clear()
        print("DEBUG: Cleared debug time override", flush=True)
    
    # Get return URL from form or default to index
    return_url = request.form.get('return_url', url_for('index'))
    return redirect(return_url)

@app.route('/change-username')
def change_username():
    """Clear username cookie and redirect to index"""
    response = make_response(redirect(url_for('index')))
    response.set_cookie('last_username', '', expires=0)  # Clear the cookie
    return response

@app.route('/<username>')
def dashboard_current(username):
    """Dashboard for current NFL week"""
    print(f"DEBUG: Dashboard current route - username: '{username}'", flush=True)
    try:
        nfl_state = sleeper_api.get_nfl_state()
        current_week = nfl_state.get('week', 1)
        print(f"DEBUG: Current week: {current_week}", flush=True)
        response = make_response(dashboard(username, current_week))
        # Set cookie to remember this username (expires in 30 days)
        response.set_cookie('last_username', username, max_age=30*24*60*60)
        return response
    except Exception as e:
        print(f"ERROR: dashboard_current exception - {str(e)}", flush=True)
        print(f"ERROR: Full traceback: {traceback.format_exc()}", flush=True)
        return render_template('error.html', 
                             message=f"Could not find user '{username}'. Please check the username and try again.")

@app.route('/<username>/<int:week>')
def dashboard_week(username, week):
    """Dashboard for specific week"""
    print(f"DEBUG: Dashboard week - username: '{username}', week: {week}", flush=True)
    response = make_response(dashboard(username, week))
    # Set cookie to remember this username (expires in 30 days)
    response.set_cookie('last_username', username, max_age=30*24*60*60)
    return response

@app.route('/<username>/<int:week>/refresh', methods=['POST'])
def refresh_scores(username, week):
    """Server-side refresh scores - redirect back to dashboard"""
    print(f"DEBUG: Refresh scores POST - username: '{username}', week: {week}", flush=True)
    return redirect(url_for('dashboard_week', username=username, week=week))

def dashboard(username, week):
    """Main dashboard logic - fetch and display user's fantasy data"""
    print(f"DEBUG: Dashboard function START - username: '{username}', week: {week}", flush=True)
    try:
        # Get user info from Sleeper (cached)
        user_cache_key = f"user_{username}"
        user = get_cached_or_fetch(user_cache_key, sleeper_api.get_user, username)
        print(f"DEBUG: get_user() returned: {user}", flush=True)
        
        if not user:
            print(f"WARNING: User lookup failed for username: '{username}'", flush=True)
            return render_template('error.html', 
                                 message=f"Could not find user '{username}'. Please check the username and try again.")
        
        print(f"DEBUG: User found - ID: {user.get('user_id')}, Display: {user.get('display_name', 'Unknown')}", flush=True)
        
        # Get current NFL season (cached)
        nfl_cache_key = "nfl_state"
        nfl_state = get_cached_or_fetch(nfl_cache_key, sleeper_api.get_nfl_state)
        season = nfl_state.get('season', str(datetime.now().year))
        print(f"DEBUG: Using season: {season}", flush=True)
        
        # Get user's fantasy leagues (cached)
        user_id = user['user_id']
        leagues_cache_key = f"leagues_{user_id}_{season}"
        leagues = get_cached_or_fetch(leagues_cache_key, sleeper_api.get_user_leagues, user_id, season)
        print(f"DEBUG: Found {len(leagues) if leagues else 0} leagues", flush=True)
        
        if leagues:
            for i, league in enumerate(leagues):
                print(f"DEBUG: League {i+1}: ID={league.get('league_id')}, Name='{league.get('name')}'", flush=True)
        
        # Get NFL game schedule for the week with user's timezone
        user_timezone = session.get('user_timezone', 'America/Los_Angeles')  # Default to PST
        print(f"DEBUG: Using timezone: {user_timezone}", flush=True)
        print(f"DEBUG: Calling get_week_schedule() for week {week}, season {season}", flush=True)
        try:
            schedule = espn_api.get_week_schedule(week, season, user_timezone, debug_time_override)
            print(f"DEBUG: Schedule retrieved successfully", flush=True)
        except Exception as e:
            print(f"ERROR: ESPN schedule fetch failed: {str(e)}", flush=True)
            schedule = {}
        
        # Process each league for matchup data
        league_data = []
        for i, league in enumerate(leagues):
            print(f"DEBUG: ===== Processing league {i+1}/{len(leagues)}: '{league['name']}' =====", flush=True)
            league_id = league['league_id']
            
            try:
                # Get matchups for the current week
                print(f"DEBUG: Calling get_matchups() for league {league_id}, week {week}", flush=True)
                matchups = sleeper_api.get_matchups(league_id, week)
                print(f"DEBUG: Found {len(matchups) if matchups else 0} matchups", flush=True)
                
                
                # Get rosters to find user's team
                print(f"DEBUG: Calling get_rosters() for league {league_id}", flush=True)
                rosters = sleeper_api.get_rosters(league_id)
                print(f"DEBUG: Found {len(rosters) if rosters else 0} rosters", flush=True)
                
                # Find user's roster in this league
                user_roster = next((r for r in rosters if r['owner_id'] == user['user_id']), None)
                print(f"DEBUG: User roster found: {user_roster is not None}", flush=True)
                
                if user_roster:
                    # Find user's matchup for this week (if matchups exist)
                    user_matchup = None
                    if matchups:
                        user_matchup = next((m for m in matchups if m['roster_id'] == user_roster['roster_id']), None)
                    print(f"DEBUG: User matchup found: {user_matchup is not None}", flush=True)
                    
                    # Find opponent's matchup and user info
                    opponent_matchup = None
                    opponent_user = None
                    if user_matchup and matchups:
                        # Find opponent in same matchup
                        opponent_matchup = next((m for m in matchups if m['matchup_id'] == user_matchup['matchup_id'] and m['roster_id'] != user_roster['roster_id']), None)
                        print(f"DEBUG: Opponent matchup found: {opponent_matchup is not None}", flush=True)
                        
                        if opponent_matchup:
                            # Get opponent's roster to find owner
                            opponent_roster = next((r for r in rosters if r['roster_id'] == opponent_matchup['roster_id']), None)
                            if opponent_roster:
                                opponent_owner_id = opponent_roster['owner_id']
                                # Fetch opponent's user profile
                                opponent_user = sleeper_api.get_user_by_id(opponent_owner_id)
                                print(f"DEBUG: Opponent user: {opponent_user.get('display_name') if opponent_user else 'None'}", flush=True)
                    
                    # Get all players on user's roster for calendar with starter info
                    all_players = []
                    if user_roster and user_roster.get('players'):
                        players_list = user_roster['players']
                        starters_list = user_matchup.get('starters') if user_matchup else None
                        starters_list = starters_list or []  # Handle None case
                        players_points = user_matchup.get('players_points') if user_matchup else None
                        players_points = players_points or {}  # Handle None case
                        print(f"DEBUG: Processing {len(players_list)} total players, {len(starters_list)} starters", flush=True)
                        
                        for player_id in players_list:
                            try:
                                # Get player details from Sleeper API
                                player_info = sleeper_api.get_player_info(player_id)
                                if player_info:
                                    # Create a copy of the player object for this league to avoid shared references
                                    player = player_info.copy()
                                    
                                    # Add starter status to player data
                                    player['is_starter'] = player_id in starters_list
                                    
                                    # Add player points for this week (league-specific)
                                    player['points'] = players_points.get(player_id, 0.0)
                                    
                                    # Check multiple possible injury status fields
                                    injury_status = (
                                        player.get('injury_status') or 
                                        player.get('status') or 
                                        player.get('injury_designation') or 
                                        player.get('practice_participation')
                                    )
                                    
                                    # Only show injury status if it's not "Active" or None
                                    if injury_status and injury_status.lower() != 'active':
                                        player['injury_status'] = injury_status
                                    else:
                                        player['injury_status'] = None
                                    
                                    # Print any player with injury status (only non-Active)
                                    if player['injury_status']:
                                        player_name = f"{player.get('first_name', '')} {player.get('last_name', '')}".strip()
                                        print(f"DEBUG: {player_name} has injury status: {player['injury_status']}", flush=True)
                                    
                                    all_players.append(player)
                            except Exception as e:
                                print(f"ERROR: Failed to get player info for {player_id}: {str(e)}", flush=True)
                    
                    # Calculate winning/losing status
                    user_points = user_matchup['points'] if user_matchup else 0
                    opponent_points = opponent_matchup['points'] if opponent_matchup else 0
                    
                    # Determine status
                    if user_points > opponent_points:
                        match_status = 'winning'
                    elif user_points < opponent_points:
                        match_status = 'losing'
                    else:
                        match_status = 'tied'
                    
                    # Store processed league data
                    league_info = {
                        'league': league,
                        'league_color': get_league_color(i),  # Assign color by order
                        'user_matchup': user_matchup,
                        'opponent_matchup': opponent_matchup,
                        'opponent_user': opponent_user,
                        'user_roster': user_roster,
                        'all_players': all_players,
                        'match_status': match_status,
                        'user_points': user_points,
                        'opponent_points': opponent_points
                    }
                    league_data.append(league_info)
                    print(f"DEBUG: League '{league['name']}' processed successfully", flush=True)
                else:
                    print(f"DEBUG: Skipping league '{league['name']}' - missing data", flush=True)
                    
            except Exception as e:
                print(f"ERROR: Failed to process league '{league['name']}': {str(e)}", flush=True)
                print(f"ERROR: League processing traceback: {traceback.format_exc()}", flush=True)
        
        # Debug output before rendering template
        print(f"DEBUG: About to render template with {len(league_data)} leagues", flush=True)
        for league_info in league_data:
            print(f"DEBUG: League '{league_info['league']['name']}' has {len(league_info['all_players'])} players", flush=True)
        
        total_game_count = sum(len(games) for games in schedule.values())
        print(f"DEBUG: Schedule has {total_game_count} total games", flush=True)
        
        try:
            # Render dashboard with all collected data
            result = render_template('dashboard.html',
                                   user=user,
                                   week=week,
                                   league_data=league_data,
                                   schedule=schedule,
                                   nfl_state=nfl_state)
            print(f"DEBUG: Template rendered successfully", flush=True)
            return result
        except Exception as e:
            print(f"ERROR: Template rendering failed: {str(e)}", flush=True)
            print(f"ERROR: Template rendering traceback: {traceback.format_exc()}", flush=True)
            return render_template('error.html', message=f"Template error: {str(e)}")
    
    except Exception as e:
        print(f"ERROR: Dashboard function exception: {str(e)}", flush=True)
        print(f"ERROR: Full dashboard traceback: {traceback.format_exc()}", flush=True)
        return render_template('error.html', 
                             message=f"Error loading data: {str(e)}")

@app.route('/api/refresh/<username>/<int:week>')
def refresh_data(username, week):
    """API endpoint for live score updates"""
    print(f"DEBUG: Refresh data API - username: '{username}', week: {week}", flush=True)
    try:
        # Get user and current season
        user = sleeper_api.get_user(username)
        if not user:
            return jsonify({'error': 'User not found'}), 404
        
        nfl_state = sleeper_api.get_nfl_state()
        season = nfl_state.get('season', str(datetime.now().year))
        leagues = sleeper_api.get_user_leagues(user['user_id'], season)
        league_scores = []
        
        # Get updated scores for each league
        for league in leagues:
            matchups = sleeper_api.get_matchups(league['league_id'], week)
            rosters = sleeper_api.get_rosters(league['league_id'])
            user_roster = next((r for r in rosters if r['owner_id'] == user['user_id']), None)
            
            if user_roster and matchups:
                # Find user and opponent matchups
                user_matchup = next((m for m in matchups if m['roster_id'] == user_roster['roster_id']), None)
                opponent_matchup = None
                if user_matchup:
                    opponent_matchup = next((m for m in matchups if m['matchup_id'] == user_matchup['matchup_id'] and m['roster_id'] != user_roster['roster_id']), None)
                
                # Return current points
                league_scores.append({
                    'league_id': league['league_id'],
                    'league_name': league['name'],
                    'user_points': user_matchup['points'] if user_matchup else 0,
                    'opponent_points': opponent_matchup['points'] if opponent_matchup else 0
                })
        
        return jsonify({'league_scores': league_scores})
    
    except Exception as e:
        print(f"ERROR: Refresh data exception: {str(e)}", flush=True)
        return jsonify({'error': str(e)}), 500

# Static file routes
@app.route('/rosterhash_logo.png')
def logo():
    """Serve the logo file"""
    return send_file('rosterhash_logo.png', mimetype='image/png')

@app.route('/favicon.ico')
def favicon():
    """Serve the favicon"""
    return send_file('rosterhash_logo.png', mimetype='image/png')

if __name__ == '__main__':
    print("DEBUG: Starting Flask app on 0.0.0.0:5000", flush=True)
    print(f"DEBUG: RosterHash {app.config['VERSION']} ready!", flush=True)
    app.run(host='0.0.0.0', port=5000, debug=True)