import hashlib

import exception

from model.base import ModelItemBase, ModelManagerBase


class User(ModelItemBase):
  def __init__(self, users, row):
    super().__init__(users, row)
    
    self.id = int(row['id'])
    self.login = str(row['login'])
    self.name = str(row['name'])
    self.superuser_ready = False
    self.superuser = None
    if self.id == self.rights.user_id:
      self._password = str(row['password'])

  def get_superuser(self):
    if not self.superuser_ready:
      self.superuser = None
      if self.id == self.rights.user_id or self.rights.issuperuser():
        self.superuser = self.rights.get_superuser(self.id)
      self.superuser_ready = True
    return self.superuser

  def reset_cache(self):
    self.manager.reset_cache(self.id, self.login)
    
  def change_password(self, newpassword, oldpassword = None):
    if self.id == self.rights.user_id:
      if oldpassword is None:
        raise exception.ModelDeny()
      oldhash = self.manager.gen_password_hash(self.id, oldpassword)
      if oldhash != self._password:
        raise exception.ModelWrongData(self.t('Password incorrect'))
    if self.id != self.rights.user_id and not self.rights.issuperuser():
      raise exception.ModelDeny()
    hash = self.manager.gen_password_hash(self.id, newpassword)
    self.connection.execute('UPDATE %T SET `password`=%s WHERE `id`=%d', self.table(), hash, self.id)
    self.reset_cache()
    self.server.sessions.delete_by_user_id(self.id)

  def can_update(self):
    return self.id == self.rights.user_id or self.rights.issuperuser()
  
  def update(self, name):
    if self.can_update():
      self.connection.execute('UPDATE %T SET `name`=%s WHERE `id`=%d', self.table(), name, self.id)
      self.reset_cache()
    else:
      raise exception.ModelDeny()

  def can_delete(self):
    return self.server.config['users']['selfdelete'] if self.id == self.rights.user_id else self.rights.issuperuser()

  def delete(self, password = None):
    if self.can_delete():
      if self.id == self.rights.user_id:
        if password is None:
          raise exception.ModelDeny()
        hash = self.manager.gen_password_hash(self.id, str(password))
        if hash != self._password:
          raise exception.ModelWrongData(self.t('Password incorrect'))

      repositories = self.model.repositories.get_list(self)
      for repo in repositories:
        repo.delete()

      self.rights.delete_list(user_id = self.id)
      self.rights.delete_list(target_type = self.table(), target_id = self.id)
      self.connection.execute('DELETE FROM %T WHERE `id`=%d', self.table(), self.id)
      self.reset_cache()
      self.server.sessions.delete_by_user_id(self.id)
    else:
      raise exception.ModelDeny()
    
  def set_superuser(self, allowed):
    if id != self.rights.user_id and self.rights.issuperuser():
      self.rights.set_superuser(self.id, allowed)
    else:
      raise exception.ModelDeny()


class Users(ModelManagerBase):
  def __init__(self, model):
    super().__init__(model)

  def table(self):
    return 'users'
    
  def itemtype(self):
    return User
    
  def reset_cache(self, id, login):
    super().reset_cache(id)
    self.connection.cache.reset(self.table(), {'login': login})

  def gen_password_hash(self, id, password):
    salt = self.server.config['users']['salt']
    return hashlib.sha512(bytes(str(id) + '|' + str(salt) + '|' + password, 'utf8')).hexdigest()

  def verify_login(self, login):
    return self.model.verify_identifier(login)

  def can_create(self):
    return self.rights.issuperuser() or self.server.config['users']['selfcreate']

  def create(self, login, password, name):
    if not self.can_create():
      raise exception.ModelDeny()
    if not self.verify_login(login):
      raise exception.ModelWrongData(self.t('Login incorrect'))
    if self.get_by_login(login):
      raise exception.ModelWrongData(self.t('Login already exists'))
    self.connection.execute("INSERT INTO %T SET `login`=%s, `password`='', `name`=%s", self.table(), login, name)
    id = self.connection.insert_id()
    hash = self.gen_password_hash(int(id), password)
    self.connection.execute('UPDATE %T SET `password`=%s WHERE `id`=%d', self.table(), hash, id)
    self.reset_cache(id, login)
    return self.get_by_id(id)

  def check_password(self, login, password):
    assert(type(login) is str)
    assert(type(password) is str)
    rows = self.connection.cache.select(self.table(), {'login': login})
    if not rows or len(rows) > 1:
      return False
    row = rows[0]
    id = int(row['id'])
    if str(row['password']) == self.gen_password_hash(id, password):
      return id
    return 0

  def get_by_id(self, id):
    assert(type(id) is int)
    row = None
    if id == self.rights.user_id or self.rights.issuperuser() or self.server.config['users']['showprofile']:
      row = self.connection.cache.row(self.table(), id)
    if not row:
      return None
    return self.itemtype()(self, row)
    
  def get_by_login(self, login):
    assert(type(login) is str)
    rows = self.connection.cache.select(self.table(), {'login': login})
    if not rows or len(rows) > 1:
      return None
    row = rows[0]
    if int(row['id']) == self.rights.user_id or self.rights.issuperuser() or self.server.config['users']['showprofile']:
      return User(self, row)
    return None
  
  def can_list(self):
    return self.rights.issuperuser() or (self.server.config['users']['showlist'] and self.server.config['users']['showprofile'])
  
  def get_list(self):
    result = list()
    if self.can_list():
      rows = self.connection.query_dict('SELECT * FROM %T ORDER BY `login`', self.table())
      for row in rows:
        result.append(User(self, row))
    elif self.rights.user_id:
      current_user = self.get_by_id(self.rights.user_id)
      if current_user:
        result.append(current_user)
    return result