class Right:
  def __init__(self, row):
    self.user_id = int(row['user_id'])
    self.target_type = str(row['target_type'])
    self.target_id = int(row['target_id'])
    self.mode = str(row['mode'])


class MyRights:
  def __init__(self, internal, model):
    self.internal = internal
    self.model = model
    self.user_id = self.internal.user_id
    self.user = None
    
  def get_user():
    if self.user_id:
      assert self.user
      return None
    if not self.user:
      self.model.users.get_by_id(self.user_id)
      assert self.user
    return self.user
    
  def issuperuser(self):
    return self.internal.issuperuser()

  def isallowed(self, target_type, target_id, mode):
    return self.internal.isallowed(target_type, target_id, mode)

  def isallowed_root(self, mode):
    return self.internal.isallowed_root(mode)


class InternalRights:
  TABLE = 'rights'
  ROOT = 'root'

  def __init__(self, connection, user_id = 0, superuser = False):
    assert(type(user_id) is int)
    assert(type(superuser) is bool)
    self.connection = connection
    self.user_id = user_id
    self.superuser = superuser
    
  def issuperuser(self):
    if self.superuser:
      return True
    if self.user_id and self.get(self.user_id, self.ROOT, 0, self.ROOT):
      return True
    
  def isallowed(self, target_type, target_id, mode):
    if self.issuperuser():
      return True
    if self.user_id and self.get(self.user_id, target_type, target_id, mode):
      return True
    if self.get(0, target_type, target_id, mode):
      return True
    return False

  def build_where(self, user_id = None, target_type = None, target_id = None, mode = None):
    where = list()
    args = list()
    if not user_id is None:
      assert(type(user_id) is int)
      where.append("`user_id`=%d")
      args.append(user_id)
    if not target_type is None:
      assert(type(target_type) is str)
      where.append("`target_type`=%s")
      args.append(target_type)
    if not target_id is None:
      assert(type(target_id) is int)
      where.append("`target_id`=%d")
      args.append(target_id)
    if not mode is None:
      assert(type(mode) is str)
      where.append("`mode`=%s")
      args.append(mode)
    if not where:
      return '', list()
    return ' WHERE ' + ' AND '.join(where), args
    
  def get_list(self, user_id = None, target_type = None, target_id = None, mode = None):
    where, args = self.build_where(user_id, target_type, target_id, mode)
    rows = self.connection.query_dict('SELECT * FROM %T' + where, self.TABLE, *args)
    rights = list()
    for row in rows:
      rights.append( Right(row) )
    return rights
  
  def delete_list(self, user_id = None, target_type = None, target_id = None, mode = None):
    where, args = self.build_where(user_id, target_type, target_id, mode)
    self.connection.execute('DELETE FROM %T' + where, self.TABLE, *args)
    self.connection.cache.reset(self.TABLE)

  def reset_cache(self, user_id, target_type, target_id, mode):
    assert(type(user_id) is int)
    assert(type(target_type) is str)
    assert(type(target_id) is int)
    assert(type(mode) is str)
    self.connection.cache.reset(
      self.TABLE,
      { 'user_id': user_id,
        'target_type': target_type,
        'target_id': target_id,
        'mode': mode })
  
  def get(self, user_id, target_type, target_id, mode):
    assert(type(user_id) is int)
    assert(type(target_type) is str)
    assert(type(target_id) is int)
    assert(type(mode) is str)
    rows = self.connection.cache.select(
      self.TABLE,
      { 'user_id': user_id,
        'target_type': target_type,
        'target_id': target_id,
        'mode': mode })
    return bool(rows)

  def set(self, user_id, target_type, target_id, mode, allowed):
    assert(type(user_id) is int)
    assert(type(target_type) is str)
    assert(type(target_id) is int)
    assert(type(mode) is str)
    if not allowed:
      self.connection.execute(
        '''DELETE FROM %T WHERE
                `user_id`=%d
            AND `target_type`=%s
            AND `target_id`=%d
            AND `mode`=%s''',
        self.TABLE, user_id, target_type, target_id, mode )
      self.reset_cache(user_id, target_type, target_id, mode)
    elif not self.get(user_id, target_type, target_id, mode):
      self.connection.execute(
        '''INSERT INTO %T SET
                `user_id`=%d,
                `target_type`=%s,
                `target_id`=%d,
                `mode`=%s''',
        self.TABLE, user_id, target_type, target_id, mode )
      self.reset_cache(user_id, target_type, target_id, mode)
      
  def isallowed_root(self, mode):
    return self.isallowed(self.ROOT, 0, mode)
  def get_list_root(self, user_id = None, mode = None):
    return self.get_list(user_id, self.ROOT, 0, mode)
  def delete_list_root(self, user_id = None, mode = None):
    return self.delete_list_root(user_id, self.ROOT, 0, mode)
  def get_root(self, user_id, mode):
    return self.get(user_id, self.ROOT, 0, mode)
  def set_root(self, user_id, mode, allowed):
    return self.set(user_id, self.ROOT, 0, mode, allowed)

  def get_superuser(self, user_id):
    return self.get_root(user_id, self.ROOT)
  def set_superuser(self, user_id, allowed):
    return self.set_root(user_id, self.ROOT, allowed)