# encoding=utf-8
import random
import string
from courses.models import Vertex, Course
from storage.models import Storage

from django.contrib.auth.base_user import AbstractBaseUser, BaseUserManager
from django.contrib.auth.models import PermissionsMixin

from django.db import models

from django.conf import settings
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
from lms.global_decorators import transaction_decorator
from django.contrib.auth.models import Group


class Invite(models.Model):
    owner = models.OneToOneField(to=settings.AUTH_USER_MODEL)
    hash = models.CharField(
        max_length=15, default=''.join(random.choice(string.ascii_letters) for x in range(15))
    )
    date = models.DateTimeField(null=True, blank=True)


class Account(models.Model):
    GENDER_CHOICES = {
        (0, 'undefined'),
        (1, 'male'),
        (2, 'female'),
    }
    b_day = models.DateField(blank=True, null=True)
    city = models.CharField(max_length=63, null=True)
    gender = models.SmallIntegerField(choices=GENDER_CHOICES, default=0)
    owner = models.OneToOneField(to=settings.AUTH_USER_MODEL)
    photo = models.ImageField(null=True, blank=True, default='user/photo/default_avatar.png', upload_to='user/photo/')
    phone = models.CharField(max_length=15, blank=True)

    def __str__(self):
        return self.owner.email


class CustomUserManager(BaseUserManager):
    use_in_migrations = True

    def get_or_create(self, email=None, password=None, **kwargs):
        if not email:
            raise ValueError('email not set')

        if password:
            kwargs["hash_password"] = password

        kwargs['email'] = self.normalize_email(email)

        try:
            return self.get(email=kwargs['email'])

        except self.model.DoesNotExist:
            return self._create_user(**kwargs)

    @transaction_decorator
    def _create_user(self, email, password=None, is_staff=False, is_superuser=False, role_list=[],
                     is_active=False, first_name='Guest', hash_password=None, is_send=False,
                     date_joined=timezone.now(), last_login=timezone.now(), **extra_fields):

        if not email:
            raise ValueError('The given email must be set')

        email = self.normalize_email(email)

        user = self.model(email=email, is_staff=is_staff, is_active=is_active, first_name=first_name,
                          is_superuser=is_superuser, date_joined=date_joined, last_login=last_login, **extra_fields)

        if not password:
            password = ''.join(random.choice(string.ascii_letters) for x in range(8))

        if not hash_password:
            user.set_password(password)
        else:
            user.password = hash_password

        user.save(using=self._db)
        Account.objects.create(owner=user)

        for group in role_list:
            user.groups.add(group)

        if is_send:
            pass
            Invite.objects.create(owner=user)
            # Должна идти отбивка
        return user

    def create_user(self, email, password, **extra_fields):
        return self._create_user(email=email, password=password, **extra_fields)

    def create_superuser(self, email, password):
        return self._create_user(email=email, password=password, is_superuser=True, is_staff=True, is_active=True)

    def create_student(self, email, password, **extra_fields):
        user = self.create_user(email=email, password=password, is_send=True, **extra_fields)
        group = Group.objects.get(name='students')
        user.groups.add(group)
        return user


class User(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(_('email address'), unique=True)
    first_name = models.CharField(_('first name'), max_length=63, blank=True, default='Guest')
    last_name = models.CharField(_('last name'), max_length=63, blank=True)
    date_joined = models.DateTimeField(_('date joined'))
    is_staff = models.BooleanField(verbose_name='флаг персонала', default=False,
                                   help_text='Определяет разрешение пользователя на вход в административную часть.')
    is_active = models.BooleanField(verbose_name='активен', default=False,
                                    help_text='Определяет активен ли пользователь в системе. Снимите флаг, '
                                              'вместо удаления пользователя.')
    is_blocked = models.BooleanField(verbose_name='заблочен', default=False,
                                    help_text='Определяет заблокирован ли пользователь. Поставьте флаг, '
                                              'если знаете, что это нехороший человек.')

    objects = CustomUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = []

    def get_full_name(self):
        full_name = '%s %s' % (self.first_name, self.last_name)
        return full_name.strip()

    def get_short_name(self):
        return self.first_name

    class Meta:
        verbose_name = _('user')
        verbose_name_plural = _('users')


class ActiveObject(models.Model):
    user = models.ForeignKey(to=settings.AUTH_USER_MODEL, verbose_name=u'Студент')
    course = models.ForeignKey(to=Course, verbose_name=u'Курс')
    active_obj = models.ForeignKey(to=Vertex, verbose_name=u'Активный объект', blank=True, null=True)
    success = models.BooleanField(default=False, verbose_name=u'Завершён ли курс')

    def __str__(self):
        return u'%s %s %s' % (
            self.user.email,
            ('завершил курс' if self.success else 'в процессе изучения курса'),
            self.course.title,
        )

    def is_access(self, vertex):
        return not vertex.is_more(self.active_obj)


class ExtraPrivilege(models.Model):
    user = models.ForeignKey(to=settings.AUTH_USER_MODEL, verbose_name=u'Правообладатель')
    is_done = models.BooleanField(default=False, verbose_name=u'Выполнено?')
    subject = models.ForeignKey(to=Vertex, verbose_name=u'Объект')