# -*- coding: utf8 -*-
from sqlalchemy import text
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import (
    scoped_session,
    sessionmaker,
)
from zope.sqlalchemy import (
    ZopeTransactionExtension, 
    mark_changed
)

from datetime import *
import transaction

def execute_query(request, query, params):
    """Execute query and mark session as changed"""
    request.dbsession.execute(query, params)
    mark_changed(request.dbsession)
    transaction.commit()

def get_userAccess(request, logged_in):
    member = get_member_by_id(request, logged_in)
    if member:
        return member.access 
    else:
        return 0 
    
def get_member_by_mdp_oublie(request, lien):
    query = "SELECT * FROM p_users WHERE mdp_oublie=:lien;"
    results = request.dbsession.execute(query, {'lien':lien}).first()
    return results

def get_member_by_id(request, mbr_id):
    if mbr_id == '0':
        query = "SELECT * FROM p_users ORDER BY cd_uti"
        results = request.dbsession.execute(query).fetchall()
    else:
        # lire le membres par son identifianr
        query = """SELECT * FROM p_users WHERE CD_UTI=:mbr_id;"""
        results = request.dbsession.execute(query, {'mbr_id': mbr_id}).first()
    return results

def get_member_info(request, logged_in):
    # lire le membres par son identifianr
    query = """SELECT nom, email, access, societe FROM p_users WHERE CD_UTI=:logged_in;"""
    results = request.dbsession.execute(query, {'logged_in': logged_in}).first()
    if results.access == 9:
        fonction = 'Administrateur'
    elif results.access == 8:
        fonction = 'Comptabilité'
    elif results.access == 5:
        fonction = 'Gestion'
    else:
        fonction = 'Production'       
    
    return {
        'nom': results.nom,
        'email': results.email,
        'fonction': fonction,
        'societe': results.societe,
        }

def update_membre_mdp_oublie(request, login):
    import uuid, base64 
    # get a UUID - URL safe, Base64
    
    uid = uuid.uuid1()
    urlslug = base64.urlsafe_b64encode(uid.bytes).decode("utf-8").rstrip('=\n').replace('/', '_')
    query = "UPDATE p_users SET mdp_oublie=:urlslug, mdp_oublie_date=now() WHERE CD_UTI=:login;"
    execute_query(request, query, {'urlslug':urlslug, 'login':login})
    
    return urlslug

def update_membre_mdp(request, login, password):
    """Update password for member login"""
    query = "UPDATE p_users SET mdp = SHA1(:password), mdp_oublie=NULL, mdp_oublie_date=NULL WHERE cd_uti=:login;"
    execute_query(request, query, {'login': login, 'password': password})

def update_last_connection(request, login, ua_string):
    """Update last connection for login """
    query = "UPDATE p_users SET dern_cnx_le=NOW(), ua_string=:ua_string WHERE cd_uti=:login;"
    execute_query(request, query, {'login': login, 'ua_string': ua_string})

def update_membre(request, cd_uti, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if param == 'nom':
            new_values['nom'] = new_values['nom'].upper()
        if param == 'access':
            ' ne prend que le 1er caractère'
            new_values['access'] = new_values['access'][0]
            
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

    if cd_uti == '0':
        query = "INSERT INTO p_users SET %s" % s
    else:
        new_values['cd_uti'] = cd_uti
        query = "UPDATE p_users SET %s WHERE cd_uti = :cd_uti;" % s
    execute_query(request, query, new_values)

def delete_membre(request, cd_uti):
    query = "DELETE FROM p_users WHERE cd_uti = :cd_uti ;"
    execute_query(request, query, {'cd_uti': cd_uti})

def get_article(request, type, groupe, libelle):
    if type == 'LIB':
        if groupe == 'TEXTE':
            # lire tous les textes dont le libelle commençe par 
            query = "SELECT * FROM tarifs WHERE groupe='TEXTE' and libelle like :libelle;"
            results = request.dbsession.execute(query, {'libelle': libelle + "%"}).fetchall()
        else:
            # lire tous les tarifs du grupe dont le ref commençe par libelle
            query = "SELECT * FROM tarifs WHERE groupe=:groupe and ref like :libelle;"
            results = request.dbsession.execute(query, {'groupe': groupe, 'libelle': libelle + "%"}).fetchall()
    else:
        # lire tous les tarif du grupe dont le ref est égale à
        query = "SELECT * FROM tarifs WHERE groupe=:groupe and ref = :libelle;"
        results = request.dbsession.execute(query, {'groupe': groupe, 'libelle': libelle}).first()
    return results

def get_codespostaux(request, codep):
    query = "SELECT * FROM p_codespostaux WHERE code_postal LIKE :code;"
    results = request.dbsession.execute(query, {'code': codep+"%"}).fetchall()
    return results

def get_dd_restant(request):
    query = """SELECT (SELECT count(*) FROM dem_devis WHERE societe='PE' AND STATUS=0) AS nb_PE,
  (SELECT count(*) FROM dem_devis WHERE societe='ME' AND STATUS=0) AS nb_ME,
  (SELECT count(*) FROM dem_devis WHERE societe='PL' AND STATUS=0) AS nb_PL;"""
    results = request.dbsession.execute(query).first()
    return results

def get_de_restant(request):
    # les suivis des attachés commerciaux dnas les 4 derniers jours
    query = """SELECT 
(SELECT count(*) FROM dem_lig WHERE societe='PE' AND DATEDIFF(CURDATE(), date) <= 7 AND usermaj in ('CG','MP','RV','VD')) AS nb_PE,
(SELECT count(*) FROM dem_lig WHERE societe='ME' AND DATEDIFF(CURDATE(), date) <= 7 AND usermaj in ('CG','MP','RV','VD')) AS nb_ME,
(SELECT count(*) FROM dem_lig WHERE societe='PL' AND DATEDIFF(CURDATE(), date) <= 7 AND usermaj in ('CG','MP','RV','VD')) AS nb_PL;"""
    results = request.dbsession.execute(query).first()
    return results

def get_fa_restant(request):
    query = """SELECT (SELECT count(*) FROM facture WHERE societe='PE' AND STATUS < 8) AS nb_PE,
  (SELECT count(*) FROM facture WHERE societe='ME' AND STATUS < 8) AS nb_ME,
  (SELECT count(*) FROM facture WHERE societe='PL' AND STATUS < 8) AS nb_PL;"""
    results = request.dbsession.execute(query).first()
    return results

def get_rdv_by_date(request, date, agenda):
    query = """SELECT COUNT(*) AS nb_rdv FROM bddevfac.dem_lig WHERE DATEVI=:date AND LISTE=:agenda;"""
    results = request.dbsession.execute(query, {'date': date, 'agenda': agenda}).first()
    return results

def get_rdf_null(request):
    # lire les RDF non validés depuis moins d'un an
    query = """SELECT COUNT(*) AS nb_rdf FROM bddevfac.dem_rdf WHERE DATEDIFF(CURDATE(), date_inter) < 365 AND date_relu IS NULL;"""
    results = request.dbsession.execute(query).first()
    return results