# Exécution de requêtes SQL sur une base de données SQLite avec
# affichage des résultats dans un fichier html sous la forme d'un
# tableau

# Importation de modules:

import sqlite3

# Définition de fonctions nécessaires:

########## Générateur du fichier résultat ###########

def htmlFile_from_template(templatename, htmlfilename, requete, resultat):
    """
    htmlFile_from_template(str templatename, str htmlfilename, str requete, str resultat) --> None

    Créer un fichier XHTML <htmlfilename> à partir du patron de mise en page
    <templatename> en y introduisant la <requete> ainsi que le code HTML <resultat>
    aux emplacements du code balisés "request", respectivement "result"
    """

    # Ouverture du patron de mise en page nommé <templatename>:
    templateFile = open(templatename, 'r', encoding='utf-8')

    # Création du fichier XHTML nommé <htmlfilename>:
    htmlFile = open(htmlfilename, 'w', encoding = 'utf-8')

    # Lecture du code du patron de mise en page <templatename>:
    code = templateFile.read()

    # Insertion de la <requete> et du contenu <resultat> dans le code
    # précédemment chargé:
    code = code.format(request = requete, result = resultat)

    # Ecriture du code XHTML dans le fichier <htmlfilename>:
    htmlFile.write(code)

    # Fermeture des fichiers:
    templateFile.close()
    htmlFile.close()
    
    
########## Générateur de code HTML ###########

def html_from_sql_result(cursor):
    """
    Retourne le code HTML affichant les enregistrements situés dans le curseur <cursor>
    sous la forme d'un tableau
    """

    code = ''       # création du code HTML à générer

    # Récupération de tous les enregistrements du curseur sous forme de liste d'objets Row
    enregistrements = cursor.fetchall()

    try:
        # Récupération de la liste des noms de champs
        nomAttributs = enregistrements[0].keys()
        
    except:
        code += '<div class = "sqlResult"> La requête n\'a retourné aucun résultat.</div>'

    else:
        # si la requête donne lieu à plusieurs enregistrements en résultat
        if len(enregistrements) > 0:

            # code XHTML de l'en-tête du tableau en tant qu'élément de la classe css .sqlResultHeader
            table_header = '<tr class ="sqlResultHeader"><th>{donnees}</th></tr>\n'.format(donnees='</th><th>'.join(nomAttributs))

            # code XHTML du corps du tableau: les lignes sont des éléments de la classe css .rowclass0 ou .rowclass1
            # selon leur position dans la table (=> alternance de couleurs des lignes)
            table_enregistrements = ''
            row_index = 0

            for e in enregistrements:

                # récupération des valeurs des attributs associés à l'enregistrement traité
                valeurs = []
                for champ in nomAttributs:
                    valeurs.append(str(e[champ]))


                # construction de la ligne du tableau associée à l'enregistrement traité
                elements = '</td><td>'.join(valeurs)     
                table_enregistrements += '<tr class = "rowclass{index}"><td>{donnees}</td></tr>\n'.format(index=row_index, donnees=elements)
                row_index = (row_index + 1) % 2         # moduler l'index de la ligne pour assurer l'alternance des couleurs

            code += '<table>\n {entete} \n {contenu} \n</table>\n'.format(entete=table_header, contenu=table_enregistrements)

        # si la requête ne donne pas lieu à plusieurs enregistrements en résultat
        else:
            code += '<div class = "sqlResult"> La requête s\'est exécutée mais n\'a retourné aucun résultat.</div>'

    return code


########## Corps principal du programme ##############

############################################
# Compléter le code aux endroits indiqués: #
############################################

# Configuration du programme:

counter = 0                         # compteur de fichiers HTML générés

modele = 'template.html'            # modèle de document
css_file = 'MonStyle.css'           # feuille de style associée
db = 'Librairie.sq3'                # base de données associée


# Connexion et curseur:
conn = sqlite3.connect(db)          # connexion à la BD
conn.row_factory = sqlite3.Row      # Retourner les enregistrements sous forme de tableau associatif
cur = conn.cursor()                 # définition du curseur

while 1:
    # Récupération de la requete à exécuter:
    req = input("Entrez une requête SQL (ou <Enter> pour terminer): ")
    
    if req == "":
        break
    
    try:
        cur.execute(req)        # exécution de la requête SQL
        
    except:
        print("*** Requête SQL incorrecte ***")
        
    else:
        # Générer le code HTML du résultat:
        code = # à compléter

        #Nnommer le fichier contenant le résultat de la requete:
        counter += 1
        html_file = 'requete' + str(counter) + '.html'
        
        # Insérer le code HTML généré dans le fichier
        # A compléter 

# Fermeture de la connexion et du curseur

choix = input("Confirmez-vous l'enregistrement de l'état actuel (o/n) ? ")
if choix[0].upper() == "O":
    conn.commit()
cur.close()
conn.close()