# -*- coding: utf-8 -*-
import re
from flask import url_for
from flask_wtf import FlaskForm as Form
from flask_login import current_user
from wtforms import StringField, PasswordField, ValidationError, \
                    BooleanField, validators
from wtforms.form import FormMeta
from markupsafe import Markup
from .utils import NotRegexp
from accounts.app import accounts_app


USERNAME_RE = re.compile(r'^[a-zA-Z][a-zA-Z0-9-]{1,15}$')
USERNAME_EXCLUDE_RE = re.compile(r'^(admin|root)')


class RegisterForm(Form):
    username = StringField('Benutzername', [
        validators.Regexp(USERNAME_RE, message='Benutzername darf nur aus a-z, '
                          'Zahlen und - bestehen (2-16 Zeichen, am Anfang nur a-z).'),
        NotRegexp(USERNAME_EXCLUDE_RE, message='Dieser Benutzername ist nicht erlaubt.'),
    ])
    mail = StringField('E-Mail-Adresse', [validators.Email(), validators.Length(min=6, max=50)])
    question = StringField('Hauptstadt von Deutschland?', [validators.AnyOf(
        ('Berlin', 'berlin'), message='Bitte beantworte die Frage.')])

    def validate_username(self, field):
        try:
            accounts_app.user_backend.get_by_uid(field.data)
        except accounts_app.user_backend.NoSuchUserError:
            if accounts_app.username_blacklist:
                if field.data.lower() in accounts_app.username_blacklist:
                    raise ValidationError(Markup(
                        'Dieser Benutzername ist momentan nicht erlaubt. '
                        '<a href="%s">Weitere Informationen</a>'
                        % url_for('default.about')))
        else:
            raise ValidationError('Dieser Benutzername ist schon vergeben.')

    def validate_mail(self, field):
        try:
            accounts_app.user_backend.get_by_mail(field.data)
        except accounts_app.user_backend.NoSuchUserError:
            pass
        else:
            raise ValidationError(Markup(
                'Ein Benutzername mit dieser Adresse existiert bereits. '
                'Falls du deinen Benutzernamen vergessen hast, kannst du '
                'die <a href="%s">Passwort-vergessen-Funktion</a> benutzen.'
                % url_for('default.lost_password')))


class AdminCreateAccountForm(RegisterForm):
    def validate_username(self, field):
        try:
            accounts_app.user_backend.get_by_uid(field.data)
        except accounts_app.user_backend.NoSuchUserError:
            return
        else:
            raise ValidationError('Dieser Benutzername ist schon vergeben')

    question = None


class RegisterCompleteForm(Form):
    password = PasswordField('Passwort', [validators.DataRequired(),
                                          validators.EqualTo('password_confirm', message='Passwörter stimmen nicht überein')])
    password_confirm = PasswordField('Passwort bestätigen')
    # n.b. this form is also used in lost_password_complete


class LostPasswordForm(Form):
    username_or_mail = StringField('Benutzername oder E-Mail')
    user = None

    def validate_username_or_mail(self, field):
        if '@' not in field.data:
            try:
                self.user = accounts_app.user_backend.get_by_uid(field.data)
            except accounts_app.user_backend.NoSuchUserError:
                raise ValidationError('Es gibt keinen Benutzer mit diesem Namen.')
        else:
            try:
                self.user = accounts_app.user_backend.get_by_mail(field.data)
            except accounts_app.user_backend.NoSuchUserError:
                raise ValidationError('Es gibt keinen Benutzer mit dieser Adresse.')


class SettingsMeta(FormMeta):
    def __call__(cls, *args, **kwargs):
        for service in accounts_app.all_services:
            setattr(cls, 'password_%s' % service.id, PasswordField(
                'Passwort für %s' % service.name, [
                    validators.Optional(),
                    validators.EqualTo(
                        'password_confirm_%s' % service.id,
                        message='Passwörter stimmen nicht überein'),
                ]))
            setattr(cls, 'password_confirm_%s' % service.id, PasswordField(
                'Passwort für %s (Bestätigung)' % service.name))
            setattr(cls, 'delete_%s' % service.id, BooleanField(
                'Passwort für %s löschen' % service.name))

        return super(SettingsMeta, cls).__call__(*args, **kwargs)


class SettingsForm(Form, metaclass=SettingsMeta):
    old_password = PasswordField('Altes Passwort')
    password = PasswordField('Neues Passwort', [validators.Optional(),
                                                validators.EqualTo('password_confirm', message='Passwörter stimmen nicht überein')])
    password_confirm = PasswordField('Passwort bestätigen')
    mail = StringField('E-Mail-Adresse', [validators.Optional(), validators.Email(), validators.Length(min=6, max=50)])

    def validate_old_password(self, field):
        if self.password.data:
            if not field.data:
                raise ValidationError('Gib bitte dein altes Passwort ein, um ein neues zu setzen.')
            if field.data != current_user.password:
                raise ValidationError('Altes Passwort ist falsch.')

    def validate_mail(self, field):
        results = accounts_app.user_backend.find_by_mail(field.data)
        for user in results:
            if user.uid != current_user.uid:
                raise ValidationError('Diese E-Mail-Adresse wird schon von einem anderen Account benutzt!')

    def get_servicepassword(self, service_id: str):
        return getattr(self, 'password_%s' % service_id)

    def get_servicepasswordconfirm(self, service_id: str):
        return getattr(self, 'password_confirm_%s' % service_id)

    def get_servicedelete(self, service_id: str):
        return getattr(self, 'delete_%s' % service_id)


class AdminDisableAccountForm(Form):
    username = StringField('Benutzername')
    user = None

    def validate_username(self, field):
        try:
            self.user = accounts_app.user_backend.get_by_uid(field.data)
        except accounts_app.user_backend.NoSuchUserError:
            raise ValidationError('Dieser Benutzername existiert nicht')