from django.db import models
from django.contrib.auth.models import AbstractUser, BaseUserManager
from django.db.models import Sum

import uuid
from functools import cached_property
from torrent.models import Torrent


class UsernameUserManager(BaseUserManager):
    use_in_migrations = True

    def _create_user(self, username, email, password, **extra_fields):
        if not username:
            raise ValueError("Un username doit être défini")
        if not email:
            raise ValueError("Un email doit être défini")

        email = self.normalize_email(email)
        user = self.model(username=username, email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self.db)
        return user

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

    def create_superuser(self, username, email, password, **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 doit être staff à True")
        if extra_fields.get("is_superuser") is not True:
            raise ValueError("SuperUser doit être is_superuser à True")

        return self._create_user(username, email, password, **extra_fields)


class User(AbstractUser):
    email = models.EmailField(unique=True)

    max_size = models.PositiveBigIntegerField(default=53687091200)
    friends = models.ManyToManyField("self", blank=True)
    is_trusted = models.BooleanField(default=False)

    objects = UsernameUserManager()

    @cached_property
    def size_used(self):
        if hasattr(self, "total_size"):
            return self.total_size
        else:
            return Torrent.objects.filter(user=self).aggregate(total_size=Sum("size", default=0))["total_size"]

    @property
    def min_infos(self):
        return {"username": self.username, "id": self.id}


class FriendRequest(models.Model):
    sender = models.ForeignKey("User", on_delete=models.CASCADE, related_name="friend_request_sends")
    receiver = models.ForeignKey("User", on_delete=models.CASCADE, related_name="friend_request_receives")
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ("sender", "receiver")


class Invitation(models.Model):
    created_by = models.ForeignKey("User", models.CASCADE, related_name="invitations")
    token = models.UUIDField(default=uuid.uuid4)
    user = models.OneToOneField("User", models.CASCADE, related_name="invitation", null=True, blank=True)
    date_created = models.DateTimeField(auto_now_add=True)