"""Main app models."""
from django.conf import settings
from django.contrib.contenttypes import fields as generic
from django.contrib.postgres.fields import JSONField
from django.db import models
from django.utils.translation import gettext_lazy as _
from django.contrib.contenttypes.models import ContentType
from location.models import Country
from main import methods
from utils.models import (ProjectBaseMixin, TJSONField,
                          TranslatedFieldsMixin, ImageMixin)
from utils.querysets import ContentTypeQuerySetMixin
from configuration.models import TranslationSettings

#
#
# class Tag(models.Model):
#     """Tag model."""
#     name = models.CharField(max_length=250)
#
#
# class MediaAsset(models.Model):
#     """Assets model."""
#     PHOTO = 0
#     VIDEO = 1
#     VIDEO_URL = 2
#     PDF = 3
#     DOCUMENT = 4
#
#     ASSET_TYPE_CHOICES = (
#         (PHOTO, _('photo')),
#         (VIDEO, _('video')),
#         (VIDEO_URL, _('video url')),
#         (PDF, _('pdf')),
#         (DOCUMENT, _('document'))
#     )
#
#     AMAZON_S3 = 0
#
#     STORAGE_TYPE_CHOICES = (
#         (AMAZON_S3, _('amazon s3')),
#     )
#
#     PUBLIC = 0
#     PRIVATE = 1
#     ROLE = 2
#
#     ACCESS_TYPE_CHOICES = (
#         (PUBLIC, _('public')),
#         (PRIVATE, _('private')),
#         (ROLE, _('role')),
#     )
#
#     asset_type = models.PositiveSmallIntegerField(
#         _('asset type'), choices=ASSET_TYPE_CHOICES, default=PHOTO
#     )
#     storage_type = models.PositiveSmallIntegerField(
#         _('storage type'), choices=STORAGE_TYPE_CHOICES, default=AMAZON_S3
#     )
#     storage_unit = models.CharField(_('storage unit'), blank=True, default='')
#     path = models.CharField(_('path'))
#     access_type = models.PositiveSmallIntegerField(
#         _('access type'), choices=ACCESS_TYPE_CHOICES, default=PUBLIC)
#     asset_text = JSONField(_('asset_text'))
#     size = models.IntegerField(_('size'))
#     version = models.CharField(_('version'), max_length=250)
#     text = JSONField(_('text'))
#
#
# class Contacts(models.Model):
#     """Contacts model."""
#     address = models.ForeignKey(
#         'location.Address', verbose_name=_('address'), on_delete=models.CASCADE
#     )
#
#
# class Social(models.Model):
#     """Social model."""
#     WEBSITE = 0
#     SOCIAL = 1
#
#     SOCIAL_TYPE_CHOICES = (
#         (WEBSITE, _('website')),
#         (SOCIAL, _('social')),
#     )
#
#     social_type = models.PositiveSmallIntegerField(
#         _('social type'), choices=SOCIAL_TYPE_CHOICES
#     )
#
#
# class Note(models.Model):
#     """Note model."""
#
#
# class Ad(models.Model):
#     """Ad model."""
#


class SiteSettingsQuerySet(models.QuerySet):
    """Extended queryset for SiteSettings model."""

    def with_country(self):
        return self.filter(country__isnull=False)


class SiteSettings(ProjectBaseMixin):

    subdomain = models.CharField(max_length=255, db_index=True, unique=True,
                                 verbose_name=_('Subdomain'))
    country = models.OneToOneField(Country, on_delete=models.PROTECT,
                                   null=True, blank=True, default=None,
                                   verbose_name=_('Country'))
    default_site = models.BooleanField(default=False,
                                       verbose_name=_('Default site'))
    pinterest_page_url = models.URLField(blank=True, null=True, default=None,
                                         verbose_name=_('Pinterest page URL'))
    twitter_page_url = models.URLField(blank=True, null=True, default=None,
                                       verbose_name=_('Twitter page URL'))
    facebook_page_url = models.URLField(blank=True, null=True, default=None,
                                        verbose_name=_('Facebook page URL'))
    instagram_page_url = models.URLField(blank=True, null=True, default=None,
                                         verbose_name=_('Instagram page URL'))
    contact_email = models.EmailField(blank=True, null=True, default=None,
                                      verbose_name=_('Contact email'))
    config = JSONField(blank=True, null=True, default=None,
                       verbose_name=_('Config'))
    ad_config = models.TextField(blank=True, null=True, default=None,
                                 verbose_name=_('AD config'))

    objects = SiteSettingsQuerySet.as_manager()

    class Meta:
        """Meta class."""

        verbose_name = _('Site setting')
        verbose_name_plural = _('Site settings')

    def __str__(self):
        return f'ID: "{self.id}". Site: "{self.subdomain}"'

    @property
    def published_features(self):
        return self.feature_set.filter(sitefeature__site_settings=self,
                                       sitefeature__published=True)

    @property
    def published_sitefeatures(self):
        return self.sitefeature_set.filter(published=True)

    @property
    def site_url(self):
        return methods.site_url(schema=settings.SCHEMA_URI,
                                subdomain=self.subdomain,
                                domain=settings.SITE_DOMAIN_URI)


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

    slug = models.CharField(max_length=255, unique=True)
    site_settings = models.ManyToManyField(SiteSettings, through='SiteFeature')

    class Meta:
        """Meta class."""
        verbose_name = _('Feature')
        verbose_name_plural = _('Features')

    def __str__(self):
        return f'{self.slug}'


class SiteFeatureQuerySet(models.QuerySet):
    """Extended queryset for SiteFeature model."""

    def published(self, switcher=True):
        return self.filter(published=switcher)


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

    site_settings = models.ForeignKey(SiteSettings, on_delete=models.CASCADE)
    feature = models.ForeignKey(Feature, on_delete=models.PROTECT)
    published = models.BooleanField(default=False, verbose_name=_('Published'))
    main = models.BooleanField(default=False, verbose_name=_('Main'))

    objects = SiteFeatureQuerySet.as_manager()

    class Meta:
        """Meta class."""

        verbose_name = _('Site feature')
        verbose_name_plural = _('Site features')
        unique_together = ('site_settings', 'feature')


class Award(TranslatedFieldsMixin, models.Model):
    """Award model."""
    award_type = models.ForeignKey('main.AwardType', on_delete=models.CASCADE)
    title = TJSONField(
        _('title'), null=True, blank=True,
        default=None, help_text='{"en-GB":"some text"}')
    vintage_year = models.CharField(_('vintage year'), max_length=255, default='')

    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = generic.GenericForeignKey('content_type', 'object_id')

    def __str__(self):
        title = 'None'
        lang = TranslationSettings.get_solo().default_language
        if self.title and lang in self.title:
            title = self.title[lang]
        return f'id:{self.id}-{title}'


class AwardType(models.Model):
    """AwardType model."""
    country = models.ForeignKey(
        'location.Country', verbose_name=_('country'), on_delete=models.CASCADE)
    name = models.CharField(_('name'), max_length=255)

    def __str__(self):
        return self.name


class MetaDataCategory(models.Model):
    """MetaData category model."""

    country = models.ForeignKey(
        'location.Country', null=True, default=None, on_delete=models.CASCADE)
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    public = models.BooleanField()


class MetaData(TranslatedFieldsMixin, models.Model):
    """MetaData model."""
    label = TJSONField(
        _('label'), null=True, blank=True,
        default=None, help_text='{"en-GB":"some text"}')
    category = models.ForeignKey(
        MetaDataCategory, verbose_name=_('category'), on_delete=models.CASCADE)

    class Meta:
        verbose_name = _('metadata')
        verbose_name_plural = _('metadata')

    def __str__(self):
        label = 'None'
        lang = TranslationSettings.get_solo().default_language
        if self.label and lang in self.label:
            label = self.label[lang]
        return f'id:{self.id}-{label}'


class MetaDataContentQuerySet(ContentTypeQuerySetMixin):
    """QuerySets for MetaDataContent model."""


class MetaDataContent(models.Model):
    """MetaDataContent model."""
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = generic.GenericForeignKey('content_type', 'object_id')
    metadata = models.ForeignKey(MetaData, on_delete=models.CASCADE)

    objects = MetaDataContentQuerySet.as_manager()


class Currency(models.Model):
    """Currency model."""
    name = models.CharField(_('name'), max_length=50)

    class Meta:
        verbose_name = _('currency')
        verbose_name_plural = _('currencies')

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


class CarouselQuerySet(models.QuerySet):
    """Carousel QuerySet."""


class Carousel(models.Model):
    """Carousel model."""
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = generic.GenericForeignKey('content_type', 'object_id')

    objects = CarouselQuerySet.as_manager()

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

    @property
    def name(self):
        # Check if Generic obj has name or title
        if hasattr(self.content_object, 'name'):
            return self.content_object.name
        if hasattr(self.content_object, 'title'):
            return self.content_object.title_translated

    @property
    def awards(self):
        if hasattr(self.content_object, 'awards'):
            return self.content_object.awards

    @property
    def toque_number(self):
        if hasattr(self.content_object, 'toque_number'):
            return self.content_object.toque_number

    @property
    def public_mark(self):
        if hasattr(self.content_object, 'public_mark'):
            return self.content_object.public_mark

    @property
    def image(self):
        # Check if Generic obj has an image
        if not hasattr(self.content_object.image, 'url'):
            # Check if Generic obj has a FK to gallery
            return self.content_object.image.image.url
        return self.content_object.image.url

    @property
    def model_name(self):
        return self.content_object.__class__.__name__