"""Webapp app models."""

from django.db import models
from django.utils import timezone
from datetime import timedelta
from django.contrib.auth.models import User
from webapp.utils import month_from_now
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import User
from auditlog.registry import auditlog
from phonenumber_field.modelfields import PhoneNumberField
from django.contrib.postgres.fields import JSONField

import logging


VERBOSE_NAME = _('Webapp')


class Tag(models.Model):
    """Model for tag."""

    slug = models.SlugField(primary_key=True)
    name = models.CharField(max_length=127)
    icon = models.ImageField()

    class Meta:
        verbose_name = _('Tag')
        verbose_name_plural = _('Tags')

    def __str__(self):
        return _('Tag: {}').format(self.slug)


class BaseFeed(models.Model):
    """Model containing something showing on some info feed."""

    tags = models.ManyToManyField(Tag, related_name="feeds", blank=True)
    visible = models.BooleanField(default=True)
    title = models.CharField(max_length=255)
    description = models.CharField(max_length=255)
    content = models.TextField()


class Feed(BaseFeed):
    """Model representing feed."""

    publish_time = models.DateTimeField(default=timezone.now)
    autohide = models.DateTimeField(default=month_from_now)

    def __str__(self):
        return _('Feed: {}').format(self.title)

    class Meta:
        verbose_name = _('Feed')
        verbose_name_plural = _('Feeds')


class Event(BaseFeed):
    """Model for event."""

    start_time = models.DateTimeField(default=timezone.now)
    end_time = models.DateTimeField(default=timezone.now)
    registration = models.ForeignKey(
        'Registration', on_delete=models.CASCADE, null=True)

    def __str__(self):
        return _('Event: {}').format(self.title)

    class Meta:
        verbose_name = _('Event')
        verbose_name_plural = _('Events')


class Registration(models.Model):
    """Model for event registration."""

    name = models.CharField(max_length=255)
    email = models.EmailField()
    options = JSONField()

    def __str__(self):
        return _('Registration: {}').format(self.name)

    class Meta:
        verbose_name = _('Registration')
        verbose_name_plural = _('Registrations')


class BaseRole(models.Model):
    """Base model for occupations/roles."""

    CATEGORIES = (
        ('corporate', _('Corporate affairs')),
        ('freshman', _('Freshmen')),
        ('international', _('International')),
        ('external', _('External affairs')),
        ('media', _('Media')),
        ('tech', _('Technology')),
        ('wellbeing', _('Wellbeing')),
        ('elepaja', _('Elepaja')),
        ('ceremonies', _('Ceremonies')),
        ('culture', _('Culture')),
        ('studies', _('Studies')),
        ('sosso', _('Sössö magazine')),
        ('alumni', _('Alumni relations')),
        ('others', _('Others')),
    )

    name = models.CharField(_('Name'), max_length=255)
    is_board = models.BooleanField(_('Board member'))
    category = models.CharField(_('Category'), choices=CATEGORIES, default='others', max_length=255)

    def __str__(self):
        n = self.name.capitalize()
        return '{} ({})'.format(n, _('board member')) if self.is_board else n


class PresetRole(BaseRole):
    """Model representing a preset occupation in the guild."""

    description = models.TextField(_('Description'))


class PresetKaehmyRole(PresetRole):
    """Model for kaehmy role."""

    class Meta:
        verbose_name = _('Preset kaehmy role')
        verbose_name_plural = _('Preset kaehmy roles')


class CustomKaehmyRole(BaseRole):
    """Model representing a user-specified custom occupation."""

    class Meta:
        verbose_name = _('Custom kaehmy role')
        verbose_name_plural = _('Custom kaehmy roles')


class MessageParent(models.Model):

    name = models.CharField(_('Name'), max_length=255, default='')
    email = models.EmailField(_('Email'), default='')
    timestamp = models.DateTimeField(_('Timestamp'), default=timezone.now)

    def __str__(self):
        return 'Message parent #{}'.format(self.id)


class KaehmyMessage(MessageParent):
    """
    Model representing a kaehmymessage.

    Every message relates to certain kaehmyform or parent message.
    """

    class Meta:
        verbose_name = _('Kaehmykommentti')
        verbose_name_plural = _('Kaehmykommentit')

    message = models.TextField(_('Message'))
    parent = models.ForeignKey('MessageParent', related_name='messages')


class KaehmyForm(MessageParent):
    """
    Model representing a form for kaehmy.

    Allows user to choose from existing roles or to create custom ones.
    """
    YEAR_CHOICES = (
        (1, '1'),
        (2, '2'),
        (3, '3'),
        (4, '4'),
        (5, 'N'),
    )

    class Meta:
        verbose_name = _('Kaehmylomake')
        verbose_name_plural = _('Kaehmylomakkeet')

    phone_number = models.CharField(
        _('Phone number'), max_length=10, default="")
    year = models.IntegerField(_('Year'), choices=YEAR_CHOICES)
    text = models.TextField(_('Text'), default="", max_length=300)
    custom_role_name = models.CharField(
        _('Custom role name'), max_length=255, blank=True)
    custom_role_is_board = models.BooleanField(
        _('Board member'), blank=True)
    custom_roles = models.ManyToManyField(
        'CustomKaehmyRole', related_name='forms', blank=True)
    preset_roles = models.ManyToManyField(
        'PresetKaehmyRole', related_name='forms', blank=True)

    def __str__(self):
        """Return model info."""
        return _('Kaehmy application: {}').format(self.name)

    def comment_count(self):
        """Count comments for kaehmy."""
        total = 0

        def recurse(message):
            count = 0
            for msg in message.messages.all():
                count += recurse(msg)

            return count + 1

        for message in self.messages.all():
            total += recurse(message)

        return total

    def board_roles(self):
        presets = [r.name.capitalize() for r in self.preset_roles.filter(is_board=True)]
        customs = [r.name.capitalize() for r in self.custom_roles.filter(is_board=True)]
        combined = presets + customs
        return _('Board: {}').format(', '.join(combined)) if len(combined) > 0 else ''

    def official_roles(self):
        presets = [r.name.capitalize() for r in self.preset_roles.filter(is_board=False)]
        customs = [r.name.capitalize() for r in self.custom_roles.filter(is_board=False)]
        combined = presets + customs
        return _('Official: {}').format(', '.join(combined)) if len(combined) > 0 else ''

    def all_roles(self):
        presets = [r.name.capitalize() for r in self.preset_roles.all()]
        customs = [r.name.capitalize() for r in self.custom_roles.all()]
        combined = presets + customs
        return ', '.join(combined) if len(combined) > 0 else ''

    def has_any_board_role(self):
        return self.preset_roles.filter(is_board=True).exists() or self.custom_roles.filter(is_board=True)


class Committee(models.Model):
    """ 
    Committee model
    
    Has many Roles found under variable roles 
    """

    class Meta:
        """Meta class for Committee class."""

        verbose_name = _('Committee')
        verbose_name_plural = _('Committees')

    def __str__(self):
        return _('Committee: {}').format(self.name)

    name = models.CharField(max_length=255)


class Role(PresetRole):
    """
    Model for Role.

    Model representing an active or historical occupation
    in an official's history.
    """

    class Meta:
        """Meta class for Role model."""

        verbose_name = _('Role')
        verbose_name_plural = _('Roles')

    start_date = models.DateField(_('Start date'))
    end_date = models.DateField(_('End date'))
    official = models.ForeignKey('Official', related_name='roles')
    committee = models.ForeignKey('Committee', related_name='roles', on_delete=models.SET_NULL, null=True)

class Official(User):
    """Model representing a guild official."""

    class Meta:
        """Meta class for Official class."""

        verbose_name = _('Official')
        verbose_name_plural = _('Officials')

    phone_number = PhoneNumberField(_('Phone number'))


# Ohlhafv
class OhlhafvChallenge(models.Model):
    """Model containing all info about ohlhafv challenge."""

    SERIES_CHOICES = (
        ('0.33 L', '0.33 L'),
        ('0.5 L', '0.5 L'),
        ('1.0 L', '1.0 L'),
    )

    challenger = models.CharField(max_length=255)
    victim = models.CharField(max_length=255)
    challenger_email = models.EmailField()
    victim_email = models.EmailField()
    series = models.CharField(choices=SERIES_CHOICES, max_length=10)
    message = models.TextField()


# Telegram channel entry for Kaehmys
class TelegramChannel(models.Model):
    """Model containing the channel id of a Telegram chat"""

    class Meta:
        verbose_name = _('Telegram channel')
        verbose_name_plural = _('Telegram channels')

    name = models.CharField(max_length=255)
    channel_id = models.CharField(max_length=255, unique=True)

    def __str__(self):
        return 'Telegram channel: "{}"'.format(self.name)


auditlog.register(Tag)
auditlog.register(Feed)
auditlog.register(Event)
auditlog.register(PresetRole)
auditlog.register(Role)
auditlog.register(Official)