"""Team-related actions for team management"""
from fastapi import Request, Depends, Form, HTTPException, BackgroundTasks
from fastapi.responses import RedirectResponse
from sqlalchemy.orm import Session
import secrets
from starlette.status import HTTP_303_SEE_OTHER
from fastapi.templating import Jinja2Templates

from ...models import Team, TeamMembership, User, TeamJoinRequest
from ...league_context import resolve_selected_league
from ...utils.auth import get_current_user
from ...utils.mail import send_team_join_request_notification, send_join_request_response
from ...templates_config import templates
from .routes import get_db
from . import utils

async def create_team_post(
    request: Request,
    name: str = Form(...),
    description: str = Form(""),
    logo_url: str = Form(""),
    is_open: bool = Form(False),
    league_id: int = Form(None),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Handle team creation form submission"""
    if not current_user:
        return RedirectResponse("/auth/login", status_code=HTTP_303_SEE_OTHER)
    
    selected_league = resolve_selected_league(db, league_id)

    # Check if team name already exists in this league
    existing_team = db.query(Team).filter(
        Team.name == name,
        Team.league_id == selected_league.id
    ).first()
    if existing_team:
        return RedirectResponse(
            f"/teams/?league_id={selected_league.id}&error=Team+name+already+exists",
            status_code=HTTP_303_SEE_OTHER
        )
    
    # Create team with only the fields that exist in the model
    team_data = {
        "name": name,
        "league_id": selected_league.id,
        "description": description,
        "is_open": is_open,
        "owner_id": current_user.id
    }
    
    # Only add logo_url if it exists in the Team model
    from sqlalchemy import inspect
    team_columns = [c.key for c in inspect(Team).columns]
    if "logo_url" in team_columns:
        team_data["logo_url"] = logo_url
    
    team = Team(**team_data)
    db.add(team)
    db.commit()
    db.refresh(team)
    
    # Make the user an admin and captain of the team
    team_membership = TeamMembership(
        user_id=current_user.id,
        team_id=team.id,
        is_admin=True,
        is_captain=True
    )
    db.add(team_membership)
    db.commit()

    return RedirectResponse(f"/teams/?league_id={selected_league.id}", status_code=HTTP_303_SEE_OTHER)

async def edit_team_post(
    request: Request,
    team_id: int,
    name: str = Form(...),
    description: str = Form(""),
    logo_url: str = Form(""),
    is_open: bool = Form(False),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Handle team edit form submission"""
    if not current_user:
        return RedirectResponse("/auth/login", status_code=HTTP_303_SEE_OTHER)
    
    team = db.query(Team).filter(Team.id == team_id).first()
    if not team:
        raise HTTPException(status_code=404, detail="Team not found")
    
    # Check if user is admin
    membership = db.query(TeamMembership).filter_by(
        team_id=team.id,
        user_id=current_user.id,
        is_admin=True
    ).first()
    
    if not membership:
        raise HTTPException(status_code=403, detail="You don't have permission to update this team")
    
    # Update team details
    team.name = name
    team.description = description
    team.logo_url = logo_url
    team.is_open = is_open
    db.commit()
    
    return RedirectResponse(f"/teams/{team_id}", status_code=HTTP_303_SEE_OTHER)

async def join_team_request(
    request: Request,
    team_id: int,
    background_tasks: BackgroundTasks,
    message: str = Form(""),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Process join team request"""
    if not current_user:
        return RedirectResponse("/auth/login", status_code=HTTP_303_SEE_OTHER)
    
    # Check if team exists
    team = db.query(Team).filter(Team.id == team_id, Team.is_active == True).first()
    if not team:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Team not found"}
        )
    
    # Check if user is already a member
    existing_membership = db.query(TeamMembership).filter(
        TeamMembership.team_id == team_id, 
        TeamMembership.user_id == current_user.id
    ).first()
    
    if existing_membership:
        return RedirectResponse(f"/teams/{team_id}", status_code=HTTP_303_SEE_OTHER)
    
    # Open team - directly add the user
    if team.is_open:
        # Add user to team
        new_member = TeamMembership(
            team_id=team_id,
            user_id=current_user.id,
            is_admin=False,
            is_captain=False
        )
        
        db.add(new_member)
        db.commit()
        
        return RedirectResponse(
            f"/teams/{team_id}?message=You+have+joined+the+team+successfully", 
            status_code=HTTP_303_SEE_OTHER
        )
    
    # Closed team - create join request
    # Check for existing pending request
    existing_request = db.query(TeamJoinRequest).filter(
        TeamJoinRequest.team_id == team_id,
        TeamJoinRequest.user_id == current_user.id,
        TeamJoinRequest.status == "pending"
    ).first()
    
    if existing_request:
        return RedirectResponse(
            f"/teams/{team_id}?message=Your+join+request+is+pending+approval", 
            status_code=HTTP_303_SEE_OTHER
        )
    
    # Create request token
    request_token = secrets.token_urlsafe(32)
    
    # Create join request
    join_request = TeamJoinRequest(
        team_id=team_id,
        user_id=current_user.id,
        message=message,
        request_token=request_token
    )
    
    db.add(join_request)
    db.commit()
    
    # Get team captains to notify - Updated to use TeamMembership instead of TeamMember
    captains = db.query(User).join(TeamMembership).filter(
        TeamMembership.team_id == team_id,
        TeamMembership.is_captain == True
    ).all()
    
    if not captains:
        print("No captains found for the team. Unable to send notifications.")
    else:
        # Send email notifications to all captains
        for captain in captains:
            try:
                await send_team_join_request_notification(
                    captain_email=captain.email,
                    captain_name=captain.username,
                    requester_name=current_user.username,
                    team_name=team.name,
                    message=message,
                    approval_token=request_token,
                    background_tasks=background_tasks
                )
                # Log success
                print(f"Team join request notification sent to {captain.email}")
            except Exception as e:
                # Log the error but continue
                print(f"Failed to send notification to {captain.email}: {str(e)}")
    
    return RedirectResponse(
        f"/teams/{team_id}?message=Your+join+request+has+been+submitted+for+approval", 
        status_code=HTTP_303_SEE_OTHER
    )

def direct_join_team(request: Request, team_id: int, db: Session = Depends(get_db)):
    """Handle direct team join requests"""
    # Check if user is logged in
    user_id = request.session.get("user_id")
    if not user_id:
        return RedirectResponse("/auth/login?next=/teams", status_code=303)
        
    # Get user
    user = db.query(User).get(user_id)
    if not user:
        return RedirectResponse("/auth/login", status_code=303)
    
    # Find the team
    team = db.query(Team).filter_by(id=team_id).first()
    if not team:
        return RedirectResponse("/teams/?error=Team+not+found", status_code=303)

    # Check if membership exists
    existing = db.query(TeamMembership)\
        .filter_by(user_id=user_id, team_id=team.id)\
        .first()
        
    if existing:
        return RedirectResponse("/teams/?error=You+are+already+a+member+of+this+team", status_code=303)
    
    # Check if team is closed (not open)
    if not team.is_open:
        # For closed teams, redirect to the join request page
        return RedirectResponse(f"/teams/{team_id}/join", status_code=303)

    # Create membership for open teams
    new_member = TeamMembership(
        user_id=user_id,
        team_id=team.id,
        is_admin=False,
        is_captain=False
    )
    db.add(new_member)
    db.commit()
    
    # Redirect to the team detail page
    return RedirectResponse(f"/teams/{team_id}", status_code=303)

def leave_team(request: Request, team_id: int, db: Session = Depends(get_db)):
    """Allow a user to leave a team"""
    # Check if user is logged in
    user_id = request.session.get("user_id")
    if not user_id:
        return RedirectResponse("/auth/login?next=/teams", status_code=303)
        
    # Get team
    team = db.query(Team).filter_by(id=team_id).first()
    if not team:
        raise HTTPException(status_code=404, detail="Team not found")
    
    # Can't leave if you're the owner
    if team.owner_id == user_id:
        return RedirectResponse(f"/teams/{team_id}?error=Team+owner+cannot+leave", status_code=303)
    
    # Find membership
    membership = db.query(TeamMembership)\
        .filter(TeamMembership.user_id == user_id, TeamMembership.team_id == team_id)\
        .first()
        
    if not membership:
        return RedirectResponse("/teams/?error=You+are+not+a+member+of+this+team", status_code=303)
    
    # Delete the team membership
    db.delete(membership)
    db.commit()
    
    return RedirectResponse("/teams/?message=Successfully+left+the+team", status_code=303)

def update_team(
    request: Request,
    team_id: int, 
    team_name: str = Form(...), 
    is_public: bool = Form(False),
    db: Session = Depends(get_db)
):
    """Update team details."""
    team = db.query(Team).filter_by(id=team_id).first()
    
    if not team:
        raise HTTPException(status_code=404, detail="Team not found")
    
    # Check if user is admin
    membership = db.query(TeamMembership).filter_by(
        team_id=team.id,
        user_id=request.session.get("user_id"),
        is_admin=True
    ).first()
    
    if not membership:
        raise HTTPException(status_code=403, detail="You don't have permission to update this team")
    
    # Update team details
    team.name = team_name
    team.is_public = is_public
    db.commit()
    
    return RedirectResponse(f"/teams/{team_id}", status_code=303)

async def approve_join_request(request: Request, token: str, db: Session = Depends(get_db)):
    """Approve a team join request using the provided token"""
    # Find the join request by token
    join_request = db.query(TeamJoinRequest).filter_by(request_token=token).first()
    
    if not join_request:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Invalid or expired join request"}
        )
    
    if join_request.status != "pending":
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "This request has already been processed"}
        )
    
    # Get the team
    team = db.query(Team).filter_by(id=join_request.team_id).first()
    if not team:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Team not found"}
        )
    
    # Check if the user has permission to approve requests
    # Get user from session
    user_id = request.session.get("user_id")
    if not user_id:
        return RedirectResponse("/auth/login", status_code=303)
    
    user = db.query(User).get(user_id)
    if not user:
        return RedirectResponse("/auth/login", status_code=303)
    
    # Check if user is admin, owner or captain
    is_user_admin, is_user_owner, is_captain = utils.check_user_permissions(db, user, join_request.team_id, team)
    
    if not (is_user_admin or is_user_owner or is_captain):
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "You don't have permission to approve join requests"}
        )
    
    # Get the user who requested to join
    requester = db.query(User).filter_by(id=join_request.user_id).first()
    if not requester:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Requesting user not found"}
        )
    
    # Check if user is already a member
    existing_membership = db.query(TeamMembership).filter(
        TeamMembership.team_id == join_request.team_id, 
        TeamMembership.user_id == join_request.user_id
    ).first()
    
    if existing_membership:
        # Update request status
        join_request.status = "approved"
        db.commit()
        
        return templates.TemplateResponse(
            "teams/request_processed.html",
            {
                "request": request,
                "message": f"{requester.username} is already a member of {team.name}",
                "team_id": team.id
            }
        )
    
    # Create team membership
    new_member = TeamMembership(
        team_id=join_request.team_id,
        user_id=join_request.user_id,
        is_admin=False,
        is_captain=False
    )
    db.add(new_member)
    
    # Update request status
    join_request.status = "approved"
    db.commit()
    
    # Send notification to the user (if email sending is available)
    try:
        background_tasks = BackgroundTasks()
        await send_join_request_response(
            user_email=requester.email,
            user_name=requester.username,
            team_name=team.name,
            approved=True,
            background_tasks=background_tasks
        )
    except Exception as e:
        print(f"Failed to send approval notification: {str(e)}")
    
    return templates.TemplateResponse(
        "teams/request_processed.html",
        {
            "request": request,
            "message": f"Successfully approved {requester.username}'s request to join {team.name}",
            "team_id": team.id
        }
    )

async def deny_join_request(request: Request, token: str, db: Session = Depends(get_db)):
    """Deny a team join request using the provided token"""
    # Find the join request by token
    join_request = db.query(TeamJoinRequest).filter_by(request_token=token).first()
    
    if not join_request:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Invalid or expired join request"}
        )
    
    if join_request.status != "pending":
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "This request has already been processed"}
        )
    
    # Get the team
    team = db.query(Team).filter_by(id=join_request.team_id).first()
    if not team:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Team not found"}
        )
    
    # Check if the user has permission to deny requests
    # Get user from session
    user_id = request.session.get("user_id")
    if not user_id:
        return RedirectResponse("/auth/login", status_code=303)
    
    user = db.query(User).get(user_id)
    if not user:
        return RedirectResponse("/auth/login", status_code=303)
    
    # Check if user is admin, owner or captain
    is_user_admin, is_user_owner, is_captain = utils.check_user_permissions(db, user, join_request.team_id, team)
    
    if not (is_user_admin or is_user_owner or is_captain):
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "You don't have permission to deny join requests"}
        )
    
    # Get the user who requested to join
    requester = db.query(User).filter_by(id=join_request.user_id).first()
    if not requester:
        return templates.TemplateResponse(
            "error.html",
            {"request": request, "error": "Requesting user not found"}
        )
    
    # Update request status
    join_request.status = "denied"
    db.commit()
    
    # Send notification to the user (if email sending is available)
    try:
        background_tasks = BackgroundTasks()
        await send_join_request_response(
            user_email=requester.email,
            user_name=requester.username,
            team_name=team.name,
            approved=False,
            background_tasks=background_tasks
        )
    except Exception as e:
        print(f"Failed to send denial notification: {str(e)}")
    
    return templates.TemplateResponse(
        "teams/request_processed.html",
        {
            "request": request,
            "message": f"Successfully denied {requester.username}'s request to join {team.name}",
            "team_id": team.id
        }
    )