from peewee import CharField, DateTimeField, BooleanField, ForeignKeyField
from peewee import create_model_tables
from datetime import datetime, timedelta
from app import db, pad
from padlite import APIException

class User(db.Model):
    username = CharField()
    api_id = CharField(null=True)
    email = CharField()
    last_login = DateTimeField(default=datetime.now)
    active = BooleanField(default=True)
    admin = BooleanField(default=False)

    def __str__(self):
        return self.username

    def __unicode__(self):
        return self.username

class Group(db.Model):
    name = CharField(unique=True)
    api_id = CharField(null=True)
    public = BooleanField(default=False)
    browsable = BooleanField(default=False)

    def __str__(self):
        return self.name

    def __unicode__(self):
        return self.name

    def save(self, force_insert=False, only=None):
        if self.id is None or force_insert:
            self.api_id = pad.createGroup()

        super(Group, self).save(force_insert=force_insert, only=only)

    def delete_instance(self, **kwargs):
        if self.api_id is not None:
            pad.deleteGroup(self.api_id)
            self.api_id = None
            self.save()
        super(Group, self).delete_instance(**kwargs)

class Member(db.Model):
    group = ForeignKeyField(Group, related_name='members')
    user = ForeignKeyField(User, related_name='groups')
    manager = BooleanField(default=False)
    admin = BooleanField(default=False)

    def __str__(self):
        return "%s member of %s" % (self.user.username, self.group.name)

    def __unicode__(self):
        return "%s member of %s" % (self.user.username, self.group.name)

class Session(db.Model):
    api_id = CharField(null=True)
    user = ForeignKeyField(User, related_name='sessions')
    group = ForeignKeyField(Group, related_name='sessions')
    uuid = CharField()
    valid_until = DateTimeField(null=True)

    def save(self, force_insert=False, only=None):
        if self.id is None or force_insert:
            if self.group.api_id is None:
                self.group.api_id = pad.createGroup()
            self.valid_until = datetime.now() + timedelta(hours=4)
            self.api_id = pad.createSession(self.group.api_id, self.user.api_id,
                                            self.valid_until.strftime("%s"))
        super(Session, self).save(force_insert=force_insert, only=only)

    def delete_instance(self, **kwargs):
        if self.api_id is not None:
            try:
                pad.deleteSession(self.api_id)
            except APIException as e:
                # we want to ignore code 1 = sessionID does not exist
                if e.code != 1:
                    raise
            self.api_id = None
            self.save()
        super(Session, self).delete_instance(**kwargs)

    def is_valid(self):
        if self.api_id is None:
            return True

        if self.valid_until is not None:
            if datetime.now() + timedelta(minutes=30) < self.valid_until:
                return True

        return False

class Pad(db.Model):
    name = CharField(verbose_name='pad name')
    api_id = CharField(null=True)
    group = ForeignKeyField(Group, related_name='pads')
    created = DateTimeField(default=datetime.now)
    public = BooleanField(default=False)
    password = CharField(null=True)

    def __str__(self):
        return self.name

    def __unicode__(self):
        return self.name

    def save(self, force_insert=False, only=None):
        if self.id is None or force_insert:
            if self.group.api_id is None:
                self.group.api_id = pad.createGroup()
            self.api_id = pad.createGroupPad(self.group.api_id, self.name, 'testing')

        if self.api_id is not None:
            pad.setPublicStatus(self.api_id, self.public)
            pad.setPassword(self.api_id, self.password)
        super(Pad, self).save(force_insert=force_insert, only=only)

    def delete_instance(self, **kwargs):
        if self.api_id is not None:
            pad.deletePad(self.api_id)
            self.api_id = None
            self.save()
        super(Pad, self).delete_instance(**kwargs)

def create_tables():
    create_model_tables([User, Group, Member, Session, Pad], fail_silently = True)