""" ScannerJammer models module
"""

from django.db import models
from django.contrib import auth
from django.contrib import admin


class SJSettingsModel(models.Model):
    """ ScannerJammer abstract settings model
    """
    settings = models.TextField(blank=True)

    class Meta:
        abstract = True

    def freeze_settings(self, settings_dict):
        """ Serialize settings dictionary into settings text field
        """
        self.settings = '\n'.join('%s\t%s' % (str(key), str(value)) for key, value in settings_dict.iteritems())

    def thaw_settings(self):
        """ Deserialize settings text field into settings dictionary
        """
        settings_dict = {}
        if self.settings:
            for line in self.settings.split('\n'):
                row = line.split('\t')
                if len(row) == 2:
                    settings_dict[row[0]] = row[1]
        return settings_dict

    def merge_settings(self, settings_dict):
        """ Merge current setting with settings dictionary
        """
        self.freeze_settings(self.thaw_settings().update(settings_dict))

class SJUserProfile(SJSettingsModel):
    """ ScannerJammer user model
    """
    user = models.OneToOneField(auth.models.User)
    nickname = models.CharField(max_length=32, blank=True)
    score = models.IntegerField(default=0, blank=True)
    access = models.IntegerField(default=0, blank=True)
    bio = models.TextField(blank=True)
    # Backward compatibility fields
    username = models.CharField(max_length=32, blank=True) # see User.username
    password = models.CharField(max_length=32, blank=True) # see User.password (store password hash)
    joindate = models.DateField(blank=True, verbose_name="Join Date") # see User.date_joined
    seendate = models.DateField(blank=True, verbose_name="Seen Date") # see User.last_login

    class Meta:
        verbose_name = "SJ User Profile"

    def __unicode__(self):
        if self.nickname:
            return "%s (%s)" % (self.username or self.user.username, self.nickname)
        return "%s" % (self.username or self.user.username)

class SJRoom(SJSettingsModel):
    """ ScannerJammer room model
    """
    name = models.CharField(max_length=32)
    date = models.DateField()
    private = models.BooleanField(default=False)
    tokbox = models.CharField(max_length=64)

    class Meta:
        verbose_name = "SJ Room"

    def __unicode__(self):
        return self.name

class SJSiteModel(models.Model):
    """ ScannerJammer abstract site base model
    """
    user = models.ForeignKey(auth.models.User)
    room = models.ForeignKey(SJRoom)
    date = models.DateField()
    url = models.URLField(blank=True, verbose_name="URL")

    class Meta:
        abstract = True

    def __unicode__(self):
        return self.url

class SJBackground(SJSiteModel):
    """ ScannerJammer background model
    """
    class Meta:
        verbose_name = "SJ Background"

class SJURL(SJSiteModel):
    """ ScannerJammer url model
    """
    likes = models.IntegerField(default=0)

    class Meta:
        verbose_name = "SJ URL"

class SJVideo(SJSiteModel):
    """ ScannerJammer video model
    """
    title = models.CharField(max_length=100)
    likes = models.IntegerField(default=0)
    views = models.IntegerField(default=0)
    removed = models.BooleanField(default=False)
    thumbnail = models.CharField(max_length=64)

    class Meta:
        verbose_name = "SJ Video"

    def __unicode__(self):
        return self.title

class SJChat(SJSiteModel):
    """ ScannerJammer chat model
    """
    msg = models.TextField(verbose_name="Message")

    class Meta:
        verbose_name = "SJ Chat"

class SJLike(models.Model):
    """ ScannerJammer like model
    """
    user = models.ForeignKey(auth.models.User)
    video = models.ForeignKey(SJVideo)
    url = models.ForeignKey(SJURL, verbose_name="URL")
    date = models.DateField()

    class Meta:
        verbose_name = "SJ Like"

class SJSearchLog(models.Model):
    """ SannerJammer search log
    """
    date = models.DateField()
    query = models.CharField(max_length=255)
    matches = models.IntegerField(default=0)

    class Meta:
        verbose_name = "SJ Search Log"

    def __unicode__(self):
        return '%s "%s" matched %d' % (self.date, self.query, self.matches)

admin.site.register(SJUserProfile)
admin.site.register(SJRoom)
admin.site.register(SJBackground)
admin.site.register(SJURL)
admin.site.register(SJVideo)
admin.site.register(SJChat)
admin.site.register(SJLike)
admin.site.register(SJSearchLog)