# -*- 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

import datetime
import transaction

from .default import (
    execute_query,
)

def get_faqs(request, faq_id):
    """Lire les FAQ"""
    if faq_id == 0:
        query = "SELECT * FROM p_faq ORDER BY theme, intitule;"
        results = request.dbsession.execute(query).fetchall()
    elif faq_id == -1:
        query = "SELECT * FROM p_faq where theme != 'INTERNE' ORDER BY theme, intitule;"
        results = request.dbsession.execute(query).fetchall()
    else:
        query = "SELECT * FROM p_faq where faq_id = :faq_id;"
        results = request.dbsession.execute(query, {'faq_id': faq_id}).first()
    return results

def update_faq(request, faq_id, intitule, texte, theme):
    """créér ou modifier la FAQ"""
    if faq_id == '0':
        query = "INSERT INTO p_faq (intitule, texte, theme) VALUES(:intitule, :texte, :theme);"
        execute_query(request, query, {'intitule': intitule, 'texte': texte, 'theme': theme})
    else:
        query = "update p_faq set intitule=:intitule, texte=:texte, theme=:theme where faq_id = :faq_id;"
        execute_query(request, query, {'faq_id': faq_id, 'intitule': intitule, 'texte': texte, 'theme': theme})

def delete_faq(request, faq_id):
    """supprimer la FAQ"""
    query = "delete from p_faq where faq_id = :faq_id;"
    execute_query(request, query, {'faq_id': faq_id})

def get_last_payments(request, ):
    """Lire les 50 derniers paiements par carte bancaire"""
    query = """SELECT tickets_cb.*, eleves.nom FROM tickets_cb 
    INNER JOIN eleves ON eleves.cd_cli = tickets_cb.cd_cli ORDER BY date DESC LIMIT 10;"""
    results = request.dbsession.execute(query, {})
    return results.fetchall()

def get_eleves_by_last_connection(request, ):
    # lire les donnees de l'eleve
    query = """SELECT dern_cnx_le,CD_CLI,CIVILITE,NOM,PERMIS_DEMANDE,FORMULE,STATUT,device_used
FROM eleves ORDER BY dern_cnx_le DESC LIMIT 10;"""
    results = request.dbsession.execute(query, )
    return results.fetchall()

def update_user(request, cd_uti, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if param == 'nom':
            new_values['nom'] = new_values['nom'].title()
        if param == 'cd_mon':
            new_values['cd_mon'] = new_values['cd_mon'].upper()
        if param == 'secu':
            ' secu = le 1er caractère'
            new_values['secu'] = new_values['secu'][0]
        if param == 'agence':
            ' agence = le 1er caractère'
            new_values['agence'] = new_values['agence'][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 update_moniteur(request, cd_mon, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if param == 'NOM':
            new_values['NOM'] = new_values['NOM'].upper()
        if param == 'PLANNING':
            new_values['PLANNING'] = new_values['PLANNING'].upper()
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

    if cd_mon == '0':
        query = "INSERT INTO moniteurs SET %s" % s
    else:
        new_values['CD_MON'] = cd_mon.upper()
        query = "UPDATE moniteurs SET %s WHERE CD_MON = :CD_MON;" % s
    execute_query(request, query, new_values)

def update_moniteur_aff(request,no_ligne, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

    if no_ligne == '0':
        query = "INSERT INTO moniteurs_aff SET %s" % s
    else:
        query = "UPDATE moniteurs_aff SET %s WHERE no_ligne = :no_ligne;" % s
    execute_query(request, query, new_values)

def delete_user(request, cd_uti):
    query = "DELETE FROM p_users WHERE cd_uti = :cd_uti ;"
    execute_query(request, query, {'cd_uti': cd_uti})
    
def delete_moniteur(request, cd_mon):
    query = "DELETE FROM moniteurs WHERE cd_mon = :cd_mon ;"
    execute_query(request, query, {'cd_mon': cd_mon})
    
def delete_moniteur_aff(request, no_ligne):
    query = "DELETE FROM moniteurs_aff WHERE no_ligne = :no_ligne ;"
    execute_query(request, query, {'no_ligne': no_ligne})
    
def import_tables(request, table, items, code):
    if table == 'PAYS':
        # Vider la table
        query = "TRUNCATE TABLE ws_pays;"
        execute_query(request, query, {})

        for pays in items:
            query = "INSERT INTO ws_pays (pays) VALUES (:pays);"
            execute_query(request, query, {'pays': pays})
    elif table == 'COMMUNES':
        for commune in items:
            query = "REPLACE INTO ws_communes (dept, commune) VALUES (:code, :commune);"
            execute_query(request, query, {'code': code, 'commune': commune})
    else:
        # Vider la table
        query = "TRUNCATE TABLE ws_departements;"
        execute_query(request, query, {})

        for item in items:
            query = "INSERT INTO ws_departements (code,nom) VALUES (:code, :nom);"
            execute_query(request, query, {'code': item.code, 'nom': item.nom})

def get_last_emailing(request, table):
    """Lire les 200 derniers envois d'emails"""
    if table == 'RESERVATIONS':
        query = "SELECT r.*, e.email FROM email_resa r INNER JOIN eleves e ON r.cd_cli = e.cd_cli GROUP BY r.cd_cli, date(r.cree_le) ORDER BY no_id DESC LIMIT 400;"
    else:
        query = "SELECT r.*, e.email FROM email_rappels r INNER JOIN eleves e ON r.cd_cli = e.cd_cli ORDER BY no_id DESC LIMIT 400;"

    results = request.dbsession.execute(query, {})
    return results.fetchall()

def get_last_7days_cnx(request, ):
    # lire les dernières connexions
    query = """SELECT date(dern_cnx_le) as date, count(*) as nb FROM eleves WHERE dern_cnx_le BETWEEN NOW() - INTERVAL 10 DAY AND NOW() 
GROUP BY date(dern_cnx_le) ORDER BY dern_cnx_le"""
    results = request.dbsession.execute(query, )
    return results.fetchall()

def get_last_7days_paymnt(request, ):
    # lire les dernières paiements
    query = """SELECT date(date) as date, count(*) as nb FROM tickets_cb WHERE date BETWEEN NOW() - INTERVAL 10 DAY AND NOW() 
GROUP BY date(date) ORDER BY date;"""
    results = request.dbsession.execute(query, )
    return results.fetchall()

def get_log_nuit(request, ):
    # lire le log de nuit
    query = """SELECT * FROM t_log_nuit;"""
    results = request.dbsession.execute(query, )
    return results.fetchall()

def get_charts_data(request, chart_id, group1):
    # lire les data
    query = "SELECT * FROM charts_data WHERE id=:chart_id AND group1=:group1;"""
    results = request.dbsession.execute(query, {'chart_id': chart_id, 'group1': group1})
    return results.fetchall()

def get_charts_exam1(request, agence):
    # lire les examens sur 12 mois glissants par agence
    today = datetime.date.today()

    query = """SELECT * FROM ( 
    SELECT * FROM bd_aem.charts_data where id='examens01' and group1 < :mois and group2=:agence order by group1 desc limit 12) t
    ORDER BY group1;"""
    results = request.dbsession.execute(query, {'mois': today.strftime("%Y%m"), 'agence': agence})
    return results.fetchall()

def get_charts_exam2(request, datedeb, datefin, cd_mon):
    # lire les examens sur 12 mois glissants par moniteur
    query = """SELECT * FROM bd_aem.charts_data 
    WHERE id='exams_mon' AND group1 >= :datedeb AND group1 < :datefin AND group2=:cd_mon order by group1;"""
    results = request.dbsession.execute(query, {'datedeb': datedeb.strftime("%Y%m"), 'datefin': datefin.strftime("%Y%m"), 'cd_mon': cd_mon})
    return results.fetchall()

def get_charts_exam2_mon(request, datedeb, datefin):
    query = """SELECT  group2, group2_lib FROM bd_aem.charts_data 
    WHERE id='exams_mon' AND group1 >= :datedeb AND group1 < :datefin GROUP BY group2 ORDER BY group2_lib;"""
    results = request.dbsession.execute(query, {'datedeb': datedeb.strftime("%Y%m"), 'datefin': datefin.strftime("%Y%m")})
    return results.fetchall()
    
def get_inscriptions(request, table):
    if table == 'PAP':
        """ Lire toutes les commandes PAP encours """
        query = """SELECT l.cree_le, l.cd_cli, l.nom, s.debut, e.credit-e.debit as solde, l.valide, l.cd_uti,l.groupe,l.fin_reservation
                    FROM bd_aem.pla_stage_lignes l 
                    INNER JOIN eleves e on e.cd_cli = l.cd_cli
                    INNER JOIN pla_stage s on s.type = l.type AND s.semaine = l.semaine AND s.groupe = l.groupe 
                where l.type='C' and s.fin >= CURRENT_DATE()
                order by s.debut, l.nom desc;"""
    elif table == 'PEM125':
        query = """SELECT l.cree_le, l.cd_cli, l.nom, s.debut, e.credit-e.debit as solde, l.valide, l.cd_uti,l.groupe,l.fin_reservation
                    FROM bd_aem.pla_stage_lignes l 
                    INNER JOIN eleves e on e.cd_cli = l.cd_cli
                    INNER JOIN pla_stage s on s.type = l.type AND s.semaine = l.semaine AND s.groupe = l.groupe 
                where l.type='M' and s.fin >= CURRENT_DATE() and s.libelle like '%pem%' 
                order by s.debut, l.nom desc;"""
    elif table == 'PASA2':
        query = """SELECT l.cree_le, l.cd_cli, l.nom, s.debut, e.credit-e.debit as solde, l.valide, l.cd_uti,l.groupe,l.fin_reservation
                    FROM bd_aem.pla_stage_lignes l 
                    INNER JOIN eleves e on e.cd_cli = l.cd_cli
                    INNER JOIN pla_stage s on s.type = l.type AND s.semaine = l.semaine AND s.groupe = l.groupe 
                where l.type='M' and s.fin >= CURRENT_DATE() and s.libelle like 'pas%' 
                order by s.debut, l.nom desc;"""
    else:
        # stage B96
        query = """SELECT l.cree_le, l.cd_cli, l.nom, s.debut, e.credit-e.debit as solde, l.valide, l.cd_uti,l.groupe,l.fin_reservation
                    FROM bd_aem.pla_stage_lignes l 
                    INNER JOIN eleves e on e.cd_cli = l.cd_cli
                    INNER JOIN pla_stage s on s.type = l.type AND s.semaine = l.semaine AND s.groupe = l.groupe 
                where l.type='B' and s.fin >= CURRENT_DATE() and l.groupe ='G' 
                order by s.debut, l.nom desc;"""
        
    results = request.dbsession.execute(query).fetchall()
    return results

def get_pass_rousseau(request):
    # lire les pass rousseau
    query = """SELECT * FROM pass_rousseau;"""
    results = request.dbsession.execute(query, )
    return results.fetchall()

def update_type_devis(request, type_devis, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():           
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

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

def delete_type_devis(request, type_devis):
    query = "DELETE FROM p_types_devis WHERE type_devis = :type_devis ;"
    execute_query(request, query, {'type_devis': type_devis})

def get_tarifs(request, ref):
    """Lire les tarifs"""
    if ref == '0':
        query = "SELECT * FROM tarifs ORDER BY ref;"
        results = request.dbsession.execute(query).fetchall()
    else:
        query = "SELECT * FROM tarifs where ref = :ref;"
        results = request.dbsession.execute(query, {'ref': ref}).first()
    return results

def get_formules(request, formule, validite):
    """Lire les formules"""
    if formule == '0':
        if validite == 'TOUTES':
            query = "SELECT * FROM formules ORDER BY formule;"
        else:
            query = "SELECT * FROM formules WHERE DateFin >= CURRENT_DATE ORDER BY formule;"            
        results = request.dbsession.execute(query).fetchall()
    else:
        query = "SELECT * FROM formules where formule = :formule;"
        results = request.dbsession.execute(query, {'formule': formule}).first()
    return results

def get_justifs(request, code):
    """Lire les justifs"""
    query = "SELECT * FROM p_justifs WHERE code = :code;"
    results = request.dbsession.execute(query, {'code': code}).first()
    return results

def get_justifsByType(request, type):
    """Lire les justifs"""
    query = "SELECT * FROM p_justifs WHERE type=:type ORDER BY conditions;"
    results = request.dbsession.execute(query, {'type': type}).fetchall()
    return results

def get_permis(request, cat):
    """Lire les permis"""
    if cat == '0':
        query = "SELECT * FROM permis ORDER BY cat;"
        results = request.dbsession.execute(query).fetchall()
    else:
        query = "SELECT * FROM permis where cat = :cat;"
        results = request.dbsession.execute(query, {'cat': cat}).first()
    return results

def update_activite(request, cd_cli, new_values):
    s = ''
    for param in new_values.keys():
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)
    if cd_cli == '0':
        query = "INSERT INTO eleves SET %s " % s
    else:
        query = "UPDATE eleves SET %s WHERE CD_CLI=:CD_CLI" % s
        new_values['CD_CLI'] = cd_cli
    execute_query(request, query, new_values)
    
def delete_activite(request, cd_cli):
    query = "DELETE FROM eleves WHERE CD_CLI=:cd_cli"
    execute_query(request, query, {'cd_cli':cd_cli})

def get_permis_justifs(request, cat, code):
    """Lire les justifs du permis"""
    if code == '0':
        query = """SELECT p.*, j.libelle, j.conditions FROM permis_justifs p INNER JOIN p_justifs j ON p.code = j.code
        WHERE CAT=:cat ORDER BY no_tri;"""
        results = request.dbsession.execute(query, {'cat': cat}).fetchall()
    else:
        query = """SELECT p.*, j.libelle, j.conditions FROM permis_justifs p INNER JOIN p_justifs j ON p.code = j.code
        WHERE p.CAT=:cat AND p.CODE=:code;"""
        results = request.dbsession.execute(query, {'cat': cat, 'code': code}).first()
    return results

def get_tarifs_byFam(request, famille):
    """Lire les tarifs par famille"""
    query = "SELECT * FROM tarifs where fam = :famille order by ref;"
    results = request.dbsession.execute(query, {'famille': famille}).fetchall()
    return results

def get_p_tables(request, table):
    query = "CALL spGet_P_TABLES_byCODE(:table, 0);"
    results = request.dbsession.execute(query, {'table': table}).fetchall()
    return results

def update_tarif(request, ref, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if param == 'LIB':
            new_values['LIB'] = new_values['LIB'].upper()
        if param == 'COMPTE':
            new_values['COMPTE'] = new_values['COMPTE'].split('|')[0]
        if param == 'CTVA':
            ' CTVA = le 1er caractère'
            new_values['CTVA'] = new_values['CTVA'][0]
        if param == 'FAM':
            ' famille = le 1er caractère'
            new_values['FAM'] = new_values['FAM'][0]
            
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

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

def delete_tarif(request, ref):
    query = "DELETE FROM tarifs WHERE ref = :ref ;"
    execute_query(request, query, {'ref': ref})

def update_permis(request, cat, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if param == 'LIB':
            new_values['LIB'] = new_values['LIB'].upper()
            
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

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

def delete_permis(request, cat):
    query = "DELETE FROM permis WHERE cat = :cat ;"
    execute_query(request, query, {'cat': cat})

def delete_formule(request, formule):
    query = "DELETE FROM formules WHERE formule = :formule ;"
    execute_query(request, query, {'formule': formule})

def delete_justif(request, code):
    query = "DELETE FROM p_justifs WHERE code = :code ;"
    execute_query(request, query, {'code': code})

def update_justif(request, code, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():           
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

    if code == '0':
        query = "INSERT INTO p_justifs SET %s" % s
    else:
        new_values['code'] = code
        query = "UPDATE p_justifs SET %s WHERE code = :code;" % s
    execute_query(request, query, new_values)
    
def update_semaine_type(request, code, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():           
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

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

def get_semaine_type_activity(request,code_sem):
    query = "SELECT * FROM  p_semaines  WHERE CODE_SEM = :code"
    query2 = "SELECT * FROM  p_semaine_type  WHERE CODE_SEM = :code"
    results = request.dbsession.execute(query, {'code': code_sem})
    results2 = request.dbsession.execute(query2, {'code': code_sem})
    return results.first(),results2.fetchall()

def delete_semaine_type(request,code_sem):
    query = "DELETE FROM p_semaines WHERE CODE_SEM = :code ;"
    execute_query(request, query, {'code': code_sem})
    
def duplicate_semaine_type(request,code_sem,logged_in):
    query = " CALL spINS_SEMAINE_DUP(:code_sem,:logged_in)"
    execute_query(request, query, {'code_sem': code_sem,'logged_in':logged_in})
    
def get_all_activites(request):
    query = "SELECT * FROM `eleves` WHERE AGENCE=0 AND (PERMIS_DEMANDE='ACTIV' OR PERMIS_DEMANDE='A' OR PERMIS_DEMANDE='A2' OR PERMIS_DEMANDE='B')"
    results = request.dbsession.execute(query).fetchall()
    return results

def get_activite_by_code(request, cd_cli):
    # lire l'eleve connecte
    query = """SELECT * FROM eleves  WHERE cd_cli=:cd_cli;"""
    results = request.dbsession.execute(query, {'cd_cli': cd_cli}).first()
    return results

def update_semaine_type_activity(request,new_values):
    result = None
    s = ''
    no_ligne = new_values['no_ligne']
    del new_values['no_ligne']
    for param in new_values.keys():           
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param).s
    if no_ligne == '' :
        query = """ INSERT INTO p_semaine_type SET %s """ % s + """;"""
        execute_query(request,query,new_values)
        query2 = "SELECT MAX(no_ligne) as  no_ligne from p_semaine_type;"
        result = request.dbsession.execute(query2,new_values).fetchone()
        mark_changed(request.dbsession, keep_session=True)
        transaction.commit()
    else:
        query = """ UPDATE p_semaine_type SET %s WHERE no_ligne = :no_ligne; """ % s
        new_values['no_ligne'] = no_ligne
        execute_query(request,query,new_values)
    return result


def delete_semaine_type_activity(request,no_ligne):
    query = "DELETE FROM p_semaine_type WHERE no_ligne = :no_ligne ;"
    execute_query(request, query, {'no_ligne': no_ligne})
    
def duplicate_semaine_type_activity(request,no_ligne,qte,logged_in):
    query = " CALL spINS_SEMAINE_DUP_ACTIVITY( :no_ligne, :qte, :logged_in) ;"
    execute_query(request,query,{'no_ligne':no_ligne,'qte':qte,'logged_in':logged_in}) 

def update_agence(request, code, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():           
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

    new_values['code'] = code
    query = "UPDATE p_agences SET %s WHERE code = :code;" % s
    execute_query(request, query, new_values)

def delete_permis_justif(request, cat, code):
    query = "DELETE FROM permis_justifs WHERE cat = :cat AND code = :code;"
    execute_query(request, query, {'cat': cat, 'code': code})

def insert_permis_justif(request, cat, code):
    query = "INSERT INTO permis_justifs (`CAT`, `CODE`) VALUES (:cat, :code);"
    execute_query(request, query, {'cat': cat, 'code': code})

def update_permis_justif(request, cat, code, no_tri):
    query = "UPDATE permis_justifs SET no_tri=:no_tri WHERE CAT = :cat AND CODE = :code;"
    execute_query(request, query, {'cat': cat, 'code': code, 'no_tri': no_tri})

def get_permis_justifs_manquant(request, cat):
    """Lire les justifs non encore ajouté dans permis"""
    
    query = """SELECT j.* FROM p_justifs j LEFT JOIN permis_justifs p ON j.code = p.code AND p.cat = :cat
WHERE j.type = 'JUST' AND p.code IS null;"""
    results = request.dbsession.execute(query, {'cat': cat}).fetchall()
    
    return results

def update_formule(request, formule, new_values):
    # formater les champs
    s = ''
    for param in new_values.keys():
        if param == 'LIBELLE':
            new_values['LIBELLE'] = new_values['LIBELLE'].upper()
            
        if s:
            s += ",%s=:%s" % (param, param)
        else:
            s = "%s=:%s" % (param, param)

    if formule == '0':
        query = "INSERT INTO formules SET %s;" % s
    else:
        new_values['formule'] = formule
        query = "UPDATE formules SET %s WHERE formule = :formule;" % s
    execute_query(request, query, new_values)
    
def get_all_semaines_type(request):
    query = "SELECT * FROM `p_semaines` ORDER BY `p_semaines`.`CODE_SEM` DESC";
    results = request.dbsession.execute(query)
    return results.fetchall()