# -*- coding: utf-8 -*-
from django.db import models
from django.utils.translation import ugettext_lazy as _
from utils.mixins.base import BaseMixin
from rh.models import Usuario
from django.core.exceptions import ValidationError
import math
import sys

# Create your models here.
class ConfigSala(BaseMixin):
    class Meta:
        verbose_name=u'Configuração da Sala'
        verbose_name_plural=u'Configurações da Sala'
        #abstract = True
    #usuario = models.ForeignKey(Usuario, related_name='usuario_sala')
    descricao = models.CharField(default=u'Configuração das Salas H1', max_length=100)
    #2GB de dados
    limite_dados = models.CharField(null=True, default='2149580800', max_length=20)
    #100MB de Mensagem
    limite_mensagem = models.CharField(null=True, default='104857600', max_length=20)
    limite_usuario = models.IntegerField(default=2)
    limite_maximo_unitario = models.CharField(null=True, default='104857600', max_length=20) #100 MB

    def __unicode__(self):
        return self.descricao

    #--- Definição Singleton ---#

    def save(self, *args, **kwargs):
        #self.definir_capacidade_dados()
        #self.definir_capacidade_mensagem()
        #self.definir_capacidade_usuarios()

        self.__class__.objects.exclude(id=self.id).delete()
        super(ConfigSala, self).save(*args, **kwargs)

    @classmethod
    def load(cls):
        try:
            return cls.objects.get()
        except cls.DoesNotExist:
            return cls()
    #---  ---#

    #Nao usado - pode ser implementado futuramente

    @staticmethod
    def definir_capacidade_dados():
        self = ConfigSala.objects.get()
        capacidade = self.limite_dados
        try:
            #todas_salas = Salas.objects.filter(usuarios__id__exact=self.usuario)
            todas_salas = Sala.objects.all()
            if not todas_salas:
                raise ValidationError(u"Não possivel alterar a capacidade maxima de dados das salas")
            else:
                for sala in todas_salas:
                    sala.limite_dados = str(capacidade)
                    sala.save()
        except Exception, e:
            raise ValidationError(u"Não possivel alterar a capacidade maxima de dados das salas")

    @staticmethod
    def definir_capacidade_mensagem():
        self = ConfigSala.objects.get()
        capacidade = self.limite_mensagem
        try:
            #todas_salas = Salas.objects.filter(usuarios__id__exact=self.usuario)
            todas_salas = Sala.objects.all()
            if not todas_salas:
                raise ValidationError(u"Não possivel alterar a capacidade maxima de mensagem das salas")
            else:
                for sala in todas_salas:
                    sala.limite_mensagem = str(capacidade)
                    sala.save()
        except Exception, e:
            raise ValidationError(u"Não possivel alterar a capacidade maxima de mensagem das salas")

    @staticmethod
    def definir_capacidade_usuarios():
        self = ConfigSala.objects.get()
        capacidade = self.limite_usuario
        try:
            #todas_salas = Salas.objects.filter(usuarios__id__exact=self.usuario)
            todas_salas = Sala.objects.all()
            if not todas_salas:
                raise ValidationError(u"Não possivel alterar a capacidade maxima de usuarios das salas")
            else:
                for sala in todas_salas:
                    sala.limite_usuario = str(capacidade)
                    sala.save()
        except Exception, e:
            raise ValidationError(u"Não possivel alterar a capacidade maxima de usuarios das salas")

    @staticmethod
    def definir_limite_maximo_unitario():
        self = ConfigSala.objects.get()
        capacidade = self.limite_usuario
        try:
            #todas_salas = Salas.objects.filter(usuarios__id__exact=self.usuario)
            todas_salas = Sala.objects.all()
            if not todas_salas:
                raise ValidationError(u"Não possivel alterar a capacidade maxima de um anexo unitario")
            else:
                for sala in todas_salas:
                    sala.limite_maximo_unitario = str(capacidade)
                    sala.save()
        except Exception, e:
            raise ValidationError(u"Não possivel alterar a capacidade maxima de um anexo unitario")

class Sala(BaseMixin):
    class Meta:
        verbose_name = 'Sala'
        verbose_name_plural = 'Salas'
        #unique_together = ('tutor','aluno')
    descricao = models.CharField(max_length=50, verbose_name=u'Nome da Sala')
    usuarios = models.ManyToManyField(Usuario, related_name='chat_sala')
    limite_dados = models.CharField(null=True, default='1000000000', max_length=20)
    total_dados = models.CharField(null=True, default=0, max_length=20)
    limite_mensagem = models.CharField(null=True, default='1000000000', max_length=20)
    total_mensagem = models.CharField(null=True, default=0, max_length=20)
    limite_usuario = models.IntegerField(default=2)
    limite_maximo_unitario = models.CharField(null=True, default='104857600', max_length=20) #100 MB

    @staticmethod
    def converte_tipos(numero_bytes):
        total_dados = int(numero_bytes) / 1024
        if (total_dados == 0):
            if (numero_bytes):
                return '{0} B'.format(numero_bytes)
            else:
                return '0 B'
        sigla = ("KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
        i = int(math.floor(math.log(total_dados,1024)))
        p = math.pow(1024,i)
        s = round(total_dados/p,2)
        return '%s %s' % (s,sigla[i])

    @staticmethod
    def total_geral_consumido_formatado():
        salas = Sala.objects.all()
        total_anexo = 0
        if salas:
            for sala in salas:
                total_anexo = total_anexo + int(sala.total_dados) + int(sala.total_mensagem)
            return Sala.converte_tipos(str(total_anexo))
        else:
            return "0 B"

    @staticmethod
    def total_geral_consumido_bytes():
        salas = Sala.objects.all()
        total_anexo = 0
        if salas:
            for sala in salas:
                total_anexo = total_anexo + int(sala.total_dados) + int(sala.total_mensagem)
            return total_anexo
        else:
            return "0"

    @staticmethod
    def total_geral_anexo_consumido_formatado():
        salas = Sala.objects.all()
        total_anexo = 0
        if salas:
            for sala in salas:
                total_anexo = total_anexo + int(sala.total_dados)
            return Sala.converte_tipos(str(total_anexo))
        else:
            return "0 B"

    @staticmethod
    def total_geral_anexo_consumido_bytes():
        salas = Sala.objects.all()
        total_anexo = 0
        if salas:
            for sala in salas:
                total_anexo = total_anexo + int(sala.total_dados)
            return total_anexo
        else:
            return "0"

    @staticmethod
    def total_geral_mensagem_consumido_formatado():
        salas = Sala.objects.all()
        total_mensagem = 0
        if salas:
            for sala in salas:
                total_mensagem = total_mensagem + int(sala.total_mensagem)
            return Sala.converte_tipos(str(total_mensagem))
        else:
            return "0 B"

    @staticmethod
    def total_geral_mensagem_consumido_bytes():
        salas = Sala.objects.all()
        total_mensagem = 0
        if salas:
            for sala in salas:
                total_mensagem = total_mensagem + int(sala.total_mensagem)
            return total_mensagem
        else:
            return "0"

    @property
    def capacidade_atual_mensagem(self):
        return Sala.converte_tipos(self.total_mensagem)

    @property
    def capacidade_maxima_mensagem(self):
        return Sala.converte_tipos(self.limite_mensagem)

    @property
    def capacidade_atual_anexo(self):
        return Sala.converte_tipos(self.total_dados)

    @property
    def capacidade_maxima_anexo(self):
        return Sala.converte_tipos(self.limite_dados)

    @property
    def capacidade_maxima_sala(self):
        total = int(self.limite_dados) + int(self.limite_mensagem)
        return Sala.converte_tipos(str(total))

    @property
    def capacidade_atual_sala(self):
        total = int(self.total_dados) + int(self.total_mensagem)
        return Sala.converte_tipos(str(total))

    def __unicode__(self):
        #return "{0}-{1}-{2}".format(self.tutor.first_name, self.aluno.first_name, self.id)
        #return "%04d%04d%04d" % (self.tutor.id, self.aluno.id, self.id)
        return self.descricao
    '''
    def save(self, *args, **kwargs):
        if not self.descricao:
            self.descricao = "Sala do Tutor: {0} para aluno: {1}".format(self.tutor.first_name, self.aluno.first_name)
        super(Sala, self).save(*args, **kwargs)
    '''
    '''
    def pode_inserir_usuario(self):
        if self.usuarios.all().count() < self.limite_usuario:
            return True
        else:
            return False

    def inserir_usuario(self):
        if self.pode_inserir_usuario():
            for usuario in self.usuarios.all():
                self.usuarios.add(usuario)
        else:
            raise ValidationError(u"Sala atingiu o numero máximo de usuários")
    '''
    '''
    def save(self, *args, **kwargs):
        #Como o dado é um singleton não há necessidade de filtro

        if self.id:
            self.inserir_usuario()
        super(Sala, self).save(*args, **kwargs)
    '''
class Anexo(BaseMixin):
    class Meta:
        verbose_name = 'Anexo'
        verbose_name_plural = 'Anexos'
    descricao = models.TextField(max_length=100)
    anexo = models.FileField(upload_to='uploads/anexo/file/')
    sala = models.ForeignKey(Sala,related_name='anexo_sala')
    usuario = models.ForeignKey(Usuario, related_name='anexo_usuario')

    def __unicode__(self):
        return "Anexo de {0}".format(self.usuario)

    def get_absolute_url(self):
        return '%d'%self.id

    def limite_anexo_unitario(self):
        if self.anexo:
            if int(self.anexo.size) > int(self.sala.limite_maximo_unitario): #100mb
                return True
            else:
                return False

    def atingiu_capacidade_maxima_anexo(self):
        if self.anexo:
            atual = int(self.sala.total_dados) + self.anexo.size
            limite_dados = int(self.sala.limite_dados)
            if self.sala.limite_dados:
                metade = 100 * atual/int(self.sala.limite_dados)
                '''
                if metade >= 50:
                    #Implementar o envio de email para o usuario
                    pass
                '''
            if atual > limite_dados:
                return True
            else:
                return False
        else:
            return False

    def save(self, *args, **kwargs):
        print '1'
        print self.limite_anexo_unitario()
        print self.atingiu_capacidade_maxima_anexo()
        if self.limite_anexo_unitario():
            print '2'
            raise ValidationError(u"Esse anexo ultrapassa 100 MB")
        elif self.atingiu_capacidade_maxima_anexo():
            print '3'
            raise ValidationError(u"Usuário antingiu a capacidade maxima uploads para esta sala")
        else:
            print '4'
            super(Anexo, self).save(*args, **kwargs)

class Mensagem(BaseMixin):
    class Meta:
        verbose_name = 'Mensagem'
        verbose_name_plural = 'Mensagens'
    usuario = models.ForeignKey(Usuario, related_name='usuario')
    descricao = models.TextField(max_length=1200, verbose_name=u'Mensagem')
    sala = models.ForeignKey(Sala,related_name='sala')
    #anexo = models.FileField(blank=True, null=True)
    favorito = models.BooleanField(default=False)
    denuncia = models.BooleanField(default=False)

    # def limite_anexo_unitario(self):
    #     if self.anexo:
    #         if self.anexo.size > self.sala.limite_maximo_unitario: #100mb
    #             return True
    #         else:
    #             return False

    def __unicode__(self):
        return u"{0}".format(self.usuario.first_name)

        # return self.usuario.first_name

    def pode_enviar_mensagem(self):
        #Verifica se o usuario que esta postando a mensagem é um Tutor ou Aluno
        valida = False
        for usuario in self.sala.usuarios.all():
            if self.usuario == usuario:
                valida = True
        return valida

    def possui_conteudo_mensagem(self):
        if self.descricao:
            return True
        else:
            return False

    def setar_mensagem_denuncia(self):
        self.denuncia = True
        self.save()

    def remover_mensagem_denuncia(self):
        self.denuncia = False
        self.save()

    def setar_mensagem_favorito(self):
        self.favorito = True
        self.save()

    def remover_mensagem_favorito(self):
        self.favorito = False
        self.save()

    def atingiu_capacidade_mensagem(self):
        atual = int(self.sala.total_mensagem) + sys.getsizeof(self.descricao)
        if self.sala.limite_mensagem:

            metade = 100 * atual/int(self.sala.limite_mensagem)
            '''
            if metade >= 50:
                #Implementar o envio de email para o usuario
                pass
            '''
            if metade >= 100:
                return True
        if atual > self.sala.limite_mensagem:

            #Implementar a solicitacao de criacao de um novo chat
            return True
        else:

            return False

    # def atingiu_capacidade_maxima_anexo(self):
    #     if self.anexo:
    #         atual = int(self.sala.total_dados) + self.anexo.size
    #         limite_dados = int(self.sala.limite_dados)
    #         if self.sala.limite_dados:
    #             metade = 100 * atual/int(self.sala.limite_dados)
    #             '''
    #             if metade >= 50:
    #                 #Implementar o envio de email para o usuario
    #                 pass
    #             '''
    #         if atual > limite_dados:
    #             return True
    #         else:
    #             return False
    #     else:
    #         return False

    def save(self, *args, **kwargs):
        if not self.pode_enviar_mensagem():
            raise ValidationError(u"Usuario não pode adicionar mensagem nessa sala")
        elif not self.possui_conteudo_mensagem():
            raise ValidationError(u"Usuário não pode enviar uma mensagem vazia")
        # elif self.limite_anexo_unitario():
        #     raise ValidationError(u"Esse anexo ultrapassa 100 MB")
        # elif self.atingiu_capacidade_maxima_anexo():
        #     raise ValidationError(u"Usuário antingiu a capacidade maxima uploads para esta sala")
        elif self.atingiu_capacidade_mensagem():
            raise ValidationError(u"Usuário antingiu a capacidade maxima mensagens para esta sala")
        else:
            super(Mensagem, self).save(*args, **kwargs)

# SIGNALS
from django.db.models import signals
def mensagem_post_save(signal, instance, sender, created, **kwargs):
    if created:
        sala = instance.sala
        # if instance.anexo:
        #     sala.total_dados = str(int(sala.total_dados) + instance.anexo.size)
        sala.total_mensagem = str(int(sala.total_mensagem) + sys.getsizeof(instance.descricao))
        sala.save()

signals.post_save.connect(mensagem_post_save, sender=Mensagem)

def anexo_post_save(signal, instance, sender, created, **kwargs):
    if created:
        if instance.anexo:
            sala = instance.sala
            sala.total_dados = str(int(sala.total_dados) + instance.anexo.size)
        sala.save()

signals.post_save.connect(anexo_post_save, sender=Anexo)

def sala_post_save(signal, instance, sender, created, **kwargs):
    if created:
        try:
            config = ConfigSala.objects.get()
            instance.limite_dados = config.limite_dados
            instance.limite_mensagem = config.limite_mensagem
            instance.limite_usuario = config.limite_usuario
            instance.limite_maximo_unitario = config.limite_maximo_unitario
            instance.save()
        except Exception, e:
            raise ValidationError(u"Não existe uma configuração de sala")

signals.post_save.connect(sala_post_save, sender=Sala)