import exception

from model.base import ModelItemBase, ModelManagerBase

from model.users import User

class Sslcert(ModelItemBase):

  def __init__(self, sslcerts, row, user = None):

    super().__init__(sslcerts, row)

    self.id = int(row['id'])

    self.user_id = int(row['user_id'])

    self.data = str(row['data'])

    assert(not user or (type(user) is User and user.id == self.user_id))

    self.user = user

  def get_user(self):

    if self.user == None:

      self.user = self.model.users.get_by_id(self.user_id)

    assert(self.user)

    assert(self.user.id == self.user_id)

    return self.user

  def reset_cache(self):

    self.manager.reset_cache(self.id, self.data)

  def can_delete(self):

    return self.user_id == self.rights.user_id or self.rights.issuperuser()

  def delete(self):

    if self.can_delete():

      self.connection.execute(

        'DELETE FROM %T WHERE `id`=%d',

        self.table(), self.id )

      self.reset_cache()

    else:

      raise exception.ModelDeny()

class Sslcerts(ModelManagerBase):

  def table(self):

    return 'sslcerts'

  def itemtype(self):

    return Sslcert

  def reset_cache(self, id, data):

    super().reset_cache(id)

    self.connection.cache.reset(self.table(), {'data': data})

  def extract_data(self, data):

    prefix = '-----BEGIN CERTIFICATE-----'

    suffix = '-----END CERTIFICATE-----'

    data = str(data)

    i0 = data.find(prefix)

    i1 = data.find(suffix)

    if i0 >= 0 and i1 >= 0 and i0 + len(prefix) <= i1:

      data = data[i0 + len(prefix):i1]

    data = ''.join(data.split())

    return data

  def verify_data(self, data):

    b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='

    if not data or not type(data) is str:

      return False

    for c in data:

      if c not in b64chars:

        return False

    return True

  def can_read(self, user):

    assert(type(user) is User)

    return user.id == self.rights.user_id \

        or self.rights.issuperuser()

  def can_create(self, user):

    assert(type(user) is User)

    return user.id == self.rights.user_id or self.rights.issuperuser()

  def create(self, user, data):

    if not self.can_create(user):

      raise exception.ModelDeny()

    if not self.verify_data(data):

      raise exception.ModelWrongData(self.t('Bad SSL certificate data'))

    if self.get_by_data(data):

      raise exception.ModelWrongData(self.t('SSL Certificate is not unique'))

    self.connection.execute(

      'INSERT INTO %T SET `user_id`=%d, `data`=%s',

      self.table(), user.id, data )

    id = self.connection.insert_id()

    self.reset_cache(id, data)

    return self.get_by_id(id, user)

  def get_by_id(self, id, user = None):

    assert(type(id) is int)

    row = self.connection.cache.row(self.table(), id)

    if not row:

      return None

    if not user:

      user = self.model.users.get_by_id(row['user_id'])

      if not user:

        return None

    if not self.can_read(user):

      return None

    return Sslcert(self, row, user)

  def get_by_data(self, data):

    assert(type(data) is str)

    rows = self.connection.cache.select(self.table(), {'data': data})

    if not rows or len(rows) > 1:

      return None

    return Sslcert(self, rows[0])

  def get_list(self, user):

    assert(type(user) is User)

    result = list()

    if not self.can_read(user):

      return result

    rows = self.connection.query_dict('SELECT * FROM %T WHERE `user_id`=%d ORDER BY `data`', self.table(), user.id)

    for row in rows:

      result.append(Sslcert(self, row, user))

    return result