from flask import Blueprint, render_template, redirect, url_for, flash, request, jsonify
from flask_login import login_required, current_user
from extensions import db
from models import User, Tryout, Match, MatchParticipant, Team, TeamMember, OrgTeam, TryoutRegistration, PlayerDisponibility
from datetime import datetime, time, timedelta

matches_bp = Blueprint('matches', __name__, url_prefix='/matches')


def can_schedule_match():
    """Check if user can schedule matches (coaches and above)."""
    return current_user.role in ['president', 'manager', 'coach', 'scout']


@matches_bp.route('/calendar')
@login_required
def calendar():
    """Calendar view showing tryouts and matches."""
    return render_template('pages/calendar.html')


@matches_bp.route('/api/events')
@login_required
def api_events():
    """API endpoint returning calendar events."""
    events = []
    
    # Get tryouts based on user permissions
    tryouts = get_visible_tryouts_for_user()
    
    for tryout in tryouts:
        events.append({
            'id': f'tryout_{tryout.id}',
            'title': tryout.title,
            'date': tryout.date.strftime('%Y-%m-%d'),
            'type': 'tryout',
            'color': '#3b82f6',  # Blue for tryouts
            'extendedProps': {
                'location': tryout.location or 'TBD',
                'status': tryout.status,
                'description': tryout.description or '',
                'tryout_id': tryout.id
            }
        })
        
        # Add matches for this tryout
        for match in tryout.matches:
            match_color = '#10b981' if match.match_type == 'team_vs_team' else '#f59e0b'
            
            # Build match description with participants
            match_desc = match.description or ''
            participants_str = ''
            if match.match_type == 'team_vs_team':
                teams = []
                if match.team1:
                    teams.append(match.team1.name)
                if match.team2:
                    teams.append(match.team2.name)
                participants_str = f"{' vs '.join(teams)}"
                match_desc = participants_str + (f"<br>{match.description}" if match.description else '')
            else:
                # Player scrim - show all participants
                player_names = []
                for p in match.participants.all():
                    player_name = p.player.full_name if p.player else 'Unknown Player'
                    player_names.append(player_name)
                participants_str = ', '.join(player_names) if player_names else 'No players'
                match_desc = participants_str + (f"<br>{match.description}" if match.description else '')
            
            # Include time for calendar display
            start_time_str = match.start_time.strftime('%H:%M') if match.start_time else None
            end_time_str = match.end_time.strftime('%H:%M') if match.end_time else None
            
            events.append({
                'id': f'match_{match.id}',
                'title': match.title,
                'date': match.date.strftime('%Y-%m-%d'),
                'type': 'match',
                'color': match_color,
                'extendedProps': {
                    'location': match.location or tryout.location or 'TBD',
                    'status': match.status,
                    'description': match_desc,
                    'match_type': match.match_type,
                    'tryout_id': tryout.id,
                    'match_id': match.id,
                    'start_time': start_time_str,
                    'end_time': end_time_str,
                    'participants': participants_str
                }
            })
    
    return jsonify(events)


@matches_bp.route('/api/events/<int:tryout_id>')
@login_required
def api_events_for_tryout(tryout_id):
    """API endpoint returning calendar events for a specific tryout."""
    tryout = Tryout.query.get_or_404(tryout_id)
    
    # Check if user can view this tryout
    can_view = current_user.can_manage_this_tryout(tryout)
    
    # For players, check if they're registered or participating in a match
    is_registered = False
    player_in_match = False
    if current_user.role == 'player':
        is_registered = TryoutRegistration.query.filter_by(
            tryout_id=tryout_id, player_id=current_user.id
        ).first() is not None
        
        # Check if player is participating in any matches for this tryout
        player_matches = Match.query.join(MatchParticipant).filter(
            MatchParticipant.player_id == current_user.id,
            Match.tryout_id == tryout_id
        ).all()
        player_in_match = len(player_matches) > 0
    
    # Non-participating players cannot see the calendar
    if not can_view and not is_registered and not player_in_match:
        return jsonify([])
    
    events = []
    
    # Add tryout date as an event (read-only, for context)
    events.append({
        'id': f'tryout_{tryout.id}',
        'title': f'Tryout: {tryout.title}',
        'date': tryout.date.strftime('%Y-%m-%d'),
        'type': 'tryout',
        'color': '#3b82f6',  # Blue for tryouts
        'extendedProps': {
            'location': tryout.location or 'TBD',
            'status': tryout.status,
            'description': tryout.description or '',
            'tryout_id': tryout.id
        }
    })
    
    for match in tryout.matches:
        # Determine color based on match type
        if match.match_type == 'team_vs_team' or match.match_type == 'player_vs_player':
            match_color = '#10b981'  # Green for team matches
        else:
            match_color = '#f59e0b'  # Orange for scrims
        
        # Build participant string with proper grouping
        participants_str = ''
        if match.match_type == 'team_vs_team':
            teams = []
            if match.team1:
                teams.append(match.team1.name)
            if match.team2:
                teams.append(match.team2.name)
            participants_str = f"{' vs '.join(teams)}"
        elif match.match_type == 'player_vs_player':
            # Get players grouped by team side
            team1_players = []
            for p in match.participants.filter_by(team_side=1).all():
                if p.player:
                    team1_players.append(p.player.full_name)
            team2_players = []
            for p in match.participants.filter_by(team_side=2).all():
                if p.player:
                    team2_players.append(p.player.full_name)
            if team1_players and team2_players:
                participants_str = f"{', '.join(team1_players)} vs {', '.join(team2_players)}"
            else:
                participants_str = 'TBD vs TBD'
        else:
            player_names = []
            for p in match.participants.all():
                player_name = p.player.full_name if p.player else 'Unknown Player'
                player_names.append(player_name)
            participants_str = ', '.join(player_names) if player_names else 'No players'
        
        # Include time for calendar display
        start_time_str = match.start_time.strftime('%H:%M') if match.start_time else None
        end_time_str = match.end_time.strftime('%H:%M') if match.end_time else None
        
        events.append({
            'id': f'match_{match.id}',
            'title': match.title,
            'date': match.date.strftime('%Y-%m-%d'),
            'type': 'match',
            'color': match_color,
            'extendedProps': {
                'location': match.location or tryout.location or 'TBD',
                'status': match.status,
                'match_type': match.match_type,
                'tryout_id': tryout.id,
                'match_id': match.id,
                'participants': participants_str,
                'start_time': start_time_str,
                'end_time': end_time_str
            }
        })
    
    return jsonify(events)


def get_visible_tryouts_for_user():
    """Get tryouts that the current user can see based on their role."""
    if current_user.role == 'president':
        return Tryout.query.order_by(Tryout.date).all()
    elif current_user.role == 'manager':
        return Tryout.query.filter_by(created_by=current_user.id).order_by(Tryout.date).all()
    elif current_user.role == 'coach':
        org_team = OrgTeam.query.filter_by(coach_id=current_user.id).first()
        if org_team:
            return Tryout.query.filter_by(target_org_team_id=org_team.id).order_by(Tryout.date).all()
        return []
    elif current_user.role == 'player':
        # Get tryouts player is registered for
        player_tryout_ids = [r.tryout_id for r in current_user.tryout_registrations.all()]
        tryouts = Tryout.query.filter(Tryout.id.in_(player_tryout_ids)).order_by(Tryout.date).all() if player_tryout_ids else []
        
        # Also include matches where player is participating
        player_matches = Match.query.join(MatchParticipant).filter(
            MatchParticipant.player_id == current_user.id
        ).all()
        
        player_match_tryout_ids = list(set(m.tryout_id for m in player_matches))
        additional_tryouts = Tryout.query.filter(
            Tryout.id.in_(player_match_tryout_ids)
        ).order_by(Tryout.date).all() if player_match_tryout_ids else []
        
        # Combine and deduplicate
        all_tryouts = tryouts + [t for t in additional_tryouts if t.id not in player_tryout_ids]
        return all_tryouts
    else:  # scout
        return Tryout.query.order_by(Tryout.date).all()


@matches_bp.route('/create/<int:tryout_id>', methods=['GET', 'POST'])
@login_required
def create_match(tryout_id):
    """Create a new match/scrimmage within a tryout."""
    tryout = Tryout.query.get_or_404(tryout_id)
    
    # Check if user can manage this tryout (president, manager, or coach)
    if not current_user.can_manage_this_tryout(tryout):
        flash('You do not have permission to schedule matches for this tryout.', 'danger')
        return redirect(url_for('tryouts.view_tryout', tryout_id=tryout_id))
    
    teams = Team.query.filter_by(tryout_id=tryout_id).all()
    all_players = User.query.filter_by(role='player').order_by(User.full_name).all()
    
    if request.method == 'POST':
        title = request.form.get('title')
        description = request.form.get('description')
        date_str = request.form.get('date')
        start_time_str = request.form.get('start_time')
        end_time_str = request.form.get('end_time')
        location = request.form.get('location')
        match_type = request.form.get('match_type')
        
        # Start time is now mandatory
        if not start_time_str:
            flash('Start time is required. Please select a time slot.', 'danger')
            return render_template('pages/create_match.html', tryout=tryout, teams=teams, all_players=all_players)
        
        try:
            date_obj = datetime.strptime(date_str, '%Y-%m-%d').date() if date_str else tryout.date
        except (ValueError, TypeError):
            flash('Invalid date format.', 'danger')
            return render_template('pages/create_match.html', tryout=tryout, teams=teams, all_players=all_players)
        
        start_time = None
        end_time = None
        try:
            start_time = datetime.strptime(start_time_str, '%H:%M').time()
            # Auto-calculate end time if not provided (start + 30 minutes)
            if end_time_str:
                end_time = datetime.strptime(end_time_str, '%H:%M').time()
            else:
                # Auto-calculate end time as start + 30 minutes
                start_dt = datetime.combine(date_obj, start_time)
                end_dt = start_dt + timedelta(minutes=30)
                end_time = end_dt.time()
        except ValueError:
            flash('Invalid time format.', 'danger')
            return render_template('pages/create_match.html', tryout=tryout, teams=teams, all_players=all_players)
        
        match = Match(
            tryout_id=tryout_id,
            title=title,
            description=description,
            date=date_obj,
            start_time=start_time,
            end_time=end_time,
            location=location,
            match_type=match_type,
            created_by=current_user.id
        )
        db.session.add(match)
        db.session.flush()  # Get match.id before commit
        
        # Handle team vs team matches
        if match_type == 'team_vs_team':
            team1_id = request.form.get('team1_id')
            team2_id = request.form.get('team2_id')
            match.team1_id = int(team1_id) if team1_id else None
            match.team2_id = int(team2_id) if team2_id else None
        
        # Handle player vs player matches
        elif match_type == 'player_vs_player':
            team1_player_ids = request.form.getlist('team1_player_ids')
            team2_player_ids = request.form.getlist('team2_player_ids')
            for pid in team1_player_ids:
                participant = MatchParticipant(match_id=match.id, player_id=int(pid), team_side=1)
                db.session.add(participant)
            for pid in team2_player_ids:
                participant = MatchParticipant(match_id=match.id, player_id=int(pid), team_side=2)
                db.session.add(participant)
        
        # Handle player scrim matches
        elif match_type == 'player_scrim':
            player_ids = request.form.getlist('player_ids')
            for pid in player_ids:
                participant = MatchParticipant(match_id=match.id, player_id=int(pid))
                db.session.add(participant)
        
        db.session.commit()
        flash('Match scheduled successfully!', 'success')
        return redirect(url_for('tryouts.view_tryout', tryout_id=tryout_id))
    
    return render_template('pages/create_match.html', tryout=tryout, teams=teams, all_players=all_players)


@matches_bp.route('/<int:match_id>/edit', methods=['GET', 'POST'])
@login_required
def edit_match(match_id):
    """Edit an existing match."""
    match = Match.query.get_or_404(match_id)
    tryout = match.tryout
    
    if not current_user.can_manage_this_tryout(tryout):
        flash('You do not have permission to edit this match.', 'danger')
        return redirect(url_for('matches.calendar'))
    
    teams = Team.query.filter_by(tryout_id=tryout.id).all()
    all_players = User.query.filter_by(role='player').order_by(User.full_name).all()
    current_player_ids = [p.player_id for p in match.participants.all()]
    # Get players grouped by team side for player_vs_player matches
    team1_player_ids = [p.player_id for p in match.participants.filter_by(team_side=1).all()]
    team2_player_ids = [p.player_id for p in match.participants.filter_by(team_side=2).all()]
    
    if request.method == 'POST':
        match.title = request.form.get('title')
        match.description = request.form.get('description')
        date_str = request.form.get('date')
        start_time_str = request.form.get('start_time')
        end_time_str = request.form.get('end_time')
        location = request.form.get('location')
        status = request.form.get('status')
        
        try:
            match.date = datetime.strptime(date_str, '%Y-%m-%d').date()
        except (ValueError, TypeError):
            flash('Invalid date format.', 'danger')
            return render_template('pages/edit_match.html', match=match, tryout=tryout, teams=teams, all_players=all_players, current_player_ids=current_player_ids)
        
        # Start time is now mandatory
        if not start_time_str:
            flash('Start time is required. Please select a time slot.', 'danger')
            return render_template('pages/edit_match.html', match=match, tryout=tryout, teams=teams, all_players=all_players, current_player_ids=current_player_ids)
        
        try:
            match.start_time = datetime.strptime(start_time_str, '%H:%M').time()
            # Auto-calculate end time if not provided (start + 30 minutes)
            if end_time_str:
                match.end_time = datetime.strptime(end_time_str, '%H:%M').time()
            else:
                # Auto-calculate end time as start + 30 minutes
                start_dt = datetime.combine(match.date, match.start_time)
                end_dt = start_dt + timedelta(minutes=30)
                match.end_time = end_dt.time()
        except ValueError:
            pass
        
        match.location = location
        if status in ['scheduled', 'completed', 'cancelled']:
            match.status = status
        
        # Handle team vs team matches
        if match.match_type == 'team_vs_team':
            team1_id = request.form.get('team1_id')
            team2_id = request.form.get('team2_id')
            match.team1_id = int(team1_id) if team1_id else None
            match.team2_id = int(team2_id) if team2_id else None
        
        # Handle player vs player matches - update participants
        elif match.match_type == 'player_vs_player':
            MatchParticipant.query.filter_by(match_id=match.id).delete()
            team1_player_ids = request.form.getlist('team1_player_ids')
            team2_player_ids = request.form.getlist('team2_player_ids')
            for pid in team1_player_ids:
                participant = MatchParticipant(match_id=match.id, player_id=int(pid), team_side=1)
                db.session.add(participant)
            for pid in team2_player_ids:
                participant = MatchParticipant(match_id=match.id, player_id=int(pid), team_side=2)
                db.session.add(participant)
        
        # Handle player scrim matches - update participants
        elif match.match_type == 'player_scrim':
            MatchParticipant.query.filter_by(match_id=match.id).delete()
            player_ids = request.form.getlist('player_ids')
            for pid in player_ids:
                participant = MatchParticipant(match_id=match.id, player_id=int(pid))
                db.session.add(participant)
        
        db.session.commit()
        flash('Match updated successfully!', 'success')
        return redirect(url_for('tryouts.view_tryout', tryout_id=tryout.id))
    
    return render_template('pages/edit_match.html', match=match, tryout=tryout, teams=teams, all_players=all_players, current_player_ids=current_player_ids, team1_player_ids=team1_player_ids, team2_player_ids=team2_player_ids)


@matches_bp.route('/<int:match_id>/delete', methods=['POST'])
@login_required
def delete_match(match_id):
    """Delete a match."""
    match = Match.query.get_or_404(match_id)
    tryout = match.tryout
    
    if not current_user.can_manage_this_tryout(tryout):
        flash('You do not have permission to delete this match.', 'danger')
        return redirect(url_for('matches.calendar'))
    
    db.session.delete(match)
    db.session.commit()
    flash('Match deleted successfully.', 'success')
    return redirect(url_for('tryouts.view_tryout', tryout_id=tryout.id))


def get_players_available_at_time(date_str, time_str):
    """Get list of player IDs available at a specific date and time.
    
    Args:
        date_str: Date in YYYY-MM-DD format
        time_str: Time in HH:MM format
        
    Returns:
        List of player IDs who are available at that time
    """
    try:
        date_obj = datetime.strptime(date_str, '%Y-%m-%d').date()
        time_obj = datetime.strptime(time_str, '%H:%M').time()
    except (ValueError, TypeError):
        return []
    
    # Calculate day of week (Python: 0=Monday, 6=Sunday)
    # JavaScript: 0=Sunday, 6=Saturday, so we convert
    date_parts = date_str.split('-')
    date_for_day = datetime(int(date_parts[0]), int(date_parts[1]), int(date_parts[2]))
    js_day = date_for_day.weekday()
    
    # Convert Python weekday (Mon=0) to our format (Mon=0)
    day_of_week = js_day
    
    # Get all active players
    players = User.query.filter_by(role='player', is_active_account=True).all()
    
    available_players = []
    for player in players:
        # Check if player has disponibility at this time
        disponibilities = PlayerDisponibility.query.filter_by(
            player_id=player.id,
            day_of_week=day_of_week
        ).all()
        
        for disp in disponibilities:
            # Check if time falls within disponibility block
            disp_start = disp.start_time.hour * 60 + disp.start_time.minute
            disp_end = disp.end_time.hour * 60 + disp.end_time.minute
            match_time = time_obj.hour * 60 + time_obj.minute
            
            if disp_start <= match_time < disp_end:
                available_players.append(player.id)
                break
    
    return available_players


@matches_bp.route('/api/available_players/<date>/<time>')
@login_required
def api_available_players(date, time):
    """API endpoint to get players available at a specific date/time slot."""
    if not current_user.can_manage_teams() and not current_user.can_schedule_matches():
        return jsonify({'error': 'Unauthorized'}), 403
    
    player_ids = get_players_available_at_time(date, time)
    return jsonify({'available_player_ids': player_ids})