#-*- coding:utf-8 -*-

from django.db.models import *
from django.contrib.auth.models import User, Group
from django.core.validators import MinValueValidator, MaxValueValidator

from dictionary.models import Entry, Frame, Message, Lemma, Lemma_Status, Vocabulary
from semantics.models import SemanticFrame

MANAGER_GROUPS = (u'Gość', u'Leksykograf', u'Superleksykograf', u'Administrator', u'Gość+', u'Frazeolog')

def manager_groups():
  return Group.objects.filter(name__in=MANAGER_GROUPS)
  
class UserStats(Model):
    user = OneToOneField(User, related_name='user_stats')
    # oplaty za prace leksykograficzne
    lemma_real_history = ManyToManyField('RealizedLemma', db_table='zrealizowane_hasla',
                                         blank=True, null=True, related_name='user_stats')
    # oplaty za prace leksykograficzne
    phraseology_real_history = ManyToManyField('RealizedPhraseology', db_table='prace_frazeologiczne',
                                               blank=True, null=True, related_name='user_stats')
    # oplaty za prace leksykograficzne
    bind_phraseology_frames_history = ManyToManyField('RealizedPhraseologyBinding', db_table='powiazania_frazeologiczne',
                                               blank=True, null=True, related_name='user_stats')
    # oplaty za prace semantyczne
    semantics_real_history = ManyToManyField('RealizedSemantics', db_table='prace_semantyczne',
                                             blank=True, null=True, related_name='user_stats')
    # kwota uiszczona
    paid_cash = FloatField(db_column='kwota_uiszczona', default = 0.0)
    
    def __unicode__(self):
        return '%s' % (self.user) 
    
    def made_phraseologic_empty_entries_count(self):
        return self.phraseology_real_history.filter(status__type__sym_name='ready_f', 
                                                    paid=False, 
                                                    new_frames=0,
                                                    reused_frames=0).count()
                                                    
    def checked_phraseologic_empty_entries_count(self):
        return self.phraseology_real_history.filter(status__type__sym_name='checked_f', 
                                                    paid=False, 
                                                    corr_frames=0,
                                                    ncorr_frames=0,
                                                    bonus=False).count()
    
def can_modify_phraseology_only(user, phraseologic):
    return phraseologic and user.has_perm('dictionary.add_phraseologic_frames')
    
class RealizedLemma(Model):
    """Model representing realized and confirmed frames by user."""
    # wykonane haslo 
    lemma = ForeignKey(Lemma, db_column='wykonane_haslo', related_name='realized_lemmas')
    # wynagrodzenie za haslo
    cash = FloatField(db_column='wynagrodzenie', default = 0.0)
    # czy wykonanie hasla zostalo juz wynagrodzone
    paid = BooleanField(db_column='oplacono', default=False)
    # ta oplata zostala juz podliczona na pewnym etapie i nie nalezy zmieniac jej wartosci 
    counted = BooleanField(db_column='przeliczono', default=False)
    # czy oplata jest bonusem dla leksykografa 
    bonus = BooleanField(db_column='bonus', default=False)
    #wlasciwie wykonane schematy (wypelniane dla leksykografa)
    prop_frames = PositiveIntegerField(db_column='poprawne_ramki',
                                       default = 0)
    # niewlasciwie wykonane schematy (wypelniane dla leksykografa)
    wrong_frames = PositiveIntegerField(db_column='niepoprawne_ramki',
                                      default = 0)
    # poprawione schematy (wypelniane dla superleksykografa)
    corr_frames = PositiveIntegerField(db_column='poprawione_ramki',
                                       default = 0)
    # poprawione schematy (wypelniane dla superleksykografa)
    made_frames = PositiveIntegerField(db_column='wykonane_ramki',
                                       default = 0)
    # schematy niepoprawiane (wypelniane dla supeleksykografa)
    ncorr_frames = PositiveIntegerField(db_column='niepoprawione_ramki',
                                      default = 0)
    date = DateTimeField(auto_now_add=True, db_column='data_zmiany')
    # statusu hasla za przejscie do ktorego otrzymano oplate
    status = ForeignKey(Lemma_Status, related_name='realized_lemmas', 
                        blank=True, null=True)
    
    def __unicode__(self):
        return '%s: %f' % (self.lemma.entry, self.cash)

class RealizedPhraseology(Model):
    """Model representing realized phraseology work."""
    # wykonane haslo 
    lemma = ForeignKey(Lemma, db_column='haslo', related_name='realized_phraseology')
    # wynagrodzenie za haslo
    cash = FloatField(db_column='wynagrodzenie', default = 0.0)
    # czy praca zostala juz oplacona
    paid = BooleanField(db_column='oplacono', default=False)
    # ta oplata zostala juz podliczona na pewnym etapie i nie nalezy zmieniac jej wartosci 
    counted = BooleanField(db_column='przeliczono', default=False)
    # czy oplata jest bonusem 
    bonus = BooleanField(db_column='bonus', default=False)
    # stworzone nowe schematy frazeologiczne
    new_frames = PositiveIntegerField(db_column='nowe_ramki',
                                       default = 0)
    # schematy pochodzace z podpowiedzi lub juz wczesniej istniejace dla danego lematu
    reused_frames = PositiveIntegerField(db_column='ponownie_uzyte_ramki',
                                         default = 0)
    #wlasciwie wykonane schematy (wypelniane dla frazeologa)
    prop_frames = PositiveIntegerField(db_column='poprawne_ramki',
                                       default = 0)
    # niewlasciwie wykonane schematy (wypelniane dla frazeologa)
    wrong_frames = PositiveIntegerField(db_column='niepoprawne_ramki',
                                      default = 0)
    # poprawione schematy (wypelniane dla superfrazeologa)
    corr_frames = PositiveIntegerField(db_column='poprawione_ramki',
                                       default = 0)
    # schematy niepoprawiane (wypelniane dla superfrazeologa)
    ncorr_frames = PositiveIntegerField(db_column='niepoprawione_ramki',
                                      default = 0)
    # data podliczenia pracy
    date = DateTimeField(auto_now_add=True, db_column='data_zmiany')
    # statusu hasla za przejscie do ktorego otrzymano oplate
    status = ForeignKey(Lemma_Status, related_name='realized_phraseology', 
                        blank=True, null=True)
    
    def __unicode__(self):
        return '%s: %f' % (self.lemma.entry, self.cash)
  
class RealizedPhraseologyBinding(Model):
    """Model representing realized phraseology work."""
    # wykonane haslo
    main_entry = ForeignKey(Entry, db_column='glowne_haslo',
                            related_name='realized_phraseology_bindings__main')
    phraseologic_frame = ForeignKey(Frame, db_column='ramka_frazeologiczna', 
                                    related_name='realized_phraseology_bindings__binded')
    binded_entry = ForeignKey(Entry, db_column='przypisane_haslo',
                              related_name='realized_phraseology_bindings')
    cash = FloatField(db_column='wynagrodzenie', default = 0.0)
    # czy praca zostala juz oplacona
    paid = BooleanField(db_column='oplacono', default=False)
    # ta oplata zostala juz podliczona na pewnym etapie i nie nalezy zmieniac jej wartosci 
    counted = BooleanField(db_column='przeliczono', default=False)
    # data podliczenia pracy
    date = DateTimeField(auto_now_add=True, db_column='data_zmiany')
    
    def __unicode__(self):
        return u'%s: %f' % (self.phraseologic_frame, self.cash)

class UserSettings(Model):
  user = OneToOneField(User, related_name='user_settings')
  incremental_search = BooleanField(
    default=False,
    verbose_name=u'wyszukiwanie przyrostowe',
    help_text=u'Wyszukiwanie odbywa się automatycznie w miarę wpisywania '
              u'szukanego hasła. Sugerujemy wyłączenie w wypadku wolnego '
              u'połączenia internetowego.')
  filter_search = BooleanField(
    default=True,
    verbose_name=u'wyszukiwanie przez filtrowanie',
    help_text=u'Wyszukiwanie powoduje zawężenie listy haseł do pasujących '
              u'do zapytania.')
  notes_per_page = PositiveSmallIntegerField(default=40, 
                                             db_column='wiadomosci_na_strone',
                                             verbose_name=u'Notatki na stronę',
                                             help_text=u'Liczba notatek na stronę w skrzynce odbiorczej użytkownika.',
                                             validators=[
                                                MaxValueValidator(100),
                                                MinValueValidator(10)]
                                             )

  def has_new_messages(self):
    lemmas_new_msg = self.user.lemmas.filter(messages__new=True).filter(messages__private=False)
    if len(lemmas_new_msg) > 0:
      return True;
    return False; 

  def new_notes_number(self):
    new_notes = Message.objects.filter(recipient=self.user, private=False, new=True)   
    return len(new_notes) 

  def change_all_lemmas(self):
    return self.user.has_perm('dictionary.change_all_lemmas')

  def view_lemma(self):
    return self.user.has_perm('dictionary.view_lemma')

  def view_realizations(self):
    return self.user.has_perm('dictionary.view_realizations')

  def view_notes(self):
    return self.user.has_perm('dictionary.view_notes')

  def add_notes(self):
    return self.user.has_perm('dictionary.add_notes')

  def change_lemmas(self):
    return self.user.has_perm('dictionary.change_lemmas')

  def change_lemma_status(self):
    return self.user.has_perm('dictionary.change_lemma_status')

  def manages_vocabulary(self):
    return self.user.has_perm('dictionary.manage_vocabulary')

  def download_vocabulary(self):
    return self.user.has_perm('dictionary.download_vocabulary')

  def view_vocab_stats(self):
    return self.user.has_perm('dictionary.view_vocab_stats')

  def edit_semantic_frames(self):
    return self.user.has_perm('semantics.edit_frames')
  
  class Meta:
    permissions = (
      ('create_admin', u'Może nadawać dowolne role'),
    )
    
class GroupSettings(Model):
    """Group settings model."""
    group = OneToOneField(Group, related_name='group_settings')
    abort_statuses = ManyToManyField(Lemma_Status, blank=True,
                                     related_name='group_settings_abort')
    next_statuses = ManyToManyField(Lemma_Status, blank=True,
                                    related_name='group_settings_next')
    active_statuses = ManyToManyField(Lemma_Status, blank=True,
                                      related_name='group_settings_active')
    priority = PositiveIntegerField(db_column='priorytet')
    
    def __unicode__(self):
        return '%s' % self.group.name

class AnonymousUserProfile(Model):
    """Anonymous user settings."""
    user_template = ForeignKey(User, db_column='szablon_uzytkownika',
                               related_name='anonymous_user_settings')
    selected = BooleanField(db_column='wybrana', default=False)
    visible_statuses = ManyToManyField(Lemma_Status, blank=True,
                                       related_name='anonymous_user_profiles')
    
    def visible_vocabularies(self):
        if self.user_template.has_perm('dictionary.view_all_lemmas'):
            return Vocabulary.objects.all()
        else:
            return self.user_template.visible_vocabularies.all()
    
    def __unicode__(self):
        return unicode(self.user_template)
    
def get_anon_user():
    return AnonymousUserProfile.objects.get(selected=True).user_template

def get_anon_profile():
    return AnonymousUserProfile.objects.get(selected=True)

def filtering_mode(user):
    return user.usersettings.filter_search

class RealizedSemantics(Model):
    """Model representing realized semantic work."""
    # wykonane haslo 
    entry = ForeignKey(Entry, db_column='haslo', 
                       related_name='realized_semantics')
    # ramy semantyczne w momencie zapisu pracy
    frames = ManyToManyField(SemanticFrame, db_table='ramy_semantyczne',
                             blank=True, null=True, related_name='realized_semantics')
    # wynagrodzenie za haslo
    cash = FloatField(db_column='wynagrodzenie', default=0.0)
    # czy oplata jest bonusem dla semantyka 
    bonus = BooleanField(db_column='bonus', default=False)
    # wlasciwie wykonane ramki (wypelniane dla semantyka)
    prop_frames = PositiveIntegerField(db_column='poprawne_ramki',
                                       default=0)
    # czesciowo wlasciwie wykonane ramki (wypelniane dla semantyka) !NOWE
    part_prop_frames = PositiveIntegerField(db_column='czesciowo_poprawne_ramki',
                                            default=0)
    # niewlasciwie wykonane ramki (wypelniane dla semantyka)
    wrong_frames = PositiveIntegerField(db_column='niepoprawne_ramki',
                                        default=0)
    # dodane powiazania miedzy ramami i schematami !NOWE
    added_connections = PositiveIntegerField(db_column='dodane_powiazania',
                                             default=0)
    # wykonane ramki (wypelniane dla semantyka)
    made_frames = PositiveIntegerField(db_column='wykonane_ramki',
                                       default=0)
    # poprawione ramki (wypelniane dla supersemantyka)
    corr_frames = PositiveIntegerField(db_column='poprawione_ramki',
                                       default=0)
    # czesciowo poprawione ramki (wypelniane dla supersemantyka) !NOWE
    part_corr_frames = PositiveIntegerField(db_column='czesciowo_poprawione_ramki',
                                            default=0)
    # ramki niepoprawiane (wypelniane dla supersemantyka)
    ncorr_frames = PositiveIntegerField(db_column='niepoprawione_ramki',
                                      default=0)
    date = DateTimeField(auto_now_add=True, db_column='data_zmiany')
    # statusu hasla za przejscie do ktorego otrzymano oplate
    status = ForeignKey(Lemma_Status, related_name='realized_semantics', 
                        blank=True, null=True)
    
    def __unicode__(self):
        return '%s: %f' % (self.entry.name, self.cash)
