from computed_property import ComputedCharField
from django.contrib.auth import get_user_model
from django.contrib.sites.models import Site as DjangoSite
from django.db import models
from django.urls import reverse
from django.utils.functional import cached_property
from itertools import groupby
from mf2util import interpret
from slugify import slugify
from textwrap import shorten
from urllib.parse import urljoin, urlparse

from lemonshort.short_url import short_url
from meta.models import ModelMeta
from model_utils.models import TimeStampedModel
from users.models import Site

from . import kinds
from lemoncurry import requests, utils

ENTRY_KINDS = [(k.id, k.id) for k in kinds.all]


class CatManager(models.Manager):
    def from_name(self, name):
        cat, created = self.get_or_create(name=name, slug=slugify(name))
        return cat


class Cat(models.Model):
    objects = CatManager()
    name = models.CharField(max_length=255, unique=True)
    slug = models.CharField(max_length=255, unique=True)

    def __str__(self):
        return "#" + self.name

    @property
    def url(self):
        return reverse("entries:cat", args=(self.slug,))

    class Meta:
        ordering = ("name",)


class EntryManager(models.Manager):
    def get_queryset(self):
        qs = super(EntryManager, self).get_queryset()
        return qs.select_related("author").prefetch_related("cats", "syndications")


class Entry(ModelMeta, TimeStampedModel):
    objects = EntryManager()
    kind = models.CharField(
        max_length=30, choices=ENTRY_KINDS, db_index=True, default=ENTRY_KINDS[0][0]
    )

    name = models.CharField(max_length=100, blank=True)
    photo = models.ImageField(blank=True)
    content = models.TextField()

    cats = models.ManyToManyField(Cat, related_name="entries")

    in_reply_to = models.CharField(max_length=255, blank=True)
    like_of = models.CharField(max_length=255, blank=True)
    repost_of = models.CharField(max_length=255, blank=True)

    author = models.ForeignKey(
        get_user_model(),
        related_name="entries",
        on_delete=models.CASCADE,
    )

    @property
    def reply_context(self):
        if not self.in_reply_to:
            return None
        return interpret(requests.mf2(self.in_reply_to).to_dict(), self.in_reply_to)

    @property
    def published(self):
        return self.created

    @property
    def updated(self):
        return self.modified

    _metadata = {
        "description": "excerpt",
        "image": "image_url",
        "twitter_creator": "twitter_creator",
        "og_profile_id": "og_profile_id",
    }

    @property
    def title(self):
        if self.name:
            return self.name
        return shorten(utils.to_plain(self.paragraphs[0]), width=100, placeholder="…")

    @property
    def excerpt(self):
        try:
            return utils.to_plain(self.paragraphs[0 if self.name else 1])
        except IndexError:
            return " "

    @property
    def paragraphs(self):
        lines = self.content.splitlines()
        return ["\n".join(para) for k, para in groupby(lines, key=bool) if k]

    @property
    def twitter_creator(self):
        return self.author.twitter_username

    @property
    def og_profile_id(self):
        return self.author.facebook_id

    @property
    def image_url(self):
        return self.photo.url if self.photo else self.author.avatar_url

    def __str__(self):
        return "{0} {1}: {2}".format(self.kind, self.id, self.title)

    def get_absolute_url(self):
        return self.absolute_url

    @property
    def absolute_url(self):
        base = "https://" + DjangoSite.objects.get_current().domain
        return urljoin(base, self.url)

    @property
    def affected_urls(self):
        base = "https://" + DjangoSite.objects.get_current().domain
        kind = kinds.from_id[self.kind]
        urls = {
            self.url,
            reverse("entries:index", kwargs={"kind": kind}),
            reverse("entries:atom_by_kind", kwargs={"kind": kind}),
            reverse("entries:rss_by_kind", kwargs={"kind": kind}),
        } | {cat.url for cat in self.cats.all()}
        if kind.on_home:
            urls |= {
                reverse("home:index"),
                reverse("entries:atom"),
                reverse("entries:rss"),
            }
        return {urljoin(base, u) for u in urls}

    @property
    def url(self):
        kind = kinds.from_id[self.kind]
        args = [kind, self.id]
        if kind.slug:
            args.append(self.slug)
        return reverse("entries:entry", args=args)

    @property
    def short_url(self):
        return short_url(self)

    @property
    def slug(self):
        return slugify(self.name)

    @property
    def json_ld(self):
        base = "https://" + DjangoSite.objects.get_current().domain
        url = urljoin(base, self.url)

        posting = {
            "@context": "http://schema.org",
            "@type": "BlogPosting",
            "@id": url,
            "url": url,
            "mainEntityOfPage": url,
            "author": {
                "@type": "Person",
                "url": urljoin(base, self.author.url),
                "name": self.author.name,
            },
            "headline": self.title,
            "description": self.excerpt,
            "datePublished": self.created.isoformat(),
            "dateModified": self.modified.isoformat(),
        }
        if self.photo:
            posting["image"] = (urljoin(base, self.photo.url),)
        return posting

    class Meta:
        verbose_name_plural = "entries"
        ordering = ["-created"]


class Syndication(models.Model):
    entry = models.ForeignKey(
        Entry, related_name="syndications", on_delete=models.CASCADE
    )
    url = models.CharField(max_length=255)

    domain = ComputedCharField(
        compute_from="calc_domain",
        max_length=255,
    )

    def calc_domain(self):
        domain = urlparse(self.url).netloc
        if domain.startswith("www."):
            domain = domain[4:]
        return domain

    @cached_property
    def site(self):
        d = self.domain
        try:
            return Site.objects.get(domain=d)
        except Site.DoesNotExist:
            return Site(name=d, domain=d, icon="fas fa-newspaper")

    class Meta:
        ordering = ["domain"]