from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.shortcuts import redirect
from django.urls import reverse
from configurazione.views import *

from .models import *

# Create your views here.

def getSecurityLevelAll(enabled=1):
  '''
  ritorna l'elenco dei livelli di sicurezza ordinati per nome
  parms:
    enabled (default 1)
    di default restituisce l'intero elenco solo se le voci sono abituate
  '''

  return SecurityLevel.objects.all().filter(enabled=enabled).order_by('nome')

def getSecurityLevel(id,enabled=1,debug=0):
  '''
  ritorna il livello di sicurezza indicato, in forma d'oggetto.
  '''

  #primo step: verifica l'intestazione, se e' attiva
  try:
    securitylevel = SecurityLevel.objects.get(pk=id)
  except SecurityLevel.DoesNotExist as dne:
    if debug:
      print('il record {} non esiste o non e\' attivo'.format(id))
    #nel caso non fosse possibile, viene preso il valore di default
    securitylevel = SecurityLevel.objects.get(pk=getConfigurazione('default-level'))
  if securitylevel.enabled != enabled:
    securitylevel = SecurityLevel.objects.get(pk=getConfigurazione('default-level'))
  return securitylevel

def getSecurityRow(id,enabled=1,debug=0):
  '''
  securityrow contiene l'associazione tra i livelli di sicurezza e le opzioni.
  per ottenerlo gli passiamo l'id del securitylevel.
  '''
  #verifica che l'id sia valido, semplicemente richiamando getSecurityLevel
  id = getSecurityLevel(id,enabled)

  orderbylist=['securityoptions__comando','ordine']
  try:
    securityrow = SecurityRow.objects.filter(securitylevel=id).filter(enabled=enabled).order_by(*orderbylist)
  except SecurityRow.DoesNotExist as dne:
    print('non ci sono righe associate all\'id {}'.format(id))
    return SecurityRow()
  #securityrow contiene l'elenco delle Options estratte.
  if debug:
    print(securityrow)
  return securityrow

def getSecurityList(securityrow,debug=0):
  securitylist=[]
  for sr in securityrow:
    srtemp = getSecurityOptions(sr.securityoptions_id)
    if debug:
      print(srtemp.acronimo)
    securitylist.append(srtemp.acronimo)
    print("SecurityList: ",securitylist)
  return securitylist

def getSecurityOptions(id):
  '''
  ritorna il contenuto della security options a cui si fa riferimento
  '''

  #! nota: sarebbe da capire se puo' tornare il record in caso di false enabled in row o level

  try:
    resultoptions = SecurityOptions.objects.get(pk=id)
  except SecurityOptions.DoesNotExist as dne:
    print("non ci sono elementi di SecurityOptions da tornare con l'id {}".format(id))
    return None
  return resultoptions

def getSecurityLevelByUser(userId,enabled=1):
  '''
  ottiene il livello di sicurezza passando direttamente l'id utente

  la sequenza e' veloce:
  cerca l'utente indicato
  verifica che abbia un level valido altrimenti ritorna il default
  estrare l'elenco delle options abilitate
  '''

  try:
    u = User.objects.get(pk=userId)
    #l'utente esiste ed e' valido
  except User.DoesNotExist as dnf:
    #l'utente non esiste
    return HttpResponseRedirect(reverse('login:welcome',args={}))

  try:
    securitylevel = getSecurityLevel(u.securitylevel)
  except SecurityLevel.DoesNotExist as dne:
    print(f'attenzione, security level non impostata per utente {u.id}')
    v = getConfigurazione('default-level')
    securitylevel = getSecurityLevel(v)
  return securitylevel

def getSecurityOptionsByUser(UserId):
  '''
  ottiene l'elenco delle righe di securityrow
  '''

  securitylevel = getSecurityLevelByUser(UserId,enabled=1)
  securityoptions = getSecurityOptions(securitylevel.id)
  return securityoptions

def _checkSessionValue(request,key,debug=0):
  if debug:
    print("session:",key,request.session.get(key))
  try:
    tmp = request.session.get(key)
  except:
    request.flush()
    return HttpResponseRedirect(reverse('Login:login'))
  return tmp

def getSessionParms(request,debug=0):
  '''
  estrae i valori dalla sessione necessari per operare
  '''

  lista=[
  '_userauth_',
  '_user2edit_',
  '_alias2edit_',
  '_domain2edit_',
  '_domainservice2edit_',
  '_contatto2edit_',
  '_registrar2edit_',
  '_liste2edit_',
  '_listeaccount2edit_',
  '_ftp2edit_',
  '_sqlserver2edit_',
  '_from_',
  '_domain_order',
  '_sqldatabase2edit_',
  '_note2edit_',
  '_filtro2edit_',
  '_causale2edit_',
  '_mqtt2edit_',
  '_webserver2edit_',
  '_web2edit',
  '_proxyserver2edit_',
  'proxy2edit_',
  '_spam2edit_',

  ]

  v2r = dict()

  for i in lista:
    v2r[i] = _checkSessionValue(request,i)

  if debug:
    print('v2r from session:',v2r)

  '''
  nota effettua subito la verifica dell'utente, cosi' salta al volo al login nel caso il check fosse non valido
  '''

  if not '_userauth_' in v2r:
    redirect(reverse('Login:login'))

  try:
     User.objects.get(pk=v2r['_userauth_'])
  except User.DoesNotExist as DNE:
    print("errore, utente autorizzato non esistente")
    print(DNE)
    redirect(reverse('Login:login'))

  print('_userauth_',v2r['_userauth_'])
  return v2r

def ManageSecurityLevelList(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  securitylevel = SecurityLevel.objects.all().order_by('nome')

  value = {}
  value['utenteautorizzato']=utenteautorizzato
  value['sicurezza']=securitylevel
  value['navbar'] = True

  return render(request,'securitylevellist.html',value)

def ManageSecurityRowList(request,levelId):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  securityrow = SecurityRow.objects.all().filter(securitylevel=levelId).order_by('id')

  value = {}
  value['utenteautorizzato'] = utenteautorizzato
  value['righe'] = securityrow
  value['navbar'] = True


  return render(request,'securityrowlist.html',value)


#decorator: anziche' gestire tutta la sessione di sicurezza dentro la funzione,
# magari possiamo fare la stessa cosa con un decoratore.

def securitywrap(function):
  def wrapper(*args,**kwargs):
    print('...wrapping')
    print(args)
    print(kwargs)
    return function(*args,**kwargs)
  return wrapper


'''
from supporto import managepassword
from sicurezza.views import *
from logger.views import *
from comunicazioni.views import *
from datetime import date,datetime
from configurazione.views import *

def UserList(request):

  session = getSessionParms(request)
  userauth = session['_userauth_']
  user2edit = session['_user2edit_']
  domain2edit = session['_domain2edit_']
  request.session['_from_']="Utenti:UserList"

  print(next)
  if not user2edit:
    user2edit = userauth

  try:
    utenteautorizzato = User.objects.get(pk=userauth)
  except User.DoesNotExist as dne:
    return  HttpResponseRedirect(reverse('Login:login',args={}))

  if not domain2edit:
    domain2edit = utenteautorizzato.domain.id

  dominio = Domini.objects.get(pk=domain2edit)

  userlist = User.objects.filter(domain=domain2edit).order_by('mail')

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['user'] = None
  value['userlist'] = userlist
  value['dominio'] = dominio
  value['navbar'] = True

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(utenteautorizzato.securitylevel_id)

  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['CANWRITE']=True #per il momento, questo flag serve a capire se e' un record nuovo
'''