forms.py

import csv
import io
from datetime import date

from django import forms
from django.core import validators
from django.forms.renderers import DjangoTemplates
from django.urls import reverse
from django.core.exceptions import ObjectDoesNotExist
from django.core.validators import MaxLengthValidator
from django.core.validators import MinLengthValidator
from django.core.validators import MinValueValidator
from django.db import transaction
from django.db.models import Exists, OuterRef
from django.http import HttpResponse
from django.utils import timezone
from django.utils.safestring import mark_safe
from django.utils.translation import gettext_lazy as _

from accounts.models import CustomUser
from home.constants import DATE_INPUT_FORMAT
from home.constants import SURVEY_FIELD_VALIDATORS
from home.models import (
    Question,
    Team,
    SessionMembership,
    ProjectPreference,
    Waitlist,
    Testimonial,
    Session,
)
from home.models import Survey
from home.models import TypeField
from home.models import UserQuestionResponse
from home.models import UserSurveyResponse
from home.availability import (
    calculate_overlap,
    calculate_team_overlap,
    format_slots_as_ranges,
)
from home.validators import RatingValidator
from home.widgets import CheckboxSelectMultipleSurvey
from home.widgets import DateSurvey
from home.widgets import RadioSelectSurvey
from home.widgets import RatingSurvey


def make_choices(question: Question) -> list[tuple[str, str]]:
    choices = []
    for choice in question.choices.split(","):
        choice = choice.strip()
        choices.append((choice.replace(" ", "_").lower(), choice))
    return choices


def to_field_name(question: Question) -> str:
    """Convert a question to the response field name key."""
    return f"field_survey_{question.id}"


def get_response_value(data: dict, question: Question) -> str:
    """
    Fetch the question's value from the data dictionary,
    typically a cleaned_data.
    """
    field_name = to_field_name(question)
    return (
        ",".join(data[field_name])
        if question.type_field == TypeField.MULTI_SELECT
        else data[field_name]
    )


class BaseSurveyForm(forms.Form):
    def __init__(self, *args, survey, user, **kwargs):
        self.survey = survey
        self.user = user if user.is_authenticated else None
        self.field_names = []
        self.questions = self.survey.questions.all().order_by("ordering")
        super().__init__(*args, **kwargs)

        # Add all question fields first
        for question in self.questions:
            # to generate field name
            field_name = to_field_name(question)

            if question.type_field == TypeField.MULTI_SELECT:
                choices = make_choices(question)
                self.fields[field_name] = forms.MultipleChoiceField(
                    choices=choices,
                    label=question.label,
                    widget=CheckboxSelectMultipleSurvey,
                )
            elif question.type_field == TypeField.RADIO:
                choices = make_choices(question)
                self.fields[field_name] = forms.ChoiceField(
                    choices=choices, label=question.label, widget=RadioSelectSurvey
                )
            elif question.type_field == TypeField.SELECT:
                choices = make_choices(question)
                empty_choice = [("", _("Choose"))]
                choices = empty_choice + choices
                self.fields[field_name] = forms.ChoiceField(
                    choices=choices, label=question.label
                )
            elif question.type_field == TypeField.NUMBER:
                self.fields[field_name] = forms.IntegerField(label=question.label)
            elif question.type_field == TypeField.URL:
                self.fields[field_name] = forms.URLField(
                    label=question.label,
                    validators=[
                        MaxLengthValidator(SURVEY_FIELD_VALIDATORS["max_length"]["url"])
                    ],
                )
            elif question.type_field == TypeField.EMAIL:
                self.fields[field_name] = forms.EmailField(
                    label=question.label,
                    validators=[
                        MaxLengthValidator(
                            SURVEY_FIELD_VALIDATORS["max_length"]["email"]
                        )
                    ],
                )
            elif question.type_field == TypeField.DATE:
                self.fields[field_name] = forms.DateField(
                    label=question.label,
                    widget=DateSurvey(),
                    input_formats=DATE_INPUT_FORMAT,
                )
            elif question.type_field == TypeField.TEXT_AREA:
                self.fields[field_name] = forms.CharField(
                    label=question.label,
                    widget=forms.Textarea,
                    validators=[
                        MinLengthValidator(
                            SURVEY_FIELD_VALIDATORS["min_length"]["text_area"]
                        ),
                        MaxLengthValidator(
                            SURVEY_FIELD_VALIDATORS["max_length"]["text_area"]
                        ),
                    ],
                )
            elif question.type_field == TypeField.RATING:
                self.fields[field_name] = forms.CharField(
                    label=question.label,
                    widget=RatingSurvey,
                    validators=[
                        MaxLengthValidator(len(str(int(question.choices)))),
                        RatingValidator(int(question.choices)),
                    ],
                )
                self.fields[field_name].widget.num_ratings = int(question.choices)
            else:
                self.fields[field_name] = forms.CharField(
                    label=question.label,
                    validators=[
                        MinLengthValidator(
                            SURVEY_FIELD_VALIDATORS["min_length"]["text"]
                        ),
                        MaxLengthValidator(
                            SURVEY_FIELD_VALIDATORS["max_length"]["text"]
                        ),
                    ],
                )

            self.fields[field_name].required = question.required
            self.fields[field_name].help_text = question.help_text
            self.field_names.append(field_name)

        # Add project preference field if survey is associated with a session
        self.session = None
        try:
            app_session = self.survey.application_session
        except ObjectDoesNotExist:
            pass
        else:
            if app_session.is_accepting_applications():
                self.session = app_session

                # Add project preference field if session has available projects
                project_choices = [
                    (
                        project.id,
                        mark_safe(
                            f'<div><a href="{project.url}" target="_blank">{project.name}</a>'
                            f"<p>{project.description}</p></div>"
                        ),
                    )
                    for project in self.session.available_projects.all()
                ]
                if project_choices:
                    self.fields["project_preferences"] = forms.MultipleChoiceField(
                        choices=project_choices,
                        label=_("Project Preferences"),
                        help_text=_(
                            "Select the projects you would like to work on. "
                            "Leave blank if you're okay with any project."
                        ),
                        widget=CheckboxSelectMultipleSurvey,
                        required=False,
                    )

                # Add GitHub username field for application sessions
                self.fields["github_username"] = forms.CharField(
                    max_length=39,
                    label=_("GitHub Username"),
                    help_text=_("Your GitHub username (required for participation)"),
                    required=True,
                    initial=(
                        self.user.profile.github_username
                        if hasattr(self.user, "profile")
                        else ""
                    ),
                )

    def clean(self):
        cleaned_data = super().clean()

        for field_name in self.field_names:
            try:
                field = cleaned_data[field_name]
            except KeyError:
                raise forms.ValidationError("You must enter valid data")

            if self.fields[field_name].required and not field:
                self.add_error(field_name, "This field is required")

        return cleaned_data


class CreateUserSurveyResponseForm(BaseSurveyForm):

    def clean(self):
        cleaned_data = super().clean()
        if UserSurveyResponse.objects.filter(
            survey=self.survey, user=self.user
        ).exists():
            self.add_error(
                None,
                "You have already submitted a response. Please edit the other instead.",
            )
        return cleaned_data

    @transaction.atomic
    def save(self):
        cleaned_data = super().clean()

        user_survey_response = UserSurveyResponse.objects.create(
            survey=self.survey, user=self.user
        )

        question_responses = [
            UserQuestionResponse(
                question=question,
                user_survey_response=user_survey_response,
                value=get_response_value(cleaned_data, question),
            )
            for question in self.questions
        ]
        UserQuestionResponse.objects.bulk_create(
            question_responses,
            update_conflicts=True,
            update_fields=("value",),
            unique_fields=("question", "user_survey_response"),
        )

        # Save project preferences if provided and session exists
        if self.session and (
            project_preferences := cleaned_data.get("project_preferences")
        ):
            preferences = [
                ProjectPreference(
                    user=self.user,
                    session=self.session,
                    project_id=project_id,
                )
                for project_id in project_preferences
            ]
            ProjectPreference.objects.bulk_create(preferences, ignore_conflicts=True)

        # Save GitHub username to user profile
        if self.session and (github_username := cleaned_data.get("github_username")):
            self.user.profile.github_username = github_username
            self.user.profile.save(update_fields=["github_username"])

        return user_survey_response


class EditUserSurveyResponseForm(BaseSurveyForm):
    def __init__(self, *args, instance: UserSurveyResponse, **kwargs):
        self.user_survey_response = instance
        super().__init__(*args, survey=instance.survey, user=instance.user, **kwargs)
        self._set_initial_data()

    def _set_initial_data(self):

        question_responses = self.user_survey_response.userquestionresponse_set.all()

        for question_response in question_responses:
            field_name = to_field_name(question_response.question)
            if question_response.question.type_field == TypeField.MULTI_SELECT:
                self.fields[field_name].initial = question_response.value.split(",")
            else:
                self.fields[field_name].initial = question_response.value

        # Set initial data for project preferences
        if self.session and "project_preferences" in self.fields:
            existing_prefs = ProjectPreference.objects.for_user_session(
                user=self.user_survey_response.user, session=self.session
            ).values_list("project_id", flat=True)
            self.fields["project_preferences"].initial = list(existing_prefs)

    def clean(self):
        cleaned_data = super().clean()
        if not self.user_survey_response.is_editable():
            self.add_error(None, "You are no longer able to edit this.")
        return cleaned_data

    @transaction.atomic
    def save(self):
        cleaned_data = super().clean()
        self.user_survey_response.updated_at = timezone.now()
        self.user_survey_response.save(update_fields=["updated_at"])

        question_responses = [
            UserQuestionResponse(
                question=question,
                user_survey_response=self.user_survey_response,
                value=get_response_value(cleaned_data, question),
            )
            for question in self.questions
        ]
        UserQuestionResponse.objects.bulk_create(
            question_responses,
            update_conflicts=True,
            update_fields=("value",),
            unique_fields=("question", "user_survey_response"),
        )

        # Update project preferences if session exists
        if self.session and (
            project_preferences := cleaned_data.get("project_preferences")
        ):
            # Delete existing preferences for this user/session
            ProjectPreference.objects.for_user_session(
                user=self.user_survey_response.user, session=self.session
            ).exclude(project_id__in=project_preferences).delete()

            # Create new preferences if projects were selected
            preferences = [
                ProjectPreference(
                    user=self.user_survey_response.user,
                    session=self.session,
                    project_id=project_id,
                )
                for project_id in project_preferences
            ]
            ProjectPreference.objects.bulk_create(preferences, ignore_conflicts=True)

        # Update GitHub username in user profile
        if self.session and (github_username := cleaned_data.get("github_username")):
            self.user_survey_response.user.profile.github_username = github_username
            self.user_survey_response.user.profile.save(
                update_fields=["github_username"]
            )

        return self.user_survey_response


class SurveyCSVExportForm(forms.Form):
    """Form for generating CSV export with scorer columns"""

    scorer_names = forms.CharField(
        label=_("Scorer Names"),
        widget=forms.Textarea(attrs={"rows": 5, "cols": 40}),
        required=False,
        help_text=_(
            "Enter one scorer name per line. These will be added as "
            "empty columns in the CSV for external scoring."
        ),
    )

    def clean_scorer_names(self) -> list[str]:
        """Parse scorer names from textarea input"""
        scorer_names_text = self.cleaned_data.get("scorer_names", "")
        if not scorer_names_text.strip():
            return []

        # Split by newlines and strip whitespace
        scorers = [
            name.strip() for name in scorer_names_text.split("\n") if name.strip()
        ]
        return scorers

    def generate_csv(self, survey: Survey, request_data: dict) -> HttpResponse:
        """
        Generate CSV based on which button was clicked.

        Args:
            survey: The survey to export
            request_data: POST data to check which button was clicked

        Returns:
            HttpResponse with CSV file
        """
        if "generate_scorer_csv" in request_data:
            return self.generate_single_scorer_csv(survey)
        else:
            return self.generate_full_csv(survey)

    def generate_full_csv(self, survey: Survey) -> HttpResponse:
        """Generate CSV file with survey responses and scorer columns"""
        scorer_names = self.cleaned_data.get("scorer_names", [])

        # Get all responses for this survey with related data
        responses = (
            UserSurveyResponse.objects.filter(survey=survey)
            .select_related("user")
            .prefetch_related("userquestionresponse_set__question")
            .order_by("id")
        )

        # Get all questions for this survey
        questions = survey.questions.all().order_by("ordering")

        # Create the HTTP response with CSV headers (UTF-8 encoded)
        response = HttpResponse(content_type="text/csv; charset=utf-8")
        response["Content-Disposition"] = (
            f'attachment; filename="survey_{survey.slug}_responses.csv"'
        )
        # Add UTF-8 BOM to ensure Excel and other tools properly recognize UTF-8
        response.write("\ufeff")

        writer = csv.writer(response)

        # Write header row
        header = ["Response ID", "Submitter Name"]
        # Add question labels as columns
        header.extend([q.label for q in questions])
        # Add scorer columns
        header.extend([f"{name} score" for name in scorer_names])
        # Add Score and Selection Rank columns
        header.append("Score")
        header.append("Selection Rank")
        writer.writerow(header)

        # Write data rows
        for response_obj in responses:
            row = [
                response_obj.id,
                f"{response_obj.user.first_name} {response_obj.user.last_name}".strip()
                or response_obj.user.email,
            ]

            # Get all question responses for this survey response
            question_responses = {
                qr.question_id: qr.value
                for qr in response_obj.userquestionresponse_set.all()
            }

            # Add question responses in order
            for question in questions:
                row.append(question_responses.get(question.id, ""))

            # Add empty scorer columns
            row.extend([""] * len(scorer_names))

            # Add empty Score and Selection Rank columns
            row.append("")
            row.append("")

            writer.writerow(row)

        return response

    def generate_single_scorer_csv(self, survey: Survey) -> HttpResponse:
        """
        Generate anonymized Single Scorer CSV with only TEXT_AREA questions.
        Suitable for session organizers to score anonymously.
        """
        # Get all responses for this survey with related data
        responses = (
            UserSurveyResponse.objects.filter(survey=survey)
            .select_related("user")
            .prefetch_related("userquestionresponse_set__question")
            .order_by("id")
        )

        # Get only TEXT_AREA questions
        questions = survey.questions.filter(type_field=TypeField.TEXT_AREA).order_by(
            "ordering"
        )

        # Create the HTTP response with CSV headers (UTF-8 encoded)
        response = HttpResponse(content_type="text/csv; charset=utf-8")
        response["Content-Disposition"] = (
            f'attachment; filename="survey_{survey.slug}_single_scorer.csv"'
        )
        # Add UTF-8 BOM to ensure Excel and other tools properly recognize UTF-8
        response.write("\ufeff")

        writer = csv.writer(response)
        header = ["Response ID"]
        for question in questions:
            header.extend([question.label, f"{question.label} Score"])
        writer.writerow(header)

        # Write data rows
        for response_obj in responses:
            row = [response_obj.id]
            response_map = {
                qr.question_id: qr.value
                for qr in response_obj.userquestionresponse_set.all()
            }
            for question in questions:
                # Add the response and an empty cell for the score.
                row.extend([response_map.get(question.id, ""), ""])
            writer.writerow(row)

        return response


class SurveyCSVImportForm(forms.Form):
    """Form for importing scores from a CSV file"""

    csv_file = forms.FileField(
        label=_("CSV File"),
        validators=[validators.FileExtensionValidator(["csv"])],
        required=True,
        help_text=_(
            "Upload a CSV file with 'Response ID', 'Score', and 'Selection Rank' columns. "
            "Only these columns will be processed; all other columns will be ignored."
        ),
    )

    def clean_csv_file(self) -> list[tuple[int, int, int]]:
        """
        Parse and validate the CSV file.

        Returns:
            List of tuples (response_id, score, selection_rank) for valid rows.
            All three values are required integers.

        Raises:
            forms.ValidationError: If CSV is invalid or missing required columns
        """
        csv_file = self.cleaned_data.get("csv_file")
        if not csv_file:
            raise forms.ValidationError(_("No file was uploaded."))

        # Check file extension
        if not csv_file.name.endswith(".csv"):
            raise forms.ValidationError(_("File must be a CSV file."))

        try:
            # Read the file content and decode it
            file_content = csv_file.read().decode("utf-8-sig")  # utf-8-sig handles BOM
            csv_file.seek(0)  # Reset file pointer for potential re-reading

            # Parse CSV
            reader = csv.DictReader(io.StringIO(file_content))

            # Validate required columns exist
            if not reader.fieldnames:
                raise forms.ValidationError(_("CSV file is empty or has no headers."))

            required_columns = ["Response ID", "Score", "Selection Rank"]
            for column in required_columns:
                if column not in reader.fieldnames:
                    raise forms.ValidationError(
                        _(f"CSV file must contain a '{column}' column.")
                    )

            # Parse and validate rows
            updates = []
            errors = []
            row_number = 1  # Start at 1 for header, increment for data rows

            for row in reader:
                row_number += 1
                response_id_str = row.get("Response ID", "").strip()
                score_str = row.get("Score", "").strip()
                selection_rank_str = row.get("Selection Rank", "").strip()

                # Skip rows with empty Response ID, Score, or Selection Rank
                if not response_id_str or not score_str or not selection_rank_str:
                    continue

                # Validate Response ID is an integer
                try:
                    response_id = int(response_id_str)
                except ValueError:
                    errors.append(
                        _(
                            f"Row {row_number}: Invalid Response ID '{response_id_str}' "
                            "(must be an integer)"
                        )
                    )
                    continue

                # Validate Score is an integer
                try:
                    score = int(score_str)
                except ValueError:
                    errors.append(
                        _(
                            f"Row {row_number}: Invalid Score '{score_str}' (must be an integer)"
                        )
                    )
                    continue

                # Validate Selection Rank is an integer (required)
                try:
                    selection_rank = int(selection_rank_str)
                except ValueError:
                    errors.append(
                        _(
                            f"Row {row_number}: Invalid Selection Rank '{selection_rank_str}' "
                            "(must be an integer)"
                        )
                    )
                    continue

                updates.append((response_id, score, selection_rank))

            # Report errors if any
            if errors:
                raise forms.ValidationError(errors)

            # Ensure we have at least one valid row
            if not updates:
                raise forms.ValidationError(
                    "No valid data rows found. Ensure the CSV has 'Response ID', "
                    "'Score', and 'Selection Rank' columns with valid integer values."
                )

            return updates

        except UnicodeDecodeError:
            raise forms.ValidationError(
                "File encoding error. Please ensure the file is UTF-8 encoded."
            )
        except csv.Error as e:
            raise forms.ValidationError(f"CSV parsing error: {e}")

    def import_scores(self, survey: Survey) -> dict:
        """
        Import scores from the validated CSV data.

        Args:
            survey: The survey to import scores for

        Returns:
            Dictionary with import statistics:
                - updated: Number of responses updated
        """
        updates = self.cleaned_data.get("csv_file")
        if not updates:
            return {"updated": 0}

        response_ids = [response_id for response_id, _, _ in updates]
        score_map = {response_id: score for response_id, score, _ in updates}
        selection_rank_map = {
            response_id: selection_rank for response_id, _, selection_rank in updates
        }

        # Fetch all relevant UserSurveyResponse objects for this survey only
        existing_responses = UserSurveyResponse.objects.filter(
            id__in=response_ids,
            survey=survey,
        )

        # Update scores and selection_rank using a transaction
        updated_count = 0
        with transaction.atomic():
            for response in existing_responses.select_for_update():
                response.score = score_map[response.id]
                response.selection_rank = selection_rank_map[response.id]
                response.save(update_fields=["score", "selection_rank"])
                updated_count += 1

        return {"updated": updated_count}


# Team Formation Forms


class ApplicantFilterForm(forms.Form):
    """Form for filtering applicants by various criteria."""

    score_min = forms.IntegerField(
        label=_("Minimum Score"),
        required=False,
        widget=forms.NumberInput(
            attrs={"class": "form-input", "placeholder": "e.g., 0"}
        ),
    )
    score_max = forms.IntegerField(
        label=_("Maximum Score"),
        required=False,
        widget=forms.NumberInput(
            attrs={"class": "form-input", "placeholder": "e.g., 10"}
        ),
    )

    rank_min = forms.IntegerField(
        label=_("Minimum Selection Rank"),
        required=False,
        widget=forms.NumberInput(
            attrs={"class": "form-input", "placeholder": "e.g., 1"}
        ),
    )
    rank_max = forms.IntegerField(
        label=_("Maximum Selection Rank"),
        required=False,
        widget=forms.NumberInput(
            attrs={"class": "form-input", "placeholder": "e.g., 50"}
        ),
    )

    team = forms.ModelChoiceField(
        label=_("Team Assignment"),
        queryset=None,
        required=False,
        empty_label=_("All"),
        widget=forms.Select(attrs={"class": "form-select"}),
    )

    show_unassigned_only = forms.BooleanField(
        label=_("Show only unassigned applicants"),
        required=False,
        widget=forms.CheckboxInput(attrs={"class": "form-checkbox"}),
    )

    overlap_with_navigators = forms.ModelChoiceField(
        label=_("Has overlap with navigators"),
        queryset=None,
        required=False,
        empty_label=_("All"),
        widget=forms.Select(attrs={"class": "form-select"}),
        help_text=_(
            "Show only applicants with availability overlap with team navigators"
        ),
    )

    overlap_with_captain = forms.ModelChoiceField(
        label=_("Has overlap with captain"),
        queryset=None,
        required=False,
        empty_label=_("All"),
        widget=forms.Select(attrs={"class": "form-select"}),
        help_text=_("Show only applicants with availability overlap with team captain"),
    )

    def __init__(self, *args, session=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.session = session

        if session:
            # Populate team choices for this session
            team_queryset = session.teams.all().order_by("name")
            self.fields["team"].queryset = team_queryset
            self.fields["overlap_with_navigators"].queryset = team_queryset
            self.fields["overlap_with_captain"].queryset = team_queryset


class BaseTeamForm(forms.Form):
    """
    Base class for forms that require a session context
    and accept a comma-delimited list of user IDs.

    Provides:
    - user_ids field (hidden input)
    - clean_user_ids method with validation
    - get_selected_users method to retrieve user objects
    """

    user_ids = forms.CharField(
        widget=forms.HiddenInput(),
        required=True,
        help_text=_("Comma-separated list of user IDs"),
    )

    def __init__(self, *args, session, **kwargs):
        """Initialize form with session context."""
        super().__init__(*args, **kwargs)
        self.session = session

    def clean_user_ids(self) -> list[int]:
        """Parse and validate comma-delimited user IDs."""
        user_ids_str = self.cleaned_data.get("user_ids", "")
        if not user_ids_str:
            raise forms.ValidationError(_("No users selected"))

        try:
            user_ids = [
                int(uid.strip()) for uid in user_ids_str.split(",") if uid.strip()
            ]
        except ValueError:
            raise forms.ValidationError(_("Invalid user ID format"))

        if not user_ids:
            raise forms.ValidationError(_("No users selected"))

        # Verify users exist
        existing_count = CustomUser.objects.filter(id__in=user_ids).count()
        if existing_count != len(user_ids):
            raise forms.ValidationError(_("Some selected users do not exist"))

        return user_ids

    def get_selected_users(self) -> list[CustomUser]:
        """
        Get selected users with prefetched availability.

        Returns:
            List of CustomUser instances with availability prefetched
        """
        user_ids = self.cleaned_data["user_ids"]
        return list(
            CustomUser.objects.filter(id__in=user_ids).prefetch_related("availability")
        )


class OverlapAnalysisForm(BaseTeamForm):
    """Form for analyzing availability overlap between selected users and team members."""

    prefix = "overlap"

    team = forms.ModelChoiceField(
        label=_("Team"),
        queryset=None,
        required=True,
        empty_label=_("Choose Team to check availability overlap"),
        help_text=_("Team whose navigators/captain will be included in analysis"),
        widget=forms.Select(attrs={"class": "form-select"}),
    )

    analysis_type = forms.ChoiceField(
        label=_("Analysis Type"),
        choices=[
            ("overlap-navigator", _("Check Navigator Overlap")),
            ("overlap-captain", _("Check Captain Overlap")),
        ],
        initial="overlap-navigator",
        widget=forms.RadioSelect(attrs={"class": "form-radio"}),
    )

    def __init__(self, *args, **kwargs):
        """Initialize form with session context for team queryset."""
        super().__init__(*args, **kwargs)
        self.fields["team"].queryset = self.session.teams.order_by("name")

    def get_existing_members(self) -> list[CustomUser]:
        """
        Get navigators and djangonauts from the selected team in a single query.

        Returns:
            Tuple of (navigators, existing_djangonauts) with availability prefetched

        Raises:
            forms.ValidationError: If team has no navigators
        """
        team = self.cleaned_data["team"]
        selected_users = self.cleaned_data["user_ids"]

        team_memberships = (
            SessionMembership.objects.for_team(team)
            .filter(
                role__in=[SessionMembership.NAVIGATOR, SessionMembership.DJANGONAUT]
            )
            .exclude(user_id__in=selected_users)
            .select_related("user")
            .prefetch_related("user__availability")
        )
        return [membership.user for membership in team_memberships]

    def get_team_captain(self) -> CustomUser:
        """
        Get captain from the selected team.

        Returns:
            Captain user with availability prefetched

        Raises:
            forms.ValidationError: If team has no captain
        """
        team = self.cleaned_data["team"]
        captain_memberships = (
            SessionMembership.objects.for_team(team)
            .captains()
            .select_related("user")
            .prefetch_related("user__availability")
        )

        captains = [m.user for m in captain_memberships]

        if not captains:
            raise forms.ValidationError(f"Team '{team.name}' has no captain assigned")

        return captains[0]  # Use first captain if multiple

    def calculate_navigator_overlap_context(self) -> dict:
        """
        Calculate navigator overlap (navigators + selected users).

        Returns:
            Context dictionary with overlap analysis results
        """
        team = self.cleaned_data["team"]
        existing_members = self.get_existing_members()
        selected_users = self.get_selected_users()

        # Calculate overlap (navigators + existing djangonauts + selected users)
        all_users = existing_members + selected_users
        slots, hours = calculate_overlap(all_users)
        time_ranges = format_slots_as_ranges(slots)

        # Generate comparison URL
        user_ids = [str(u.id) for u in all_users]
        compare_url = (
            reverse("compare_availability")
            + f"?users={','.join(user_ids)}&session={self.session.id}"
        )

        return {
            "team": team,
            "analysis_type": "overlap-navigator",
            "existing_members": existing_members,
            "selected_users": selected_users,
            "hour_blocks": hours,
            "time_ranges": time_ranges,
            "is_sufficient": hours >= 5,
            "compare_availability_url": compare_url,
        }

    def calculate_captain_overlap_context(self) -> dict:
        """
        Calculate captain overlaps (with each selected user).

        Returns:
            Context dictionary with overlap analysis results
        """
        team = self.cleaned_data["team"]
        captain = self.get_team_captain()
        selected_users = self.get_selected_users()

        # Calculate captain overlaps (with each selected user)
        results = []
        for user in selected_users:
            slots, hours = calculate_overlap([captain, user])
            time_ranges = format_slots_as_ranges(slots)
            user_ids = [str(captain.id), str(user.id)]
            compare_url = (
                reverse("compare_availability")
                + f"?users={','.join(user_ids)}&session={self.session.id}"
            )

            results.append(
                {
                    "user": user,
                    "hour_blocks": hours,
                    "time_ranges": time_ranges,
                    "is_sufficient": hours >= 2,
                    "compare_availability_url": compare_url,
                }
            )

        return {
            "team": team,
            "analysis_type": "overlap-captain",
            "captain": captain,
            "results": results,
        }

    def get_overlap_context(self) -> dict:
        """
        Get overlap analysis context based on analysis type.

        Returns:
            Context dictionary for template rendering

        Raises:
            forms.ValidationError: If team members are missing
        """
        analysis_type = self.cleaned_data["analysis_type"]

        if analysis_type == "overlap-navigator":
            return self.calculate_navigator_overlap_context()
        else:  # captain
            return self.calculate_captain_overlap_context()


class BulkTeamAssignmentForm(BaseTeamForm):
    """Form for bulk assignment of users to a team."""

    prefix = "bulk_assign"

    team = forms.ModelChoiceField(
        label=_("Team"),
        queryset=None,
        required=True,
        empty_label=_("Choose Team to assign Djangonauts"),
        widget=forms.Select(attrs={"class": "form-select", "id": "bulk-team-select"}),
        help_text=_("Select the team to assign selected users to"),
    )

    def __init__(self, *args, **kwargs):
        """Initialize form with session context for team queryset."""
        super().__init__(*args, **kwargs)
        self.fields["team"].queryset = self.session.teams.order_by("name")

    def clean(self):
        """Validate that users' project preferences match the team's project."""
        cleaned_data = super().clean()

        # Only validate if we have both user_ids and team
        if "user_ids" not in cleaned_data or "team" not in cleaned_data:
            return cleaned_data

        user_ids = cleaned_data["user_ids"]
        team = cleaned_data["team"]

        # Get users who have invalid/conflicting project preferences
        users_with_invalid_pref = CustomUser.objects.filter(
            id__in=user_ids
        ).with_invalid_project_preference(
            project=team.project,
            session=self.session,
        )

        # Build error message if any users have mismatched preferences
        user_list = ", ".join(
            user.get_full_name() or user.email for user in users_with_invalid_pref
        )
        if user_list:
            self.add_error(
                "team",
                _(
                    f"The following users have not selected '{team.project.name}'"
                    f"as a preference: {user_list}. Users with no preferences can "
                    "be assigned to any project."
                ),
            )

        return cleaned_data

    @transaction.atomic
    def save(self) -> int:
        """
        Assign selected users to the team.

        Returns:
            Number of users successfully assigned
        """

        if not self.session:
            raise ValueError("Session must be set before saving")

        user_ids = self.cleaned_data["user_ids"]
        team = self.cleaned_data["team"]

        assigned_count = 0
        for user in CustomUser.objects.filter(id__in=user_ids):
            membership, created = SessionMembership.objects.get_or_create(
                user=user,
                session=self.session,
                defaults={"role": SessionMembership.DJANGONAUT},
            )
            membership.team = team
            # Don't change role - keep whatever it was
            membership.save()
            assigned_count += 1

        Waitlist.objects.filter(session=self.session, user__id__in=user_ids).delete()

        return assigned_count


class BulkWaitlistForm(BaseTeamForm):
    """Form for bulk adding users to the session waitlist."""

    prefix = "bulk_waitlist"

    @transaction.atomic
    def save(self) -> int:
        """
        Add selected users to the waitlist.

        If any users have existing SessionMembership records, those will be deleted
        before adding them to the waitlist.

        Returns:
            Number of users successfully added to waitlist
        """
        user_ids = self.cleaned_data["user_ids"]
        existing_member_ids = list(
            SessionMembership.objects.for_session(self.session)
            .filter(user_id__in=user_ids)
            .values_list("id", flat=True)
        )
        # Delete SessionMembership records for users being waitlisted
        if existing_member_ids:
            SessionMembership.objects.filter(id__in=existing_member_ids).delete()

        waitlist_entries = [
            Waitlist(user_id=user_id, session=self.session) for user_id in user_ids
        ]

        # Use bulk_create with ignore_conflicts to handle race conditions
        Waitlist.objects.bulk_create(waitlist_entries, ignore_conflicts=True)

        # Return count of actually created entries
        return len(waitlist_entries)


class SendSessionResultsForm(forms.Form):
    """Form for sending session result notifications."""

    deadline_days = forms.IntegerField(
        initial=7,
        validators=[MinValueValidator(1)],
        help_text=_("Number of days from now for the acceptance deadline"),
        widget=forms.NumberInput(attrs={"min": 1, "class": "form-control"}),
    )


class MembershipAcceptanceForm(forms.Form):
    """Form for users to accept or decline their session membership."""

    ACTION_ACCEPT = "accept"
    ACTION_DECLINE = "decline"

    ACTION_CHOICES = (
        (ACTION_ACCEPT, _("Accept Membership")),
        (ACTION_DECLINE, _("Decline Membership")),
    )

    action = forms.ChoiceField(
        choices=ACTION_CHOICES,
        widget=forms.HiddenInput(),
        required=True,
    )

    def __init__(self, *args, membership: SessionMembership, **kwargs):
        """Initialize form with membership context."""
        super().__init__(*args, **kwargs)
        self.membership = membership

    def clean(self):
        """Validate that user hasn't already responded and deadline hasn't passed."""
        cleaned_data = super().clean()

        if self.membership.accepted is not None:
            raise forms.ValidationError(
                _("You have already responded to this invitation.")
            )

        # Check if deadline has passed
        if self.membership.acceptance_deadline:
            if timezone.now().date() > self.membership.acceptance_deadline:
                deadline_str = self.membership.acceptance_deadline.strftime("%B %d, %Y")
                raise forms.ValidationError(
                    _(
                        f"The acceptance deadline ({deadline_str}) has passed. "
                        "Please contact the organizers if you still wish to "
                        "participate."
                    )
                )

        return cleaned_data

    def save(self) -> bool:
        """
        Save the acceptance/decline decision.

        Returns:
            True if accepted, False if declined
        """
        from home.email import send

        action = self.cleaned_data["action"]
        is_accepted = action == self.ACTION_ACCEPT

        self.membership.accepted = is_accepted
        self.membership.accepted_at = timezone.now()
        self.membership.save(update_fields=["accepted", "accepted_at"])

        # Send notification email to organizers if declined
        if not is_accepted:
            context = {
                "user": self.membership.user,
                "session": self.membership.session,
                "membership": self.membership,
            }
            send(
                email_template="membership_declined",
                recipient_list=[
                    "contact@djangonaut.space",
                    "session@djangonaut.space",
                ],
                context=context,
            )

        return is_accepted


class CompareAvailabilityForm(forms.Form):
    """
    Form for handling compare availability querystring parameters.

    Validates session_id, user selection, and offset parameters.
    Also determines which users the current user can select for comparison.
    """

    session = forms.ModelChoiceField(
        queryset=Session.objects.all(),
        required=False,
    )
    users = forms.CharField(required=False)
    offset = forms.FloatField(required=False, initial=0)

    def __init__(self, *args, user: CustomUser, **kwargs):
        """
        Initialize form with the requesting user.

        Args:
            user: The currently logged-in user making the request
        """
        super().__init__(*args, **kwargs)
        self.user = user
        self._session = None
        self._session_membership = None

    def clean_offset(self) -> float:
        """Return offset value, defaulting to 0 if not provided or invalid."""
        offset = self.cleaned_data.get("offset")
        return offset if offset is not None else 0.0

    def clean_users(self) -> set[int]:
        """Parse user IDs from form data, handling both comma-separated and multiple params."""
        result = set()
        # Handle multiple params (from select multiple) and comma-separated values
        values = (
            self.data.getlist("users")
            if hasattr(self.data, "getlist")
            else [self.data.get("users", "")]
        )
        for value in values:
            for uid in str(value).split(","):
                if uid.strip().isdigit():
                    result.add(int(uid.strip()))
        return result

    def clean_session(self) -> Session | None:
        if session := self.cleaned_data.get("session"):
            self._session_membership = (
                SessionMembership.objects.for_session(session)
                .for_user(self.user)
                .first()
            )
        self._session = session
        return self._session

    def get_selectable_users(self) -> list[CustomUser]:
        """
        Get users that the current user can select for comparison.

        Returns:
            List of CustomUser objects the user can compare
        """
        return list(
            CustomUser.objects.for_comparing_availability(
                user=self.user,
                session=self._session,
                session_membership=self._session_membership,
            )
        )

    def get_selected_users(
        self, selectable_users: list[CustomUser]
    ) -> list[CustomUser]:
        """
        Get the users that are currently selected from the selectable users.

        Args:
            selectable_users: List of users that can be selected

        Returns:
            List of selected CustomUser objects
        """
        if not self.cleaned_data["users"]:
            return []
        return [u for u in selectable_users if u.id in self.cleaned_data["users"]]

    def get_offset_hours(self) -> float:
        """Return the validated offset hours value."""
        return self.cleaned_data.get("offset", 0)


class CollectStatsForm(forms.Form):
    """Form for collecting GitHub stats with date range selection."""

    start_date = forms.DateField(
        label=_("Start Date"),
        widget=forms.DateInput(attrs={"type": "date"}),
    )
    end_date = forms.DateField(
        label=_("End Date"),
        widget=forms.DateInput(attrs={"type": "date"}),
    )

    def clean_start_date(self) -> date:
        start_date = self.cleaned_data["start_date"]
        today = date.today()
        if start_date > today:
            return today
        return start_date

    def clean_end_date(self) -> date:
        end_date = self.cleaned_data["end_date"]
        today = date.today()
        if end_date > today:
            return today
        return end_date

    def clean(self) -> dict:
        cleaned_data = super().clean()
        start_date = cleaned_data.get("start_date")
        end_date = cleaned_data.get("end_date")

        if start_date and end_date and start_date > end_date:
            raise forms.ValidationError(
                _("Start date must be before or equal to end date.")
            )

        return cleaned_data


class TestimonialFormRenderer(DjangoTemplates):
    field_template_name = "home/testimonials/field.html"


class TestimonialForm(forms.ModelForm):
    default_renderer = TestimonialFormRenderer

    class Meta:
        model = Testimonial
        fields = ["title", "text", "image", "image_description", "session"]
        widgets = {
            "title": forms.TextInput(attrs={"class": "form-input"}),
            "text": forms.Textarea(attrs={"class": "form-textarea", "rows": 6}),
            "image_description": forms.TextInput(attrs={"class": "form-input"}),
            "session": forms.Select(attrs={"class": "form-select"}),
        }
        help_texts = {
            "title": _("A brief title for your testimonial"),
            "text": _(
                "Share your experience from this session (minimum 50 characters)"
            ),
            "image": _(
                "Optional: Add an image to accompany your testimonial "
                "(recommended size: 600x400 pixels)"
            ),
            "image_description": _(
                "Brief description of the image for screen readers "
                "(e.g., 'Team photo of two at DjangoCon. They are "
                "both wearing Djangonaut Space shirts and in front "
                "of a building.')"
            ),
            "session": _("Select the session this testimonial is about"),
        }

    def __init__(self, *args, user, **kwargs):
        """Initialize form with user context to filter session choices."""
        super().__init__(*args, **kwargs)
        self.user = user
        # Filter sessions to those the user participated in
        self.fields["session"].queryset = Session.objects.filter(
            Exists(
                SessionMembership.objects.for_user(self.user).filter(
                    session_id=OuterRef("id")
                )
            )
        )
        self.fields["session"].empty_label = None

    def clean_text(self):
        """Validate testimonial text has minimum length."""
        text = self.cleaned_data.get("text", "")
        if len(text) < 50:
            raise forms.ValidationError(
                _("Your testimonial must be at least 50 characters long.")
            )
        return text