# encoding=utf-8
import random
import string
import json

from celery.result import AsyncResult
from django.contrib.contenttypes.models import ContentType
from django_celery_results.models import TaskResult

from courses.models import Vertex, Course
from storage.models import Storage
from django.core.mail import send_mail

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

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 journals.models import Journal, Thread, ACTION_CHOICES


class Invite(models.Model):
    owner = models.OneToOneField(to=settings.AUTH_USER_MODEL)
    hash = models.CharField(max_length=15)
    date = models.DateTimeField(null=True, blank=True)

    class Meta:
        verbose_name = 'Приглошение в систему'
        verbose_name_plural = 'Приглошения в систему'


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, blank=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, null=True, blank=True)

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

    class Meta:
        verbose_name = 'Дополнительная информация о пользователе'
        verbose_name_plural = 'Дополнительная информация о пользователе'


class CustomUserManager(BaseUserManager):
    use_in_migrations = True

    def get_or_create(self, email=None, password=None, **kwargs):
        if not email:
            raise ValueError('The given email must be 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=None,
                     is_active=False, first_name='Guest', hash_password=None, is_send=False,
                     date_joined=timezone.now(), last_login=timezone.now(), **extra_fields):

        if role_list is None:
            role_list = []

        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)

        if role_list:
            for group in role_list:
                user.groups.add(Group.objects.get(name=group))

        if is_send and password:
            invite = Invite.objects.create(owner=user,
                                           hash=''.join(random.choice(string.ascii_letters) for x in range(15)))
            body = {
                "subject": 'Спасибо за регистрацию',
                "message": '''
                        Вы были успешны зарегистрированны на портале go.skillbox.ru
                        ваш пароль %s
                        для подтверждения регистрации перейдите по ссылке
                        https://go.skillbox.ru/api/v1/users/registration/?hash=%s''' %(password, invite.hash),
                "from_email": 'robo@skillbox.ru',
                "recipient_list": [user.email],
            }

            send_mail(
                **body
            )
        return user

    def create_user(self, email, **extra_fields):
        return self._create_user(email=email, **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, **extra_fields):
        return self.create_user(email=email, role_list=['students'], is_send=True, **extra_fields)


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 = _('Пользователь')
        verbose_name_plural = _('Пользователи')


class Progress(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 Meta:
        verbose_name = 'Прогресс пользователя'
        verbose_name_plural = 'Прогресс пользователя'


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'Объект')

    class Meta:
        verbose_name = 'Доп право'
        verbose_name_plural = 'Доп права пользователя'