import hashlib
from django.template.defaultfilters import slugify
from django.utils import timezone
from django.contrib.auth import get_user_model
from django.db import models
from django.dispatch import receiver
from django.db.models.signals import post_save

def _create_unique_string():
    time = f"pucko {timezone.now()} prutt"
    m = hashlib.blake2s()
    m.update(str.encode(time))
    return m.hexdigest()[16:52]

class User_Profile(models.Model):

    class Meta:
        verbose_name = "User profile"
        verbose_name_plural = "User profiles"
    
    user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE, related_name="profile")
    friends = models.ManyToManyField("self", blank=True)
    nickname = models.CharField("Nickname", max_length=36, default=_create_unique_string)
    first_name = models.CharField("First name", max_length=35, null=True, blank=True)
    last_name = models.CharField("Last name", max_length=50, null=True, blank=True)
    birthday = models.DateField("Birthday", null=True, blank=True)
    updated_at = models.DateTimeField("Last updated", auto_now=True)
    created_at = models.DateTimeField("Created at", auto_now_add=True)
    slug = models.CharField(max_length=36, blank=True)

    @classmethod
    def search_for(cls, query):
        search_filter = models.Q(nickname__icontains=query)|models.Q(first_name__icontains=query)|models.Q(last_name__icontains=query)
        return cls.objects.filter(search_filter).distinct()

    def friend_request_send(self, user):
        if self.friends.filter(pk=user.pk).exists():
            return "you are already friends!"
        _, created = Friend_Request.objects.get_or_create(from_user=self, to_user=user)
        if created:
            return "friend request sent."
        return "friend request already sent."
    
    def friend_request_accept(self, requestID):
        friend_request = Friend_Request.objects.get(pk=requestID)
        if friend_request.to_user == self:
            self.friends.add(friend_request.from_user)
            friend_request.from_user.friends.add(friend_request.to_user)
            friend_request.delete()
            return 0
        else:
            return -1
        
    def friend_request_deny(self, requestID):
        friend_request = Friend_Request.objects.get(pk=requestID)
        if friend_request.to_user == self:
            friend_request.delete()
            return 0
        else:
            return -1
        
    def save(self, *args, **kwargs):
        self.slug = slugify(self.nickname)
        if not self.first_name is None:
            self.first_name = self.first_name.title()
        if not self.last_name is None:
            self.last_name = self.last_name.title()
        return super(User_Profile, self).save()
    
    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"
    
    @property
    def initials(self):
        return "".join(x[0] for x in self.full_name.split(" "))

    def __str__(self):
        return f"[Userprofile] {self.nickname}"
    
    def __repr__(self):
        return self.__str__()

class Friend_Request(models.Model):
    from_user = models.ForeignKey(User_Profile, on_delete=models.CASCADE, related_name="friend_requests_sent")
    to_user = models.ForeignKey(User_Profile, on_delete=models.CASCADE, related_name="friend_requests_recieved")
    asked_at = models.DateTimeField("asked at", auto_now_add=True)

    def __str__(self):
        return f"[Friend Request] from {self.from_user.user.username} to {self.to_user.user.username}"
    
    def __repr__(self):
        return self.__str__()

@receiver(post_save, sender=get_user_model())
def create_profile_for_new_user(sender, created, instance, **kwargs):
    if created:
        profile = User_Profile(user = instance)
        profile.save()