from __future__ import annotations

import copy
from typing import Any, cast
from collections.abc import Sequence

from django import forms
from django.core.exceptions import ImproperlyConfigured
from django.db.models import Model, fields
from django.utils.encoding import force_str
from django.utils.functional import Promise
from django.utils.translation import override

from modeltranslation import settings as mt_settings
from modeltranslation.thread_context import fallbacks_enabled
from modeltranslation.utils import (
    build_localized_fieldname,
    build_localized_intermediary_model,
    build_localized_verbose_name,
    get_language,
    resolution_order,
)
from modeltranslation.widgets import ClearableWidgetWrapper

from ._typing import Self
from ._compat import is_hidden, clear_ForeignObjectRel_caches

SUPPORTED_FIELDS = (
    fields.CharField,
    # Above implies also CommaSeparatedIntegerField, EmailField, FilePathField, SlugField
    # and URLField as they are subclasses of CharField.
    fields.TextField,
    fields.json.JSONField,
    fields.IntegerField,
    # Above implies also BigIntegerField, SmallIntegerField, PositiveIntegerField and
    # PositiveSmallIntegerField, as they are subclasses of IntegerField.
    fields.BooleanField,
    fields.NullBooleanField,
    fields.FloatField,
    fields.DecimalField,
    fields.IPAddressField,
    fields.GenericIPAddressField,
    fields.DateField,
    fields.DateTimeField,
    fields.TimeField,
    fields.files.FileField,
    fields.files.ImageField,
    fields.related.ForeignKey,
    # Above implies also OneToOneField
    fields.related.ManyToManyField,
)


class NONE:
    """
    Used for fallback options when they are not provided (``None`` can be
    given as a fallback or undefined value) or to mark that a nullable value
    is not yet known and needs to be computed (e.g. field default).
    """

    pass


def create_translation_field(model: type[Model], field_name: str, lang: str, empty_value: Any):
    """
    Translation field factory. Returns a ``TranslationField`` based on a
    fieldname and a language.

    The list of supported fields can be extended by defining a tuple of field
    names in the projects settings.py like this::

        MODELTRANSLATION_CUSTOM_FIELDS = ('MyField', 'MyOtherField',)

    If the class is neither a subclass of fields in ``SUPPORTED_FIELDS``, nor
    in ``CUSTOM_FIELDS`` an ``ImproperlyConfigured`` exception will be raised.
    """
    if empty_value not in ("", "both", None, NONE):
        raise ImproperlyConfigured("%s is not a valid empty_value." % empty_value)
    field = cast(fields.Field, model._meta.get_field(field_name))
    cls_name = field.__class__.__name__
    if not (isinstance(field, SUPPORTED_FIELDS) or cls_name in mt_settings.CUSTOM_FIELDS):
        raise ImproperlyConfigured("%s is not supported by modeltranslation." % cls_name)
    translation_class = field_factory(field.__class__)
    return translation_class(translated_field=field, language=lang, empty_value=empty_value)


def field_factory(baseclass: type[fields.Field]) -> type[TranslationField]:
    class TranslationFieldSpecific(TranslationField, baseclass):  # type: ignore[valid-type]
        pass

    # Reflect baseclass name of returned subclass
    TranslationFieldSpecific.__name__ = "Translation%s" % baseclass.__name__

    return TranslationFieldSpecific


class TranslationField:
    """
    The translation field functions as a proxy to the original field which is
    wrapped.

    For every field defined in the model's ``TranslationOptions`` localized
    versions of that field are added to the model depending on the languages
    given in ``settings.LANGUAGES``.

    If for example there is a model ``News`` with a field ``title`` which is
    registered for translation and the ``settings.LANGUAGES`` contains the
    ``de`` and ``en`` languages, the fields ``title_de`` and ``title_en`` will
    be added to the model class. These fields are realized using this
    descriptor.

    The translation field needs to know which language it contains therefore
    that needs to be specified when the field is created.
    """

    def __init__(
        self,
        translated_field: fields.Field,
        language: str,
        empty_value: Any,
        *args: Any,
        **kwargs: Any,
    ) -> None:
        from modeltranslation.translator import translator

        # Update the dict of this field with the content of the original one
        # This might be a bit radical?! Seems to work though...
        self.__dict__.update(translated_field.__dict__)

        # Store the originally wrapped field for later
        self.translated_field = translated_field
        self.language = language
        self.empty_value = empty_value
        if empty_value is NONE:
            self.empty_value = None if translated_field.null else ""

        # Default behaviour is that all translations are optional
        if not isinstance(self, fields.BooleanField):
            # TODO: Do we really want to enforce null *at all*? Shouldn't this
            # better honour the null setting of the translated field?
            self.null = True

        # We preserve original blank value for translated fields,
        # when they're in 'required_languages'.
        # So they will be only required if original field itself was required.
        original_blank = self.blank
        self.blank = True

        # Take required_languages translation option into account.
        trans_opts = translator.get_options_for_model(self.model)
        if trans_opts.required_languages:
            required_languages = trans_opts.required_languages
            if isinstance(required_languages, (tuple, list)):
                # All fields
                if self.language in required_languages:
                    # self.null = False
                    self.blank = original_blank
            else:
                # Certain fields only
                # Try current language - if not present, try 'default' key
                try:
                    req_fields = required_languages[self.language]
                except KeyError:
                    req_fields = required_languages.get("default", ())
                if self.name in req_fields:
                    # TODO: We might have to handle the whole thing through the
                    # FieldsAggregationMetaClass, as fields can be inherited.
                    # self.null = False
                    self.blank = original_blank

        # Adjust the name of this field to reflect the language
        self.attname = build_localized_fieldname(self.translated_field.name, language)
        self.name = self.attname
        if self.translated_field.db_column:
            self.db_column = build_localized_fieldname(self.translated_field.db_column, language)
            self.column = self.db_column

        # Copy the verbose name and append a language suffix
        # (will show up e.g. in the admin).
        self.verbose_name = build_localized_verbose_name(translated_field.verbose_name, language)

        if self.remote_field:
            clear_ForeignObjectRel_caches(self.remote_field)

        # M2M support - <rewrite related_name> <patch intermediary model>
        if isinstance(self.translated_field, fields.related.ManyToManyField) and hasattr(
            self.remote_field, "through"
        ):
            # Since fields cannot share the same remote_field object:
            self.remote_field = copy.copy(self.remote_field)

            # To support multiple relations to self, must provide a non null language scoped related_name
            if self.remote_field.symmetrical and (
                self.remote_field.model == "self"
                or self.remote_field.model == self.model._meta.object_name
                or self.remote_field.model == self.model
            ):
                self.remote_field.related_name = "%s_rel_+" % self.name
            elif is_hidden(self.remote_field):
                # Even if the backwards relation is disabled, django internally uses it, need to use a language scoped related_name
                self.remote_field.related_name = "_{}_{}_+".format(
                    self.model.__name__.lower(),
                    self.name,
                )
            else:
                # Default case with standard related_name must also include language scope
                if self.remote_field.related_name is None:
                    # For implicit related_name use different query field name
                    loc_related_query_name = build_localized_fieldname(
                        self.related_query_name(), self.language
                    )
                    self.related_query_name = lambda: loc_related_query_name
                    self.remote_field.related_name = "{}_set".format(
                        build_localized_fieldname(self.model.__name__.lower(), language),
                    )
                else:
                    self.remote_field.related_name = build_localized_fieldname(
                        self.remote_field.get_accessor_name(), language
                    )

            # Patch intermediary model with language scope to create correct db table
            self.remote_field.through = build_localized_intermediary_model(
                self.remote_field.through, language
            )
            self.remote_field.field = self

            if hasattr(self.remote_field.model._meta, "_related_objects_cache"):
                del self.remote_field.model._meta._related_objects_cache

        elif self.remote_field and not is_hidden(self.remote_field):
            current = self.remote_field.get_accessor_name()
            # Since fields cannot share the same rel object:
            self.remote_field = copy.copy(self.remote_field)

            if self.remote_field.related_name is None:
                # For implicit related_name use different query field name
                loc_related_query_name = build_localized_fieldname(
                    self.related_query_name(), self.language
                )
                self.related_query_name = lambda: loc_related_query_name
            self.remote_field.related_name = build_localized_fieldname(current, self.language)
            self.remote_field.field = self
            if hasattr(self.remote_field.model._meta, "_related_objects_cache"):
                del self.remote_field.model._meta._related_objects_cache

    # Django 1.5 changed definition of __hash__ for fields to be fine with hash requirements.
    # It spoiled our machinery, since TranslationField has the same creation_counter as its
    # original field and fields didn't get added to sets.
    # So here we override __eq__ and __hash__ to fix the issue while retaining fine with
    # http://docs.python.org/2.7/reference/datamodel.html#object.__hash__
    def __eq__(self, other: object) -> bool:
        if isinstance(other, fields.Field):
            return self.creation_counter == other.creation_counter and self.language == getattr(
                other, "language", None
            )
        return super().__eq__(other)

    def __ne__(self, other: object) -> bool:
        return not self.__eq__(other)

    def __hash__(self) -> int:
        return hash((self.creation_counter, self.language))

    def get_default(self) -> Any:
        with override(self.language):
            default = super().get_default()
            # we must *force evaluation* at this point, otherwise the lazy translatable
            # string is returned and will be evaluated only later when the main language
            # is activated again (because this context block has exited).
            #
            # force_str passes protected types as-is, which includes None, int, float,
            # datetime...
            if isinstance(default, Promise):
                default = force_str(default, strings_only=True)
            return default

    def formfield(self, *args: Any, **kwargs: Any) -> forms.Field:
        """
        Returns proper formfield, according to empty_values setting
        (only for ``forms.CharField`` subclasses).

        There are 3 different formfields:
        - CharField that stores all empty values as empty strings;
        - NullCharField that stores all empty values as None (Null);
        - NullableField that can store both None and empty string.

        By default, if no empty_values was specified in model's translation options,
        NullCharField would be used if the original field is nullable, CharField otherwise.

        This can be overridden by setting empty_values to '' or None.

        Setting 'both' will result in NullableField being used.
        Textual widgets (subclassing ``TextInput`` or ``Textarea``) used for
        nullable fields are enriched with a clear checkbox, allowing ``None``
        values to be preserved rather than saved as empty strings.

        The ``forms.CharField`` somewhat surprising behaviour is documented as a
        "won't fix": https://code.djangoproject.com/ticket/9590.
        """
        formfield = super().formfield(*args, **kwargs)
        if isinstance(formfield, forms.CharField):
            if self.empty_value is None:
                from modeltranslation.forms import NullCharField

                form_class = formfield.__class__
                kwargs["form_class"] = type(
                    "Null%s" % form_class.__name__, (NullCharField, form_class), {}
                )
                formfield = super().formfield(*args, **kwargs)
            elif self.empty_value == "both":
                from modeltranslation.forms import NullableField

                form_class = formfield.__class__
                kwargs["form_class"] = type(
                    "Nullable%s" % form_class.__name__, (NullableField, form_class), {}
                )
                formfield = super().formfield(*args, **kwargs)
                if isinstance(formfield.widget, (forms.TextInput, forms.Textarea)):
                    formfield.widget = ClearableWidgetWrapper(formfield.widget)
        return formfield

    def save_form_data(self, instance: Model, data: Any, check: bool = True) -> None:
        # Allow 3rd-party apps forms to be saved using only translated field name.
        # When translated field (e.g. 'name') is specified and translation field (e.g. 'name_en')
        # not, we assume that form was saved without knowledge of modeltranslation and we make
        # things right:
        # Translated field is saved first, settings respective translation field value. Then
        # translation field is being saved without value - and we handle this here (only for
        # active language).
        # Questionable fields are stored in special variable, which is later handled by clean_fields
        # method on the model.
        if check and self.language == get_language() and getattr(instance, self.name) and not data:
            if not hasattr(instance, "_mt_form_pending_clear"):
                instance._mt_form_pending_clear = {}
            instance._mt_form_pending_clear[self.name] = data
        else:
            super().save_form_data(instance, data)

    def deconstruct(self) -> tuple[str, str, Sequence[Any], dict[str, Any]]:
        name, path, args, kwargs = self.translated_field.deconstruct()
        if self.null is True:
            kwargs.update({"null": True})
        if "db_column" in kwargs:
            kwargs["db_column"] = self.db_column
        kwargs.update(getattr(self, "_field_options_kwargs", {}))
        return self.name, path, args, kwargs

    def clone(self) -> Self:
        from django.utils.module_loading import import_string

        name, path, args, kwargs = self.deconstruct()
        cls = import_string(path)
        return cls(*args, **kwargs)


class TranslationFieldDescriptor:
    """
    A descriptor used for the original translated field.
    """

    def __init__(
        self,
        field: fields.Field,
        fallback_languages: dict[str, tuple[str, ...]] | None = None,
        fallback_value: Any = NONE,
        fallback_undefined: Any = NONE,
    ) -> None:
        """
        Stores fallback options and the original field, so we know it's name
        and default.
        """
        self.field = field
        self.fallback_languages = fallback_languages
        self.fallback_value = fallback_value
        self.fallback_undefined = fallback_undefined

    def __set__(self, instance, value):
        """
        Updates the translation field for the current language.
        """
        # In order for deferred fields to work, we also need to set the base value
        instance.__dict__[self.field.name] = value
        if isinstance(self.field, fields.related.ForeignKey):
            instance.__dict__[self.field.get_attname()] = None if value is None else value.pk
        if getattr(instance, "_mt_init", False) or getattr(instance, "_mt_disable", False):
            # When assignment takes place in model instance constructor, don't set value.
            # This is essential for only/defer to work, but I think it's sensible anyway.
            # Setting the localized field may also be disabled by setting _mt_disable.
            return
        loc_field_name = build_localized_fieldname(self.field.name, get_language())
        setattr(instance, loc_field_name, value)

    def meaningful_value(self, val, undefined):
        """
        Check if val is considered non-empty.
        """
        if isinstance(val, fields.files.FieldFile):
            return val.name and not (
                isinstance(undefined, fields.files.FieldFile) and val == undefined
            )
        return val is not None and val != undefined

    def __get__(self, instance, owner):
        """
        Returns value from the translation field for the current language, or
        value for some another language according to fallback languages, or the
        custom fallback value, or field's default value.
        """
        if instance is None:
            return self
        default = NONE
        undefined = self.fallback_undefined
        if undefined is NONE:
            default = self.field.get_default()
            undefined = default
        langs = resolution_order(get_language(), self.fallback_languages)
        for lang in langs:
            loc_field_name = build_localized_fieldname(self.field.name, lang)
            val = getattr(instance, loc_field_name, None)
            if self.meaningful_value(val, undefined):
                return val
        if fallbacks_enabled() and self.fallback_value is not NONE:
            return self.fallback_value
        else:
            if default is NONE:
                default = self.field.get_default()
            # Some fields like FileField behave strange, as their get_default() doesn't return
            # instance of attr_class, but rather None or ''.
            # Normally this case is handled in the descriptor, but since we have overridden it, we
            # must mock it up.
            if isinstance(self.field, fields.files.FileField) and not isinstance(
                default, self.field.attr_class
            ):
                return self.field.attr_class(instance, self.field, default)
            return default


class TranslatedRelationIdDescriptor:
    """
    A descriptor used for the original '_id' attribute of a translated
    ForeignKey field.
    """

    def __init__(
        self, field_name: str, fallback_languages: dict[str, tuple[str, ...]] | None
    ) -> None:
        self.field_name = field_name  # The name of the original field (excluding '_id')
        self.fallback_languages = fallback_languages

    def __set__(self, instance, value):
        lang = get_language()
        loc_field_name = build_localized_fieldname(self.field_name, lang)
        # Localized field name with '_id'
        loc_attname = instance._meta.get_field(loc_field_name).get_attname()
        setattr(instance, loc_attname, value)
        base_attname = instance._meta.get_field(self.field_name).get_attname()
        instance.__dict__[base_attname] = value

    def __get__(self, instance, owner):
        if instance is None:
            return self
        langs = resolution_order(get_language(), self.fallback_languages)
        for lang in langs:
            loc_field_name = build_localized_fieldname(self.field_name, lang)
            # Localized field name with '_id'
            loc_attname = instance._meta.get_field(loc_field_name).get_attname()
            val = getattr(instance, loc_attname, None)
            if val is not None:
                return val
        return None


class TranslatedManyToManyDescriptor:
    """
    A descriptor used to return correct related manager without language fallbacks.
    """

    def __init__(
        self, field_name: str, fallback_languages: dict[str, tuple[str, ...]] | None
    ) -> None:
        self.field_name = field_name  # The name of the original field
        self.fallback_languages = fallback_languages

    def __get__(self, instance, owner):
        # TODO: do we really need to handle fallbacks with m2m relations?
        loc_field_name = build_localized_fieldname(self.field_name, get_language())
        loc_attname = (instance or owner)._meta.get_field(loc_field_name).get_attname()
        return getattr((instance or owner), loc_attname)

    def __set__(self, instance, value):
        loc_field_name = build_localized_fieldname(self.field_name, get_language())
        loc_attname = instance._meta.get_field(loc_field_name).get_attname()
        setattr(instance, loc_attname, value)
