import sys
from Globale import*
from pg8000 import DBAPI

class GestionBD:
    """Mise en place et interfaçage d'une base de données MySQL"""
    def __init__(self, dbName, user, passwd, host, port= 5432):
        "Établissement de la connexion - Création du curseur"
        try:
            self.baseDonn = DBAPI.connect(database= dbName,
                                          user= user, password= passwd,
                                          host= host, port= port)
        except Exception as err:
            print ('La connexion avec la base de données a échoué :\n'\
                  'Erreur détectée :\n%s' % err)
            self.echec =1
        else:    
            self.cursor = self.baseDonn.cursor()   # création du curseur
            self.echec =0

    def creerTable(self, dicTables):
        "Création des tables décrites dans le dictionnaire <dicTables>."
        for table in dicTables:            # parcours des clés du dict.
            req = "CREATE TABLE %s (" % table
            pk =''
            for descr in dicTables[table]:
                nomChamp = descr[0]        # libellé du champ à créer
                tch = descr[1]             # type de champ à créer
                if tch =='i':
                    typeChamp ='INTEGER'
                elif tch =='k':
                    # champ 'clé primaire' (incrémenté automatiquement)
                    typeChamp ='INTEGER AUTO_INCREMENT'   
                    pk = nomChamp
                else:
                    typeChamp ='VARCHAR(%s)' % tch                
                req = req + "%s %s, " % (nomChamp, typeChamp)
            if pk == '':
                req = req[:-2] + ")"
            else:
                req = req + "CONSTRAINT %s_pk PRIMARY KEY(%s))" % (pk, pk)
            self.executerReq(req)

    def supprimerTables(self, dicTables):
        "Suppression de toutes les tables décrites dans <dicTables>"
        for table in dicTables.keys():
            req ="DROP TABLE %s" % table
            self.executerReq(req) 
        self.commit()                       # transfert -> disque

    def executerReq(self, req):
        "Exécution de la requête <req>, avec détection d'erreur éventuelle"
        try:
            self.cursor.execute(req)
            
        except Exception as err:
               # afficher la requête et le message d'erreur système :
               print ("Requête SQL incorrecte :\n%s\nErreur détectée :\n%s"\
               % (req, err))
               return 0
        else:
             return 1

    def resultatReq(self):
        "renvoie le résultat de la requête précédente (un tuple de tuples)"
        return self.cursor.fetchall()

    def commit(self):
       if self.baseDonn:
          self.baseDonn.commit()         # transfert curseur -> disque        

    def close(self):
        if self.baseDonn:
           self.baseDonn.close()


class Enregistreur():
    """classe pour gérer l'entrée d'enregistrement divers"""
    def __init__(self, bd, table):
        self.bd = bd
        self.table = table
        self.descriptif = Glob.dicoT[table]    #descriptif des champs

    def entrer(self):
        "procédure d'entrée d'un enregistrement d'entier"
        champs = "("      #ébauche d'une chaine pour les nom de champs
        valeurs = []      #liste pour les valeurs correspondantes

        #Demander successivement une valeur pour chaque champ
        for cha, type, nom in self.descriptif:
            if(type == "k"):                #on ne demandera pas le n° d'enregistrement
               continue                     #à l'utilisateur (numérotation auto)
            
            champs = champs + cha + ","
            val = input("Entrez le champ {}".format(nom))

            if(type == "i"):
               val = int(val)
               
            valeurs.append(val)
            
        balise = "(" + "%s," * len(valeurs)  #balise de conversion
        champs = champs[:-1] + "("           #supprimer la dernière virgule,
        balise = balise[:-1] + "("           #et ajouté une parentèse
        req    = "INSERT INTO {} {} VALUES {}".format(self.table, champs, balise)
        self.bd.executeReq(req, valeur)

        ch = input("Continuer(O/N)? ")
        if(ch.upper() == "O"):
           return 0
        else:
           return 1

class Glob():
      """Espace de noms pour les variables et fonctions <pseudo_globales>"""
      dbName  = "musique"          #Nom de la base de dodnnées
      user    = "ShikiSokuZeku"    #propriétaire ou utilisateur
      passwd  = "Hayabuza"         #mot de passe d'accés
      host    = "127.0.0.1"
      port    = 5432

      #Structure de la base de données. Dictionnaire des table & champs:
      dicoT ={"compositeurs":[('id_comp', "k", "clé primaire"),
                              ('nom', 25, "nom"),
                              ('prenom', 25, "prénom"),
                              ('a_naiss', "i", "année de naissance"),
                              ('a_mort', "i", "année de mort")],
              "oeuvres":[('id_oeuv', "k", "clé primaire"),
                         ('id_comp', "i", "clé compositeur"),
                         ('titre', 50, "titre de l'oeuvre"),
                         ('duree', "i", "durée (en minutes)"),
                         ('interpr', 30, "interprète principal")]}

import sys
from Globale import*
from BD      import*

#Création de l'objet-interface avec la base de donnée
bd = GestionBD(Glob.dbName, Glob.user, Glob.passwd, Glob.host, Glob.port)
if bd.echec:
   sys.exit()

while 1:
   print("\nQue voulez-vous faire: \n"\
         "1) Créer les tables de la base de données\n"\
         "2) Supprimer les tables de la base de données\n"\
         "3) Entrer des compositeurs\n"\
         "4) Entrer des oeuvres\n"\
         "5) Lister les compositeur\n"\
         "6) Lister les oeuvres\n"\
         "7) Executer une requëte SQL quelconque\n"\
         "8) terminer?   Votre choix: ", end= ' ')
   ch = int(input())
   if(ch == 1):
      #création de toute les tables décrites dans le dico
      bd.creerTable(Glob.dicoT)
      
   elif(ch == 2):
      #suppression de toutes les tables décrites dans le dic
      bd.supprimerTable(Glob.dicoT)

   elif(ch == 3 or ch == 4):
      #création d'un enregistreur de compositeur ou d'oeuvre
      table = {3: 'compositeur', 4: 'oeuvres'}[ch]
      enreg = Enregistrement(bd, table)

      while 1:
          if(enreg.entrer()):
             break

   elif(ch == 5 or ch == 6):
         #Listage de tout les compositeur || oeuvre
         table = {5: 'compositeur', 6: 'oeuvres'}[ch]
         
         if(bd.executerReq("SELECT * FROM %s" % table)):
            #analyser le résultat de la requête ci-dessus
            records = bd.resultatReq()     #ce serat un tuple de tuple
            
            for rec in record:             #chaque enregistrement
                for item in req:           #chaque champ dans l'enregistrement
                    print(item, end= ' ')

   elif(ch == 7):
         req == input("Entrez la requête SQL: ")
         if(bd.executerReq(req)):
            print(bd.resultatReq())        #ce serat un tuple de tuple

   else:
         bd.comit()
         bd.close()
         break