import random
import time
import re
import wikipediaapi
from bs4 import BeautifulSoup
from django.conf import settings
from django.db import models
from pathlib import Path
from unidecode import unidecode


class Gender(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=250)

    class Meta:
        unique_together = ["name"]
        ordering = ["name"]
        verbose_name = "Género"
        verbose_name_plural = "Generos"

    def __str__(self):
        return self.name


class Country(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=250, verbose_name="País")

    class Meta:
        unique_together = ["name"]
        ordering = ["name"]
        verbose_name = "País"
        verbose_name_plural = "Paises"

    def __str__(self):
        return self.name


class PersonQuerySet(models.QuerySet):
    def directors(self):
        rows = self.filter(is_director=True).values_list("name", flat=True)
        return rows

    def actors(self):
        rows = self.filter(is_actor=True).values_list("name", flat=True)
        return rows


class Person(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField("Nombre", max_length=500)
    country = models.ForeignKey(
        Country, related_name="country", on_delete=models.PROTECT
    )
    date_born = models.DateField("Fecha de nacimiento", null=True, blank=True)
    is_actor = models.BooleanField("Es Actor", default=False)
    is_director = models.BooleanField("Es Director", default=False)
    is_woman = models.BooleanField("Es mujer", default=False)
    photo = models.ImageField(
        "Fotografía", upload_to="%Y/%m/%d/", null=True, blank=True
    )
    objects = PersonQuerySet.as_manager()

    class Meta:
        unique_together = ["name"]
        ordering = ["name"]
        verbose_name = "Persona"
        verbose_name_plural = "Personas"

    def __str__(self):
        return self.name


class MovieQuerySet(models.QuerySet):
    def random_pick(self, random_max=6, min_items=20, all=None, **kwargs):
        """
        Regresa películas de manera aleatoria.

        Por defecto tiene que haber al menos 20 películas en la consulta.
        Por defecto regresa un máximo de 6 películas.
        """
        if all is None:
            all = list(Movie.objects.filter(**kwargs).values())
        if len(all) < min_items:
            return None
        elif len(all) < random_max:
            return all
        else:
            return random.sample(all, random_max)

    def top_pick(self, key, top_max=6):
        """
        Regresa el top de películas.

        El top corresponde al criterio de búsqueda en 'key'.
        Por defecto regresa las primeras 6 películas como máximo.
        """
        all = list(Movie.objects.order_by(f"-{key}").values())
        return self.fix_all(all[:top_max])

    def top_random_pick(self, key, top_max=6):
        """
        Regresa el top de películas de manera aleatorias.

        El top corresponde al criterio de búsqueda en 'key'.
        Por defecto regresa un máximo de 6 películas.
        A diferencia de 'random_pick', de todo el top selecciona de manera
        aleatoria según el 'top_max'.
        """
        all = list(Movie.objects.order_by(f"-{key}").values())
        top = []
        for movie in all:
            if movie[key] == all[0][key]:
                top.append(movie)
            else:
                break
        if len(top) > top_max:
            movies = random.sample(top, top_max)
        else:
            movies = top
        return self.fix_all(movies)

    def home_pick(self):
        """
        Regresa la selección de películas para el 'home'.

        El 'home' es la página principal.
        """
        genders = list(Gender.objects.values_list("id", flat=True))
        sections = self.home_sections()
        for gender in genders:
            key = Gender.objects.get(pk=gender).name
            picked = self.random_pick(genders=gender)
            if picked:
                sections["genders"][key] = self.fix_all(picked)
        return sections

    def home_sections(self):
        """
        Regresa la selección de películas en secciones para el 'home'.

        Las secciones son novedades, mejor valorados y más descargados.
        """
        sections = {
            "Novedades": self.top_pick("id"),
            "Mejor valorados": self.top_random_pick("stars"),
            "Más descargados": self.top_pick("count"),
        }
        sections["genders"] = {}
        return sections

    def fix_all(self, movies):
        """
        Enmienda los datos de las películas.
        """
        for movie in movies:
            self.fix_data(movie, wikipedia=False)
        return movies

    def fix_data(self, movie, wikipedia=True):
        """
        Enmienda los datos de una película.

        Los enmiendos son formateos de unos valores (que se guardan en nuevas
        llaves) y de rutas a medios.
        """
        if len(movie["file_name"]) == 0 or len(movie["cartel"]) == 0:
            print(f"WARN: película sin ruta de video o cartel:\n{movie}")
        movie["duration_formatted"] = self.format_duration(movie["duration"])
        movie["count_formatted"] = self.format_count(movie["count"])
        movie["stars_icons"] = self.format_stars(movie["stars"])
        movie["file_name"] = self.fix_path(movie["file_name"])
        movie["cartel"] = self.fix_path(movie["cartel"])
        if wikipedia:
            movie["wiki"] = self.get_wiki(movie)

    def fix_path(self, el):
        """
        Enmienda ruta a medio.

        La ruta es distinta según se esté en producción o en desarrollo
        ('DEBUG'). La URL_DEBUB apunta a la dirección en nebula.
        """
        if settings.DEBUG:
            if str(Path(el).parent) == "." and len(el) > 0:
                el = f"{el[0]}/{el}"
            return settings.URL_DEBUG.format(el)
        else:
            return settings.MEDIA_ROOT / el

    def fix_summ(self, raw):
        """
        Enmienda sinopsis de Wikipedia.

        Los sumarios de artículos a la Wikipedia vienen con notas al pie que no
        son necesarias. Para la sinopsis estas notas son eliminadas y se
        regresa el código HTML como una cadena de caracteres.
        """
        html = BeautifulSoup(raw, "lxml")
        for ref in html.find_all("sup", "reference"):
            ref.decompose()
        clean = list(map(lambda x: str(x), html.body.children))
        return " ".join(clean)

    def format_stars(self, num):
        """
        Da formato a la cantidad de estrellas.

        Regresa la cantidad de estrellas en lugar del número de estas.
        """
        stars = "★" * num
        while len(stars) < 5:
            stars += "☆"
        return stars

    def format_count(self, num):
        """
        Da formato a la cantidad de descargas.

        Regresa la cantidad en una cifra separada por comas.
        """
        return "{:,}".format(num)

    def format_duration(self, num):
        """
        Da formato a duración.

        Regresa la duración en 'Nh Nm'; p. ej.: 1h 22m, 2h, 15m.
        """
        secs = num * 60
        hours = self.format_duration_num("%H", secs)
        mins = self.format_duration_num("%M", secs)
        if hours == "":
            return mins
        elif mins == "":
            return hours
        else:
            return f"{hours}&nbsp;{mins}"

    def format_duration_num(self, num_type, secs):
        """
        Da formato a cada número de la duración.

        Extrae hora o minuto de la duración, la pasa a int y si no es cero,
        regresa Ns; p. ej.: 1h, 55m.
        """
        num = int(time.strftime(num_type, time.gmtime(secs)))
        sym = num_type[-1].lower()
        if num == 0:
            return ""
        else:
            return f"{num}{sym}"

    def get_wiki(self, movie, again=True):
        """
        Obtiene artículo de Wikipedia.

        Primero intenta obtener el artículo por el nombre original. Si no tiene
        éxito, intenta obtenerlo por el nombre en español. Regresa None si no
        tuvo ningún éxito.
        """
        wiki = self.get_wiki_page(movie["original_name"])
        if not wiki:
            wiki = self.get_wiki_page(movie["name"])
        return wiki

    def get_wiki_page(self, title):
        """
        Intenta obtener artículo de Wikipedia.

        Si no tiene éxito, regresa 'None'.
        """
        try:
            lang = settings.LANGUAGE_CODE.split("-")[0]
            wiki = wikipediaapi.Wikipedia(
                lang, extract_format=wikipediaapi.ExtractFormat.HTML
            )
            page = wiki.page(title)
            if page.exists():
                return {
                    "title": page.title,
                    "url": page.fullurl,
                    "summary": self.fix_summ(page.summary),
                }
            else:
                return None
        except Exception:
            return None

    def get_related(self):
        """
        Regresa los campos relacionados a las películas.
        """
        return ["countries", "genders", "directors", "actors"]

    def get_movie_by_id(self, id):
        """
        Obtiene película por id.

        Esta obtención también añade objetos relacionados.
        """
        related = self.get_related()
        movie = Movie.objects.prefetch_related(*related).get(pk=id).__dict__
        for key, val in movie["_prefetched_objects_cache"].items():
            movie[key] = list(map(lambda x: x["name"], val.values()))
        movie.pop("_state")
        movie.pop("_prefetched_objects_cache")
        self.fix_data(movie)
        return movie

    def get_movies(self, query):
        """
        Obtiene películas buscadas.
        """
        movies = Movie.objects.prefetch_related(*self.get_related())
        for q in self.get_queries(query):
            selector = None
            if re.match(r"^\w:", q) is not None:
                selector = self.get_selector(re.sub(r"^(\w):.*", r"\1", q))
                q = re.sub(r"^\w:(.*)", r"\1", q)
            movies = self.get_movies_by_query(selector, q, movies)
        if len(movies) != len(Movie.objects.all()):
            if hasattr(movies, "values"):
                movies = self.fix_all(list(movies.values()))
            movies = self.random_pick(random_max=100, min_items=0, all=movies)
            return movies
        else:
            return []

    def get_movies_by_query(self, selector, query, movies):
        """
        Obtiene película por query.
        """
        if selector is None:
            return self.get_movies_by_query_any(query, movies)
        elif selector != "section":
            return self.get_movies_by_query_selector(selector, query, movies)
        else:
            return self.get_movies_by_query_section(query, movies)

    def get_movies_by_query_selector(self, selector, query, movies):
        """
        Obtiene película por query que tiene selector 'w:'.
        """
        if selector == "year":
            selector = f"{selector}__iregex"
            try:
                query = int(query)
            except Exception:
                query = 0
        else:
            if selector == "name" or selector == "original_name":
                selector = f"{selector}__unaccent__iregex"
            else:
                selector = f"{selector}__name__unaccent__iregex"
        query = f"[[:<:]]{query}"
        kwargs = {selector: query}
        return movies.filter(**kwargs)

    def get_movies_by_query_section(self, query, movies):
        """
        Obtiene película por query que tiene selector 'w:' para sección.
        """
        if query == "mejor valorados":
            return self.top_random_pick("stars", top_max=100)
        elif query == "novedades":
            return self.top_pick("id", top_max=100)
        elif query == "mas descargados":
            return self.top_pick("count", top_max=100)
        else:
            return list(movies.values())

    def get_movies_by_query_any(self, query, movies):
        """
        Obtiene película por query que no tiene ningún selector.
        """
        for field in ["name"] + self.get_related():
            if field != "name":
                field = f"{field}__name"
            kwargs = {f"{field}__unaccent__iregex": f"[[:<:]]{query}"}
            result = movies.filter(**kwargs)
            if len(result) > 0:
                movies = result
        return movies

    def get_queries(self, query):
        """
        Devuelve un conjunto de queries sanitizado; p. ej.:
            de: d:Bruno--Stagñaro y:1997 pizzá, birra,         faso
            a: ['d:bruno-stagnaro', 'y:1997', 'pizza', 'birra', 'faso']
        """
        queries = re.sub(r"\s+", " ", unidecode(str(query)).lower()).split()
        return list(map(lambda q: self.clean_query(q), queries))

    def clean_query(self, word):
        """
        Limpia query de caracteres 'W' al inicio y al final. También sustituye
        '-' por un espacio.
        """
        word = re.sub(r"^\W+", "", word)
        word = re.sub(r"\W+$", "", word)
        word = re.sub(r"-+", " ", word)
        return word

    def get_selector(self, prefix):
        """
        Obtiene el selector para filtrar la consulta de una búsqueda.

        Esto permite restricciones en la búsqueda con esta sintaxis:
        * t:Un-Título => Buscará las películas que tengan 'Un T…' en sus 'name'
        * d:Nombre => Buscará las películas que tengan 'N…' en sus 'directors'
        El guion (-) se usa como separador de palabras, puede contener acentos
        o eñe, aunque va a ser decodificado.
        """
        prefixes = {
            "t": "name",
            "o": "original_name",
            "y": "year",
            "c": "countries",
            "p": "countries",
            "d": "directors",
            "a": "actors",
            "g": "genders",
            "s": "section",
        }
        if prefix in prefixes:
            return prefixes[prefix]
        else:
            return None


def upload_cartel(instance, filename):
    first = filename[0].upper()
    if first.isdigit():
        first = "0"
    return f"{first}/{filename}"


class Movie(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField("Nombre", max_length=1000)
    original_name = models.CharField(
        "Nombre original", max_length=1000, default="", blank=True
    )
    file_name = models.CharField(
        "Nombre archivo", max_length=1000, default="", blank=True
    )
    year = models.PositiveSmallIntegerField("Año", default=1900)
    duration = models.PositiveSmallIntegerField("Duración", default=0)
    directors = models.ManyToManyField(
        Person, verbose_name="Director", related_name="directors"
    )
    actors = models.ManyToManyField(Person, related_name="actors", blank=True)
    countries = models.ManyToManyField(
        Country, related_name="countries", verbose_name="País", blank=True
    )
    genders = models.ManyToManyField(
        Gender, related_name="genders", verbose_name="Género", blank=True
    )
    cartel = models.ImageField(
        "Cartel", upload_to=upload_cartel, null=True, blank=True
    )
    count = models.PositiveIntegerField("Descargas", default=0)
    stars = models.PositiveSmallIntegerField("Estrellas", default=0)
    published = models.BooleanField("¿Publicar?", default=True)
    is_digital = models.BooleanField("Es digital", default=False)
    objects = MovieQuerySet.as_manager()

    class Meta:
        unique_together = ["name", "original_name"]
        ordering = ["name"]
        verbose_name = "Película"
        verbose_name_plural = "Películas"

    def __str__(self):
        return self.name