from django.contrib.contenttypes.fields import ContentType
from django.contrib.postgres.fields import JSONField
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db import models
import re
from django.utils.translation import gettext_lazy as _

from utils.models import ProjectBaseMixin, URLImageMixin
from utils.models import TJSONField
from utils.models import TranslatedFieldsMixin
from utils.querysets import RelatedObjectsCountMixin


# Mixins
class CollectionNameMixin(models.Model):
    """CollectionName mixin"""
    name = models.CharField(_('name'), max_length=250)

    class Meta:
        """Meta class"""
        abstract = True


class CollectionDateMixin(models.Model):
    """CollectionDate mixin"""
    start = models.DateTimeField(_('start'))
    end = models.DateTimeField(blank=True, null=True, default=None,
                               verbose_name=_('end'))

    class Meta:
        """Meta class"""
        abstract = True


# Models
class CollectionQuerySet(RelatedObjectsCountMixin):
    """QuerySet for model Collection"""

    def by_country_code(self, code):
        """Filter collection by country code."""
        return self.filter(country__code=code)

    def published(self):
        """Returned only published collection"""
        return self.filter(is_publish=True)


class Collection(ProjectBaseMixin, CollectionDateMixin,
                 TranslatedFieldsMixin, URLImageMixin):
    """Collection model."""
    STR_FIELD_NAME = 'name'

    ORDINARY = 0  # Ordinary collection
    POP = 1  # POP collection

    COLLECTION_TYPES = (
        (ORDINARY, _('Ordinary')),
        (POP, _('Pop')),
    )

    name = TJSONField(verbose_name=_('name'),
                      help_text='{"en-GB":"some text"}')
    collection_type = models.PositiveSmallIntegerField(choices=COLLECTION_TYPES,
                                                       default=ORDINARY,
                                                       verbose_name=_('Collection type'))
    is_publish = models.BooleanField(
        default=False, verbose_name=_('Publish status'))
    on_top = models.BooleanField(
        default=False, verbose_name=_('Position on top'))
    country = models.ForeignKey(
        'location.Country', verbose_name=_('country'), on_delete=models.CASCADE)
    block_size = JSONField(
        _('collection block properties'), null=True, blank=True,
        default=None, help_text='{"width": "250px", "height":"250px"}')
    description = TJSONField(
        _('description'), null=True, blank=True,
        default=None, help_text='{"en-GB":"some text"}')
    slug = models.SlugField(max_length=50, unique=True,
                            verbose_name=_('Collection slug'), editable=True, null=True)
    old_id = models.IntegerField(null=True, blank=True)

    objects = CollectionQuerySet.as_manager()

    class Meta:
        """Meta class."""
        verbose_name = _('collection')
        verbose_name_plural = _('collections')


class GuideTypeQuerySet(models.QuerySet):
    """QuerySet for model GuideType."""


class GuideType(ProjectBaseMixin):
    """GuideType model."""

    name = models.SlugField(max_length=255, unique=True,
                            verbose_name=_('code'))

    objects = GuideTypeQuerySet.as_manager()

    class Meta:
        """Meta class."""
        verbose_name = _('guide type')
        verbose_name_plural = _('guide types')

    def __str__(self):
        """Overridden str dunder method."""
        return self.name


class GuideQuerySet(models.QuerySet):
    """QuerySet for Guide."""


class Guide(ProjectBaseMixin, CollectionNameMixin, CollectionDateMixin):
    """Guide model."""
    BUILT = 0
    WAITING = 1
    REMOVING = 2
    BUILDING = 3

    STATE_CHOICES = (
        (BUILT, 'built'),
        (WAITING, 'waiting'),
        (REMOVING, 'removing'),
        (BUILDING, 'building'),

    )

    start = models.DateTimeField(null=True,
                                 verbose_name=_('start'))
    vintage = models.IntegerField(validators=[MinValueValidator(1900),
                                              MaxValueValidator(2100)],
                                  null=True,
                                  verbose_name=_('guide vintage year'))
    slug = models.SlugField(max_length=255, unique=True, null=True,
                            verbose_name=_('slug'))
    guide_type = models.ForeignKey('GuideType', on_delete=models.PROTECT,
                                   null=True,
                                   verbose_name=_('type'))
    site = models.ForeignKey('main.SiteSettings', on_delete=models.SET_NULL,
                             null=True,
                             verbose_name=_('site settings'))
    state = models.PositiveSmallIntegerField(default=WAITING, choices=STATE_CHOICES,
                                             verbose_name=_('state'))
    old_id = models.IntegerField(blank=True, null=True)

    objects = GuideQuerySet.as_manager()

    class Meta:
        """Meta class."""
        verbose_name = _('guide')
        verbose_name_plural = _('guides')

    def __str__(self):
        """String method."""
        return f'{self.name}'


class AdvertorialQuerySet(models.QuerySet):
    """QuerySet for model Advertorial."""


class Advertorial(ProjectBaseMixin):
    """Guide advertorial model."""
    number_of_pages = models.PositiveIntegerField(
        verbose_name=_('number of pages'),
        help_text=_('the total number of reserved pages'))
    right_pages = models.PositiveIntegerField(
        verbose_name=_('number of right pages'),
        help_text=_('the number of right pages (which are part of total number).'))
    old_id = models.IntegerField(blank=True, null=True)

    objects = AdvertorialQuerySet.as_manager()

    class Meta:
        """Meta class."""
        verbose_name = _('advertorial')
        verbose_name_plural = _('advertorials')


class GuideFilterQuerySet(models.QuerySet):
    """QuerySet for model GuideFilter."""


class GuideFilter(ProjectBaseMixin):
    """Guide filter model."""
    establishment_type_json = JSONField(blank=True, null=True,
                                        verbose_name='establishment types')
    country_code_json = JSONField(blank=True, null=True,
                                  verbose_name='countries')
    region_code_json = JSONField(blank=True, null=True,
                                 verbose_name='regions')
    sub_region_code_json = JSONField(blank=True, null=True,
                                     verbose_name='sub regions')
    wine_region_json = JSONField(blank=True, null=True,
                                 verbose_name='wine regions')
    wine_classification_json = JSONField(blank=True, null=True,
                                         verbose_name='wine classifications')
    wine_color_json = JSONField(blank=True, null=True,
                                verbose_name='wine colors')
    wine_type_json = JSONField(blank=True, null=True,
                               verbose_name='wine types')
    with_mark = models.BooleanField(default=True,
                                    verbose_name=_('with mark'),
                                    help_text=_('exclude empty marks?'))
    locale_json = JSONField(blank=True, null=True,
                            verbose_name='locales')
    max_mark = models.PositiveSmallIntegerField(verbose_name=_('max mark'),
                                                help_text=_('mark under'))
    min_mark = models.PositiveSmallIntegerField(verbose_name=_('min mark'),
                                                help_text=_('mark over'))
    review_vintage_json = JSONField(verbose_name='review vintage years')
    review_state_json = JSONField(blank=True, null=True,
                                  verbose_name='review states')
    guide = models.OneToOneField(Guide, on_delete=models.CASCADE,
                                 verbose_name=_('guide'))
    old_id = models.IntegerField(blank=True, null=True)

    objects = GuideFilterQuerySet.as_manager()

    class Meta:
        """Meta class."""
        verbose_name = _('guide filter')
        verbose_name_plural = _('guide filters')