#models

from django.db import models
from django.urls import reverse
import misaka
from taggit.managers import TaggableManager

class Post(models.Model):
    titile = models.CharField(max_length=250)
    created_at = models.DateTimeField(auto_now=True)
    text = models.TextField()
    text_html = models.TextField(editable=False)
    tags = TaggableManager()

    def __str__(self):
        return self.text
    def save(self,*args,**kwargs):
        self.text_html = misaka.html(self.text)
        super().save(*args,**kwargs)
    def get_absolute_url(self):
        return reverse(
            "posts:post_detail",
            kwargs={
                "username": self.user.username,
                "pk": self.pk
            }
        )

class Actual(models.Model):
    created_at = models.DateTimeField(auto_now=True)
    text = models.TextField()
    text_html = models.TextField(editable=False)

    def __str__(self):
        return self.text
    def save(self,*args,**kwargs):
        self.text_html = misaka.html(self.text)
        super().save(*args,**kwargs)
    def get_absolute_url(self):
        return reverse(
            "posts:actual",
            kwargs={
                "username": self.user.username,
            }
        )
      
      
#views
from django.shortcuts import render
from django.contrib.auth.mixins import LoginRequiredMixin
from django.urls import reverse_lazy
from django.views import generic
from django.http import Http404
from braces.views import SelectRelatedMixin
from . import models,forms
from django.contrib import messages
from django.contrib.auth import get_user_model
from taggit.models import Tag
User = get_user_model()

# Create your views here.

class PostList(SelectRelatedMixin, generic.ListView):
    model = models.Post
    select_related = ("user")

class Actual(generic.ListView):
    models = models.Actual
    template_name = 'posts/actual.html'


class UserPosts(generic.ListView):
    model = models.Post
    template_name = "posts/user_post.html"

    def get_queryset(self):
        try:
            self.post_user = User.objects.prefetch_related("posts").get(
                username__iexact=self.kwargs.get("username")
            )
        except User.DoesNotExist:
            raise Http404
        else:
            return self.post_user.posts.all()

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["post_user"] = self.post_user
        return context


class PostDetail(SelectRelatedMixin, generic.DetailView):
    model = models.Post
    select_related = ("user")

    def get_queryset(self):
        queryset = super().get_queryset()
        return queryset.filter(
            user__username__iexact=self.kwargs.get("username")
        )


class CreatePost(LoginRequiredMixin, SelectRelatedMixin, generic.CreateView):
    # form_class = forms.PostForm
    form_class = forms.Post
    model = models.Post

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs.update({"user": self.request.user})
        return kwargs

    def form_valid(self, form):
        self.object = form.save(commit=False)
        self.object.user = self.request.user
        self.object.save()
        return super().form_valid(form)


class DeletePost(LoginRequiredMixin, SelectRelatedMixin, generic.DeleteView):
    model = models.Post
    select_related = ("user", "group")
    success_url = reverse_lazy("posts:all")

    def get_queryset(self):
        queryset = super().get_queryset()
        return queryset.filter(user_id=self.request.user.id)

    def delete(self, *args, **kwargs):
        messages.success(self.request, "Post usunięto")
        return super().delete(*args, **kwargs)
      
#forms
class ModelPost:
    class Meta:
        model = Post
        fields = [
            'titile',
            'text',
            'tags',
        ]