import logging
import traceback

from django.contrib import auth
from django.contrib.auth.base_user import BaseUserManager
from django.contrib.auth.hashers import make_password

from core.models import Address, Order

logger = logging.getLogger(__name__)


class UserManager(BaseUserManager):
    use_in_migrations = True

    @staticmethod
    def handle_unregistered_entities(user):
        try:
            orders = set()
            for order in Order.objects.filter(attributes__icontains=user.email):
                if not order.user:
                    order.user = user
                    order.save()
                    orders.add(order.uuid)
            for order in Order.objects.filter(attributes__icontains=user.phone_number):
                if not order.user:
                    order.user = user
                    order.save()
                    orders.add(order.uuid)
            for address in Address.objects.filter(billing_address_order__in=orders):
                if not address.user:
                    address.user = user
                    address.save()
            for address in Address.objects.filter(shipping_address_order__in=orders):
                if not address.user:
                    address.user = user
                    address.save()
        except Exception as e:
            logger.error(e)
            logger.error(traceback.format_exc())

        def _create_user(self, email, password, **extra_fields):
            email = self.normalize_email(email)
            user = self.model(email=email, **extra_fields)
            user.password = make_password(password)
            user.save(using=self._db)
            self.handle_unregistered_entities(user)
            return user

        def create_user(self, email=None, password=None, **extra_fields):
            extra_fields.setdefault("is_staff", False)
            extra_fields.setdefault("is_superuser", False)
            return self._create_user(email, password, **extra_fields)

        def create_superuser(self, email=None, password=None, **extra_fields):
            extra_fields.setdefault("is_staff", True)
            extra_fields.setdefault("is_superuser", True)
            if extra_fields.get("is_staff") is not True:
                raise ValueError("Superuser must have is_staff=True.")
            if extra_fields.get("is_superuser") is not True:
                raise ValueError("Superuser must have is_superuser=True.")
            user = self._create_user(email, password, **extra_fields)
            user.is_active = True
            user.is_verified = True
            user.save()
            return user

        def with_perm(self, perm, is_active=True, include_superusers=True, backend=None, obj=None):
            if backend is None:
                backends = auth._get_backends(return_tuples=True)
                if len(backends) == 1:
                    backend, _ = backends[0]
                else:
                    raise ValueError(
                        "You have multiple authentication backends configured and "
                        "therefore must provide the `backend` argument."
                    )
            elif not isinstance(backend, str):
                raise TypeError(f"backend must be a dotted import path string (got {backend}).")
            else:
                backend = auth.load_backend(backend)
            if hasattr(backend, "with_perm"):
                return backend.with_perm(
                    perm,
                    is_active=is_active,
                    include_superusers=include_superusers,
                    obj=obj,
                )
            return self.none()