from django import forms
from django.core.exceptions import NON_FIELD_ERRORS, ObjectDoesNotExist, ValidationError
from django.forms import BoundField
from django.forms.models import BaseInlineFormSet, ModelFormMetaclass
from django.utils.functional import cached_property
from django.utils.translation import get_language
from django.utils.translation.trans_real import get_supported_language_variant

from parler.models import TranslationDoesNotExist

__all__ = (
    "TranslatableModelForm",
    "TranslatedField",
    "BaseTranslatableModelForm",
    #'TranslatableModelFormMetaclass',
)


class TranslatedField:
    """
    A wrapper for a translated form field.

    This wrapper can be used to declare translated fields on the form, e.g.

    .. code-block:: python

        class MyForm(TranslatableModelForm):
            title = TranslatedField()
            slug = TranslatedField()

            description = TranslatedField(form_class=forms.CharField, widget=TinyMCE)
    """

    def __init__(self, **kwargs):
        # The metaclass performs the magic replacement with the actual formfield.
        self.kwargs = kwargs


class BaseTranslatableModelForm(forms.BaseModelForm):
    """
    The base methods added to :class:`TranslatableModelForm` to fetch and store translated fields.
    """

    language_code = None  # Set by TranslatableAdmin.get_form() on the constructed subclass.

    def __init__(self, *args, **kwargs):
        current_language = kwargs.pop("_current_language", None)  # Used for TranslatableViewMixin
        super().__init__(*args, **kwargs)

        # Load the initial values for the translated fields
        instance = kwargs.get("instance", None)
        if instance:
            for meta in instance._parler_meta:
                try:
                    # By not auto creating a model, any template code that reads the fields
                    # will continue to see one of the other translations.
                    # This also causes admin inlines to show the fallback title in __unicode__.
                    translation = instance._get_translated_model(meta=meta)
                except TranslationDoesNotExist:
                    pass
                else:
                    for field in meta.get_translated_fields():
                        try:
                            model_field = translation._meta.get_field(field)
                            self.initial.setdefault(
                                field, model_field.value_from_object(translation)
                            )
                        except ObjectDoesNotExist:
                            # This occurs when a ForeignKey field is part of the translation,
                            # but it's value is still not yet, and the field has null=False.
                            pass

        # Typically already set by admin
        if self.language_code is None:
            if instance:
                self.language_code = instance.get_current_language()
            else:
                self.language_code = current_language or get_language()

        try:
            get_supported_language_variant(self.language_code)
        except LookupError:
            # Instead of raising a ValidationError
            raise ValueError(
                "Translatable forms can't be initialized for the language '{}', "
                "that option does not exist in the 'LANGUAGES' setting.".format(self.language_code)
            )

    def _get_translation_validation_exclusions(self, translation):
        exclude = ["master"]
        if "language_code" not in self.fields:
            exclude.append("language_code")

        # This is the same logic as Django's _get_validation_exclusions(),
        # only using the translation model instead of the master instance.
        for field_name in translation.get_translated_fields():
            if field_name not in self.fields:
                # Exclude fields that aren't on the form.
                exclude.append(field_name)
            elif self._meta.fields and field_name not in self._meta.fields:
                # Field might be added manually at the form,
                # but wasn't part of the ModelForm's meta.
                exclude.append(field_name)
            elif self._meta.exclude and field_name in self._meta.exclude:
                # Same for exclude.
                exclude.append(field_name)
            elif field_name in self._errors.keys():
                # No need to validate fields that already failed.
                exclude.append(field_name)
            else:
                # Exclude fields that are not required in the form, while the model requires them.
                # See _get_validation_exclusions() for the detailed bits of this logic.
                form_field = self.fields[field_name]
                model_field = translation._meta.get_field(field_name)
                field_value = self.cleaned_data.get(field_name)
                if (
                    not model_field.blank
                    and not form_field.required
                    and field_value in form_field.empty_values
                ):
                    exclude.append(field_name)

        return exclude

    def _post_clean(self):
        # Copy the translated fields into the model
        # Make sure the language code is set as early as possible (so it's active during most clean() methods)
        self.instance.set_current_language(self.language_code)
        self.save_translated_fields()

        # Perform the regular clean checks, this also updates self.instance
        super()._post_clean()

    def save_translated_fields(self):
        """
        Save all translated fields.
        """
        fields = {}

        # Collect all translated fields {'name': 'value'}
        for field in self._translated_fields:
            try:
                value = self.cleaned_data[field]
            except KeyError:  # Field has a ValidationError
                continue
            fields[field] = value

        # Set the field values on their relevant models
        translations = self.instance._set_translated_fields(**fields)

        # Perform full clean on models
        non_translated_fields = {"id", "master_id", "language_code"}
        for translation in translations:
            self._post_clean_translation(translation)

            # Assign translated fields to the model (using the TranslatedAttribute descriptor)
            for field in translation._get_field_names():
                if field in non_translated_fields:
                    continue
                setattr(self.instance, field, getattr(translation, field))

    def _post_clean_translation(self, translation):
        exclude = self._get_translation_validation_exclusions(translation)
        try:
            translation.full_clean(exclude=exclude, validate_unique=False)
        except ValidationError as e:
            self._update_errors(e)

        # Validate uniqueness if needed.
        if self._validate_unique:
            try:
                translation.validate_unique()
            except ValidationError as e:
                self._update_errors(e)
            try:
                translation.validate_constraints()
            except ValidationError as e:
                self._update_errors(e)

    @cached_property
    def _translated_fields(self):
        field_names = self._meta.model._parler_meta.get_all_fields()
        return [f_name for f_name in field_names if f_name in self.fields]

    def __getitem__(self, name):
        """
        Return a :class:`TranslatableBoundField` for translated models.
        This extends the default ``form[field]`` interface that produces the BoundField for HTML templates.
        """
        boundfield = super().__getitem__(name)
        if name in self._translated_fields:
            # Oh the wonders of Python :)
            boundfield.__class__ = _upgrade_boundfield_class(boundfield.__class__)
        return boundfield


UPGRADED_CLASSES = {}


def _upgrade_boundfield_class(cls):
    if cls is BoundField:
        return TranslatableBoundField
    elif issubclass(cls, TranslatableBoundField):
        return cls

    # When some other package also performs this same trick,
    # combine both classes on the fly. Avoid having to do that each time.
    # This is needed for django-slug-preview
    try:
        return UPGRADED_CLASSES[cls]
    except KeyError:
        # Create once
        new_cls = type(f"Translatable{cls.__name__}", (cls, TranslatableBoundField), {})
        UPGRADED_CLASSES[cls] = new_cls
        return new_cls


class TranslatableBoundField(BoundField):
    """
    Decorating the regular BoundField to distinguish translatable fields in the admin.
    """

    #: A tagging attribute, making it easy for templates to identify these fields
    is_translatable = True

    def label_tag(
        self, contents=None, attrs=None, *args, **kwargs
    ):  # extra args differ per Django version
        if attrs is None:
            attrs = {}

        attrs["class"] = (attrs.get("class", "") + " translatable-field").strip()
        return super().label_tag(contents, attrs, *args, **kwargs)

    # The as_widget() won't be overwritten to add a 'class' attr,
    # because it will overwrite what AdminTextInputWidget and fields have as default.


class TranslatableModelFormMetaclass(ModelFormMetaclass):
    """
    Meta class to add translated form fields to the form.
    """

    def __new__(mcs, name, bases, attrs):
        # Before constructing class, fetch attributes from bases list.
        form_meta = _get_mro_attribute(bases, "_meta")
        form_base_fields = _get_mro_attribute(
            bases, "base_fields", {}
        )  # set by previous class level.

        if form_meta:
            # Not declaring the base class itself, this is a subclass.

            # Read the model from the 'Meta' attribute. This even works in the admin,
            # as `modelform_factory()` includes a 'Meta' attribute.
            # The other options can be read from the base classes.
            form_new_meta = attrs.get("Meta", form_meta)
            form_model = form_new_meta.model if form_new_meta else form_meta.model

            # Detect all placeholders at this class level.
            placeholder_fields = [
                f_name
                for f_name, attr_value in attrs.items()
                if isinstance(attr_value, TranslatedField)
            ]

            # Include the translated fields as attributes, pretend that these exist on the form.
            # This also works when assigning `form = TranslatableModelForm` in the admin,
            # since the admin always uses modelform_factory() on the form class, and therefore triggering this metaclass.
            if form_model:
                for translations_model in form_model._parler_meta.get_all_models():
                    fields = getattr(form_new_meta, "fields", form_meta.fields)
                    exclude = getattr(form_new_meta, "exclude", form_meta.exclude) or ()
                    widgets = getattr(form_new_meta, "widgets", form_meta.widgets) or ()
                    labels = getattr(form_new_meta, "labels", form_meta.labels) or ()
                    help_texts = getattr(form_new_meta, "help_texts", form_meta.help_texts) or ()
                    error_messages = (
                        getattr(form_new_meta, "error_messages", form_meta.error_messages) or ()
                    )
                    formfield_callback = attrs.get(
                        "formfield_callback", getattr(form_new_meta, "formfield_callback", None)
                    )

                    if fields == "__all__":
                        fields = None

                    for f_name in translations_model.get_translated_fields():
                        # Add translated field if not already added, and respect exclude options.
                        if f_name in placeholder_fields:
                            # The TranslatedField placeholder can be replaced directly with actual field, so do that.
                            attrs[f_name] = _get_model_form_field(
                                translations_model,
                                f_name,
                                formfield_callback=formfield_callback,
                                **attrs[f_name].kwargs,
                            )

                        # The next code holds the same logic as fields_for_model()
                        # The f.editable check happens in _get_model_form_field()
                        elif (
                            f_name not in form_base_fields
                            and (fields is None or f_name in fields)
                            and f_name not in exclude
                            and not f_name in attrs
                        ):
                            # Get declared widget kwargs
                            if f_name in widgets:
                                # Not combined with declared fields (e.g. the TranslatedField placeholder)
                                kwargs = {"widget": widgets[f_name]}
                            else:
                                kwargs = {}

                            if f_name in help_texts:
                                kwargs["help_text"] = help_texts[f_name]

                            if f_name in labels:
                                kwargs["label"] = labels[f_name]

                            if f_name in error_messages:
                                kwargs["error_messages"] = error_messages[f_name]

                            # See if this formfield was previously defined using a TranslatedField placeholder.
                            placeholder = _get_mro_attribute(bases, f_name)
                            if placeholder and isinstance(placeholder, TranslatedField):
                                kwargs.update(placeholder.kwargs)

                            # Add the form field as attribute to the class.
                            formfield = _get_model_form_field(
                                translations_model,
                                f_name,
                                formfield_callback=formfield_callback,
                                **kwargs,
                            )
                            if formfield is not None:
                                attrs[f_name] = formfield

        # Call the super class with updated `attrs` dict.
        return super().__new__(mcs, name, bases, attrs)


def _get_mro_attribute(bases, name, default=None):
    for base in bases:
        try:
            return getattr(base, name)
        except AttributeError:
            continue
    return default


def _get_model_form_field(model, name, formfield_callback=None, **kwargs):
    """
    Utility to create the formfield from a model field.
    When a field is not editable, a ``None`` will be returned.
    """
    field = model._meta.get_field(name)
    if not field.editable:  # see fields_for_model() logic in Django.
        return None

    # Apply admin formfield_overrides
    if formfield_callback is None:
        formfield = field.formfield(**kwargs)
    elif not callable(formfield_callback):
        raise TypeError("formfield_callback must be a function or callable")
    else:
        formfield = formfield_callback(field, **kwargs)

    return formfield


class TranslatableModelForm(
    BaseTranslatableModelForm, forms.ModelForm, metaclass=TranslatableModelFormMetaclass
):
    """
    The model form to use for translated models.
    """

    # The multiple parent classes are needed in django 1.7 to pass check admin.E016:
    #       "The value of 'form' must inherit from 'BaseModelForm'"
    # so we use our copied version in parler.utils.compat
    #
    # Also, the class must inherit from ModelForm,
    # or the ModelFormMetaclass will skip initialization.
    # It only adds the _meta from anything that extends ModelForm.


class TranslatableBaseInlineFormSet(BaseInlineFormSet):
    """
    The formset base for creating inlines with translatable models.
    """

    language_code = None

    def _construct_form(self, i, **kwargs):
        form = super()._construct_form(i, **kwargs)
        form.language_code = self.language_code  # Pass the language code for new objects!
        return form

    def save_new(self, form, commit=True):
        obj = super().save_new(form, commit)
        return obj


# Backwards compatibility
TranslatableModelFormMixin = BaseTranslatableModelForm
