# -*- coding: utf-8 -*-
from bitfield import BitField
from django.db import models
from django.db.models import F, Q
from django.db.models.signals import post_save
from django.utils.translation import ugettext as _
from functions.custom_fields import EnumField
from functions.signal_handlers import post_save_handler
from hvad.models import TranslatableModel, TranslatedFields, TranslationManager

CURENCIES = ('', 'USD', 'RUB', 'EUR')


class Service(TranslatableModel):

    url = models.SlugField(unique=True)
    currency = EnumField(values=CURENCIES, blank=True, default='USD')
    price = models.PositiveIntegerField(blank=True, null=True)
    params = models.CharField(max_length=255, blank=True)
    template = models.CharField(max_length=255, blank=True)
    type = BitField(flags=['expo', 'conference'])
    #translated fields
    translations = TranslatedFields(
        name = models.CharField(max_length=50),
        main_title = models.TextField(),
        description = models.TextField(),
        advantage = models.TextField(blank=True),
        #meta fields
        title = models.CharField(max_length=255, blank=True),
        descriptions = models.CharField(max_length=255, blank=True),
        keywords = models.CharField(max_length=255, blank=True),
    )
    sort = models.PositiveIntegerField(default=0, db_index=True)
    main_page = models.PositiveIntegerField(default=0, db_index=True)
    meta_id = models.IntegerField(null=True)

    def __unicode__(self):
        return self.lazy_translation_getter('name', self.pk)

    def get_form(self):
        pass

    def get_permanent_url(self):
        return '/service/%s/'%self.url

    def get_price(self):
        pr = self.price

    def get_currency_html(self):
        cur = self.currency
        currency_codes = {'EUR':'€', 'USD':'$', 'RUB':'руб.'}
        code = currency_codes.get(cur)
        if code:
            return code
        return cur


post_save.connect(post_save_handler, sender=Service)

class AbstractOrder(models.Model):
    person = models.ForeignKey('accounts.User')
    phone = models.BigIntegerField()
    city = models.CharField(max_length=255, blank=True, default='')
    country = models.CharField(max_length=255, blank=True, default='')
    person_inf = models.CharField(max_length=255)
    price = models.IntegerField(blank=True, null=True)
    currency = EnumField(values=CURENCIES, blank=True)
    event = models.CharField(max_length=255, blank=True, null=True)
    exposition = models.ForeignKey('exposition.Exposition', null=True)
    conference = models.ForeignKey('conference.Conference', null=True)
    seminar = models.ForeignKey('seminar.Seminar', null=True)
    created = models.DateTimeField(auto_now_add=True)
    viewed = models.DateTimeField(null=True, blank=True)
    #
    referer1 = models.TextField(
        verbose_name=_(u'Первый переход'), null=True, blank=True)
    referer2 = models.TextField(
        verbose_name=_(u'Второй переход'), null=True, blank=True)
    utm_source1 = models.TextField(null=True, blank=True)
    utm_medium1 = models.TextField(null=True, blank=True)
    utm_campaign1 = models.TextField(null=True, blank=True)
    utm_source2 = models.TextField(null=True, blank=True)
    utm_medium2 = models.TextField(null=True, blank=True)
    utm_campaign2 = models.TextField(null=True, blank=True)
    search1 = models.TextField(null=True, blank=True)
    search2 = models.TextField(null=True, blank=True)
    search3 = models.TextField(null=True, blank=True)


    class Meta:
        abstract = True
        ordering = ['-created']



class Catalog(AbstractOrder):
    pass

class BuildStand(AbstractOrder):
    pass

class Tickets(AbstractOrder):
    days = models.SmallIntegerField()
    people = models.SmallIntegerField()

class Remote(AbstractOrder):
    interested_participants = models.TextField(blank=True)
    additional = models.CharField(max_length=255, blank=True)


class Participation(AbstractOrder):
    area = models.IntegerField(null=True)
    area_type = models.CharField(max_length=255)
    company_inf = models.TextField()

class Translation(AbstractOrder):
    days = models.IntegerField(null=True,blank=True)
    hours = models.IntegerField(null=True, blank=True)
    fr = models.DateField(blank=True)
    to = models.DateField(blank=True)
    languages = models.TextField(blank=True)
    themes = models.TextField(blank=True)


class Visit(AbstractOrder):
    fr = models.DateField()
    to = models.DateField()
    people = models.IntegerField(blank=True, null=True)
    hotel_additional = models.TextField(blank=True)
    city_from = models.CharField(max_length=255, blank=True)
    hotel_stars = models.CharField(max_length=30, blank=True)
    hotel_location = models.CharField(max_length=255, blank=True)
    hotel_budget = models.CharField(max_length=255, blank=True)
    hotel_budget_add = models.CharField(max_length=255, blank=True)

    avia_tickets = models.BooleanField()
    avia_type = models.CharField(max_length=255)
    visa = models.BooleanField()
    transfer = models.BooleanField()
    event_tickets = models.BooleanField()
    #
    translator = models.BooleanField()
    languages = models.CharField(max_length=255, blank=True)
    themes = models.CharField(max_length=255, blank=True)
    tr_employment_days = models.PositiveIntegerField(blank=True, null=True)
    tr_employment_hours = models.PositiveIntegerField(blank=True, null=True)

    excursion = models.BooleanField()
    notes = models.TextField(blank=True)

ADVERTYSE_TYPES = ((u'Рекламировать участника', _(u'Рекламировать участника')),
                  (u'Баннерная реклама', _(u'Баннерная реклама')),
                  (u'Приоритетное размещение событий в каталоге', _(u'Приоритетное размещение событий в каталоге')),
                  (u'Персональная визитка Вашей компании', _(u'Персональная визитка Вашей компании')))
class Advertising(AbstractOrder):
    type = models.CharField(max_length=255, blank=True, null=True)


class CallBack(models.Model):
    phone = models.CharField(max_length=30)
    person_inf = models.CharField(max_length=255)
    created = models.DateTimeField(auto_now_add=True)
    viewed = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ['-created']


class LinkedService(models.Model):
    service = models.ForeignKey(Service, blank=False)
    countries = models.ManyToManyField('country.Country', blank=True, verbose_name=_(u"Страны"))
    exclude_countries = models.BooleanField(default=False, verbose_name=_(u"Исключить страны"))
    expositions = models.ManyToManyField('exposition.Exposition', blank=True, verbose_name= _(u"Выставки"))
    conferences = models.ManyToManyField('conference.Conference', blank=True, verbose_name=_(u'Конференции'))
    exclude_expositions = models.ManyToManyField('exposition.Exposition', blank=True, verbose_name= _(u"Выставки"), related_name='show_%(class)s_set')
    exclude_conferences = models.ManyToManyField('conference.Conference', blank=True, verbose_name=_(u'Конференции'), related_name='show_%(class)s_set')

    def update_countries_flag(self):
        from country.models import Country
        if self.exclude_countries:
            'filter all countries except selected and set flag to true'
            Country.objects.language().exclude(id__in=[c.id for c in self.countries.all()]).update(services=F('services').bitor(getattr(Country.services, self.service.url)))
            'set another flags to false'
            Country.objects.language().filter(id__in=[c.id for c in self.countries.all()]).update(services=F('services').bitand(~getattr(Country.services, self.service.url)))
        else:
            'if not exclude, filter all selected countries and set flag to true'
            self.countries.update(services=F('services').bitor(getattr(Country.services, self.service.url)))
            Country.objects.exclude(id__in=[c.id for c in self.countries.all()]).update(services=F('services').bitand(~getattr(Country.services, self.service.url)))

    # def update_expositions_flag(self):
    #     from exposition.models import Exposition
    #     self.expositions.update(services=F('services').bitor(getattr(Exposition.services, self.service.url)))
    #     Exposition.objects.exclude(id__in=[c.id for c in self.expositions.all()]).update(services=F('services').bitand(~getattr(Exposition.services, self.service.url)))

    # def update_conferences_flag(self):
    #     from conference.models import Conference
    #     self.conferences.update(services=F('services').bitor(getattr(Conference.services, self.service.url)))
    #     Conference.objects.exclude(id__in=[c.id for c in self.conferences.all()]).update(services=F('services').bitand(~getattr(Conference.services, self.service.url)))

    def set_events_services(self):
        from exposition.models import Exposition
        from conference.models import Conference
        from country.models import Country

        exposition_on_ids = list(self.expositions.all().values_list('pk', flat=True))
        conference_on_ids = list(self.conferences.all().values_list('pk', flat=True))

        exposition_off_ids = list(self.exclude_expositions.all().values_list('pk', flat=True))
        conference_off_ids = list(self.exclude_conferences.all().values_list('pk', flat=True))

        countries_on_ids = list(self.countries.all().values_list('pk', flat=True))

        if self.exclude_countries:
            countries_on_ids = list(Country.objects.all().exclude(id__in=countries_on_ids).values_list('pk', flat=True))

        if self.service.type.expo:
            # включаем сервис для выставок
            expo_on_qs = Exposition.objects.filter(Q(country_id__in=countries_on_ids) | Q(pk__in=exposition_on_ids))\
                .exclude(pk__in=exposition_off_ids)
            expo_on_qs.update(services=F('services').bitor(getattr(Exposition.services, self.service.url)))

            # выключаем сервис во всех событиях, в которых мы его не включали
            Exposition.objects.exclude(pk__in=list(expo_on_qs.values_list('pk', flat=True)))\
                .update(services=F('services').bitand(~getattr(Exposition.services, self.service.url)))
        else:
            # выставки для данного события выключены
            Exposition.objects.all()\
                .update(services=F('services').bitand(~getattr(Exposition.services, self.service.url)))

        if self.service.type.conference:
            conf_on_qs = Conference.objects.filter(Q(country_id__in=countries_on_ids) | Q(pk__in=conference_on_ids))\
                .exclude(pk__in=conference_off_ids)
            conf_on_qs.update(services=F('services').bitor(getattr(Conference.services, self.service.url)))

            Conference.objects.exclude(pk__in=list(conf_on_qs.values_list('pk', flat=True)))\
                .update(services=F('services').bitand(~getattr(Conference.services, self.service.url)))
        else:
            # конференции для данного события выключены
            Conference.objects.all()\
                .update(services=F('services').bitand(~getattr(Conference.services, self.service.url)))

    def update_all_flags(self):
        self.update_countries_flag()
        self.set_events_services()
        # self.update_expositions_flag()
        # self.update_conferences_flag()

    def countries_count(self):
        if not self.exclude_countries:
            return self.countries.all().count()
        else:
            from country.models import Country
            all = Country.objects.filter().count()
            excluded = self.countries.all().count()
            return all - excluded

    def __unicode__(self):
        return u'Linked service for %s'%self.service.url