from smtplib import SMTPException

from django.shortcuts import render
from django.http import HttpResponse
from django.utils.safestring import mark_safe
from formtools.wizard.views import CookieWizardView
from django.core.mail import BadHeaderError, EmailMultiAlternatives
from django.template.loader import get_template
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.views.generic.edit import FormView

from .forms import (
    ExternForm,
    LibraryForm,
    ELiteratureForm,
    SoftwareForm,
    IFGForm,
    LiteratureForm,
    TravelForm,
    EmailForm,
    ListForm,
    BusinessCardForm,
)
from .models import TYPE_CHOICES, MODELS, TYPE_BIB, TYPE_ELIT, TYPE_SOFT

LIBRARY_FORMS = {
    TYPE_BIB: LibraryForm,
    TYPE_ELIT: ELiteratureForm,
    TYPE_SOFT: SoftwareForm,
}

HELP_TEXTS = {
    "IFG": {
        "notes": (
            "Bitte gib an, wie die gewonnenen Informationen den<br>"
            "Wikimedia-Projekten zugute kommen sollen."
        )
    },
    "MAIL": {
        "domain": (
            "Mit welcher Domain, bzw. für welches Wikimedia-Projekt,<br>"
            "möchtest du eine Mailadresse beantragen?"
        )
    },
    "LIT": {
        "notes": "Bitte gib an, wofür du die Literatur verwenden möchtest."
    },
    "LIST": {
        "domain": (
            "Mit welcher Domain, bzw. für welches Wikimedia-Projekt,<br>"
            "möchtest du eine Mailingliste beantragen?"
        )
    },
}


def auth_deny(choice, pk, auth):
    if choice not in MODELS:
        return HttpResponse(f'ERROR! UNKNOWN CHOICE TYPE! {choice}')

    MODELS[choice].set_granted(pk, auth)


@login_required
def export(request):
    '''export the project database to a csv'''
    return HttpResponse('WE WANT CSV!')


@login_required
def authorize(request, choice, pk):
    '''If IF grant a support they click a link in a mail which leads here.
    We write the granted field in the database here and set a timestamp.'''

    if ret := auth_deny(choice, pk, True):
        return ret
    else:
        return HttpResponse(f"AUTHORIZED! choice: {choice}, pk: {pk}")


@login_required
def deny(request, choice, pk):
    '''If IF denies a support they click a link in a mail which leads here
    We write the granted field in the database here.'''

    if ret := auth_deny(choice, pk, False):
        return ret
    else:
        return HttpResponse(f"DENIED! choice: {choice}, pk: {pk}")


def done(request):
    return HttpResponse(
        "Deine Anfrage wurde gesendet. Du erhältst in Kürze eine E-Mail-Benachrichtigung mit deinen Angaben. Für alle Fragen kontaktiere bitte das Team Communitys und Engagement unter community@wikimedia.de.")


def index(request):
    return render(request, 'input/index.html')


class BaseApplicationView(FormView):
    """
    Base view for all application types.

    - Each application type (travel, literature, email, etc.) gets its own subclass.
    - Renders the generic form template.
    - Handles saving the submitted form to the database.
    - Adds extra fields from the session or request type if needed.
    - Applies optional help_text overrides for certain fields.
    - Sends confirmation mail to the applicant.
    - Sends notification mail to the internal IF address.
    - Returns the "done" response after successful processing.
    """
    template_name = "input/forms/form_generic.html"
    type_code: str = ""

    def get_context_data(self, **kwargs):
        """Add the human-readable type string (from TYPE_CHOICES) to the template context."""
        ctx = super().get_context_data(**kwargs)
        ctx["typestring"] = TYPE_CHOICES.get(self.type_code, self.type_code)
        return ctx

    def get_form(self, form_class=None):
        """Return the form instance and inject custom help_texts if defined for this type."""
        form = super().get_form(form_class)

        # Apply help_text overrides if defined for this type_code
        if self.type_code in HELP_TEXTS:
            for field, text in HELP_TEXTS[self.type_code].items():
                if field in form.fields:
                    form.fields[field].help_text = mark_safe(text)

        return form

    def form_valid(self, form):
        """
        Process a valid form submission:
        - Enrich form data (e.g., set type_code, handle special rules).
        - Save the model instance and related data.
        - Send confirmation and notification mails.
        - Return the "done" response.
        """

        # Collect cleaned data and mark the current type
        data = form.cleaned_data.copy()
        data["choice"] = self.type_code

        # Special rule for literature applications
        if self.type_code == "LIT" and data.get("selfbuy") == "TRUE":
            data["selfbuy_give_data"] = "False"

        # Save model instance
        modell = form.save(commit=False)

        # Username from session if present
        user = self.request.session.get("user")
        if user:
            modell.username = user.get("username")

        # Copy common fields if provided by the form
        if "realname" in data:
            modell.realname = data["realname"]
        if "email" in data:
            modell.email = data["email"]

        # Set model.type for specific request types
        if self.type_code in ("BIB", "ELIT", "SOFT"):
            modell.type = self.type_code

        # Literature-specific extra field
        if self.type_code == "LIT" and "selfbuy_give_data" in data:
            modell.selfbuy_give_data = data["selfbuy_give_data"]

        modell.save()
        if hasattr(form, "save_m2m"):
            form.save_m2m()

        # Prepare minimal mail context and send mails
        data["pk"] = modell.pk
        data["url_prefix"] = settings.EMAIL_URL_PREFIX
        data["typestring"] = TYPE_CHOICES.get(self.type_code, self.type_code)
        context = {"data": data}

        try:
            # Mail to applicant
            txt1 = get_template("input/ifg_volunteer_mail.txt").render(context)
            html1 = get_template("input/ifg_volunteer_mail.html").render(context)
            msg1 = EmailMultiAlternatives(
                "Formular ausgefüllt", txt1, settings.IF_EMAIL, [data["email"]]
            )
            msg1.attach_alternative(html1, "text/html")
            msg1.send()

            # Mail to IF
            txt2 = get_template("input/if_mail.txt").render(context)
            html2 = get_template("input/if_mail.html").render(context)
            msg2 = EmailMultiAlternatives(
                "Formular ausgefüllt", txt2, settings.IF_EMAIL, [settings.IF_EMAIL]
            )
            msg2.attach_alternative(html2, "text/html")
            msg2.send()

        except BadHeaderError:
            modell.delete()
            return HttpResponse("Invalid header found. Data not saved!")
        except SMTPException:
            modell.delete()
            return HttpResponse("Error in sending mails (probably wrong adress?). Data not saved!")

        return done(self.request)


class TravelApplicationView(BaseApplicationView):
    form_class = TravelForm
    type_code = "TRAV"


class LibraryApplicationView(BaseApplicationView):
    form_class = LibraryForm
    type_code = "BIB"


class ELiteratureApplicationView(BaseApplicationView):
    form_class = ELiteratureForm
    type_code = "ELIT"


class SoftwareApplicationView(BaseApplicationView):
    form_class = SoftwareForm
    type_code = "SOFT"


class IFGApplicationView(BaseApplicationView):
    form_class = IFGForm
    type_code = "IFG"


class EmailApplicationView(BaseApplicationView):
    form_class = EmailForm
    type_code = "MAIL"


class LiteratureApplicationView(BaseApplicationView):
    form_class = LiteratureForm
    type_code = "LIT"


class ListApplicationView(BaseApplicationView):
    form_class = ListForm
    type_code = "LIST"


class BusinessCardApplicationView(BaseApplicationView):
    form_class = BusinessCardForm
    type_code = "VIS"