import datetime

from django.core.exceptions import ValidationError

from django.core.urlresolvers import reverse

from django.db import models

from django.db.models.signals import post_init, post_save

from django.utils.translation import ugettext_lazy as _

from django.contrib.auth.models import User

from symposion.conference.models import Conference

from symposion.sponsorship.managers import SponsorManager

class SponsorLevel(models.Model):

    conference = models.ForeignKey(Conference, verbose_name=_("conference"))

    name = models.CharField(_("name"), max_length=100)

    order = models.IntegerField(_("order"), default=0)

    cost = models.PositiveIntegerField(_("cost"))

    description = models.TextField(_("description"), blank=True, help_text=_("This is private."))

    class Meta:

        ordering = ["conference", "order"]

        verbose_name = _("sponsor level")

        verbose_name_plural = _("sponsor levels")

    def __unicode__(self):

        return self.name

    def sponsors(self):

        return self.sponsor_set.filter(active=True).order_by("added")

class Sponsor(models.Model):

    applicant = models.ForeignKey(User, related_name="sponsorships", verbose_name=_("applicant"),

                                  null=True)

    name = models.CharField(_("Sponsor Name"), max_length=100)

    external_url = models.URLField(_("external URL"))

    annotation = models.TextField(_("annotation"), blank=True)

    contact_name = models.CharField(_("Contact Name"), max_length=100)

    contact_email = models.EmailField(_(u"Contact Email"))

    level = models.ForeignKey(SponsorLevel, verbose_name=_("level"))

    added = models.DateTimeField(_("added"), default=datetime.datetime.now)

    active = models.BooleanField(_("active"), default=False)

    # Denormalization (this assumes only one logo)

            pass

        allowed_benefits = []

        if level:

            for benefit_level in level.benefit_levels.all():

                # Create all needed benefits if they don't exist already

                sponsor_benefit, created = SponsorBenefit.objects.get_or_create(

                    sponsor=self, benefit=benefit_level.benefit)

                # and set to default limits for this level.

                sponsor_benefit.max_words = benefit_level.max_words

                sponsor_benefit.other_limits = benefit_level.other_limits

                # and set to active

                sponsor_benefit.active = True

                # @@@ We don't call sponsor_benefit.clean here. This means

                # that if the sponsorship level for a sponsor is adjusted

                # downwards, an existing too-long text entry can remain,

                # and won't raise a validation error until it's next

                # edited.

                sponsor_benefit.save()

                allowed_benefits.append(sponsor_benefit.pk)

        # Any remaining sponsor benefits that don't normally belong to

        # this level are set to inactive

        self.sponsor_benefits.exclude(pk__in=allowed_benefits)\

            .update(active=False, max_words=None, other_limits="")

    def send_coordinator_emails(self):

        pass  # @@@ should this just be done centrally?

def _store_initial_level(sender, instance, **kwargs):

    if instance:

        instance._initial_level_id = instance.level_id

post_init.connect(_store_initial_level, sender=Sponsor)

def _check_level_change(sender, instance, created, **kwargs):

    if instance and (created or instance.level_id != instance._initial_level_id):

        instance.reset_benefits()

post_save.connect(_check_level_change, sender=Sponsor)

BENEFIT_TYPE_CHOICES = [

    ("text", "Text"),

    ("file", "File"),

    ("weblogo", "Web Logo"),

]

class Benefit(models.Model):

    name = models.CharField(_("name"), max_length=100)

    description = models.TextField(_("description"), blank=True)

    def __unicode__(self):

        return self.name

class BenefitLevel(models.Model):

    benefit = models.ForeignKey(Benefit, related_name="benefit_levels", verbose_name=_("benefit"))

    level = models.ForeignKey(SponsorLevel, related_name="benefit_levels", verbose_name=_("level"))

    # default limits for this benefit at given level

    max_words = models.PositiveIntegerField(_("max words"), blank=True, null=True)

    other_limits = models.CharField(_("other limits"), max_length=200, blank=True)

    class Meta:

        ordering = ["level"]

    def __unicode__(self):

        return u"%s - %s" % (self.level, self.benefit)

class SponsorBenefit(models.Model):

    sponsor = models.ForeignKey(Sponsor, related_name="sponsor_benefits", verbose_name=_("sponsor"))

    benefit = models.ForeignKey(Benefit, related_name="sponsor_benefits", verbose_name=_("benefit"))

    active = models.BooleanField(default=True)

    # Limits: will initially be set to defaults from corresponding BenefitLevel

    max_words = models.PositiveIntegerField(_("max words"), blank=True, null=True)

    other_limits = models.CharField(_("other limits"), max_length=200, blank=True)

    # Data: zero or one of these fields will be used, depending on the

    # type of the Benefit (text, file, or simple)

    text = models.TextField(_("text"), blank=True)

    upload = models.FileField(_("file"), blank=True, upload_to="sponsor_files")

    class Meta:

        ordering = ["-active"]

    def __unicode__(self):

        return u"%s - %s" % (self.sponsor, self.benefit)

    def clean(self):

        num_words = len(self.text.split())

        if self.max_words and num_words > self.max_words:

            raise ValidationError(

                "Sponsorship level only allows for %s words, you provided %d." % (

                    self.max_words, num_words))

from django import template

from symposion.conference.models import current_conference

from symposion.sponsorship.models import Sponsor, SponsorLevel

register = template.Library()

class SponsorsNode(template.Node):

    @classmethod

    def handle_token(cls, parser, token):

        bits = token.split_contents()

        if len(bits) == 3 and bits[1] == "as":

            return cls(bits[2])

        elif len(bits) == 4 and bits[2] == "as":

            return cls(bits[3], bits[1])

        else:

            raise template.TemplateSyntaxError("%r takes 'as var' or 'level as var'" % bits[0])

    def __init__(self, context_var, level=None):

        if level:

            self.level = template.Variable(level)

        else:

            self.level = None

        self.context_var = context_var

    def render(self, context):

        conference = current_conference()

        if self.level:

            level = self.level.resolve(context)

            queryset = Sponsor.objects.filter(

                level__conference=conference, level__name__iexact=level, active=True)\

                .order_by("added")

        else:

            queryset = Sponsor.objects.filter(level__conference=conference, active=True)\

                .order_by("level__order", "added")

        context[self.context_var] = queryset

        return u""

class SponsorLevelNode(template.Node):

    @classmethod

    def handle_token(cls, parser, token):

        bits = token.split_contents()

        if len(bits) == 3 and bits[1] == "as":

            return cls(bits[2])

        else:

            raise template.TemplateSyntaxError("%r takes 'as var'" % bits[0])

    def __init__(self, context_var):

        self.context_var = context_var

    def render(self, context):

        conference = current_conference()

        context[self.context_var] = SponsorLevel.objects.filter(conference=conference)

        return u""

@register.tag

def sponsors(parser, token):

    """

    {% sponsors as all_sponsors %}

    or

    {% sponsors "gold" as gold_sponsors %}

    """

    return SponsorsNode.handle_token(parser, token)

@register.tag

def sponsor_levels(parser, token):

    """

    {% sponsor_levels as levels %}

    """

    return SponsorLevelNode.handle_token(parser, token)