# -*- coding: cp1252 -*-
# Altorithme ID3 programme par Jean-Gabriel Ganascia

from math import log
#from string import split
import io

# fonction d'ouverture d'un fichier
def ouvrir(chaine):
    drapeau = 0
    while exdrapeau == 0:
        drapeau = 1
        nom = input(chaine)
        try:
            fichier = open(nom + '.txt', "r")
        except IOError:
            print("Ce n'est pas un fichier texte! Recommencez.")
            drapeau = 0
    fichier.close()
    return nom

def lire(fic):
    entree = open(fic+'.txt', "r")
    texte = entree.read().split('\n')
    entree.close()
    return texte

# classe ensemble apprentissage: stocke l'ensemble des exemples
class ensembleApprentissage:
    def __init__(self):
        self.Nom = ouvrir("Donner les nom du fichier d'exemples: ")
        self.Texte = lire(self.Nom)
        self.Attributs = self.Texte[0].split()
        self.ensApprentissage = {}
        j = 1
        for i in range(1, len(self.Texte)):
            if self.Texte[i].split() != []:
                self.ensApprentissage[j] = self.Texte[i].split()
                j = j+1
        self.nombreExemples = len(self.ensApprentissage)
        self.classeTerminale = input("  Classe terminale: ")
        while not self.classeTerminale in self.Attributs:
            print("  La classe terminale doit etre l'un des attributs suivants:")
            for x in self.Attributs:
                print("   - ", x)
            self.classeTerminale = input(" Classe terminale: ")

    def valeur(self, Attr, Ex):
        return self.ensApprentissage[Ex][self.Attributs.index(Attr)]

    def valeurs(self, Attr, Exs) :
        l = []
        for Ex in Exs:
            v = self.valeur(Attr, Ex)
            if not v in l:
                l.append(v)
        return l

    def sousEnsemble(self, Attr, Val, Exs):
        l = []
        for Ex in Exs:
            if self.valeur(Attr, Ex) == Val:
                l.append(Ex)
        return l

    def entropie(self, Exs):
        vals = self.valeurs(self.classeTerminale, Exs)
        N = float(len(Exs))
        entr = 0
        for Vi in vals:
            Ni = float(len(self.sousEnsemble(self.classeTerminale, Vi, Exs)))
            Pi = Ni/N
            entr = entr - Ni*log(Pi)
        return entr

    def entropieFils(self, Attr, Exs):
        vals = self.valeurs(Attr, Exs)
        Entr = 0
        for Vi in vals:
            Ei = self.sousEnsemble(Attr, Vi, Exs)
            Si = self.entropie(Ei)
            Entr = Entr + Si
        return Entr


    def classeMajoritaire(self, Exs):
        vals = self.valeurs(self.classeTerminale, Exs)
        E = 0
        C = ''
        for v in vals:
            I = self.sousEnsemble(self.classeTerminale, v, Exs)
            if len(I) > E:
                E = len(I)
                C = v
        return C
        
# classe ensemble test: stocke l'ensemble des exemples de test
class ensembleTest:
    def __init__(self, ens):
        self.Nom = ouvrir("Donner les nom du fichier test: ")
        self.Texte = lire(self.Nom)
        self.Attributs = self.Texte[0].split()
        self.ensTest = {}
        j = 1
        for i in range(1, len(self.Texte)):
            if self.Texte[i].split() != []:
                self.ensTest[j] = self.Texte[i].split()
                j = j+1
        self.nombreExemples = len(self.ensTest)
        self.classeTerminale = ens.classeTerminale

# classe "arbreD": stocke et construit un arbre de decision
class arbreD:
    def __init__(self, Exs, Attrs, EnsAppr):
        self.exemples = Exs
        self.Attributs = Attrs
        self.Attribut = ''
        self.Classe = ''
        self.EnsAppr = EnsAppr
        self.fils = {}

    def construire(self):
        self.Classe = self.terminale()
        if self.Classe != '':
            return
#        self.Attribut = self.choixAttributSimple() # choix d'attribut, simple
        self.Attribut = self.choixAttributEntropie() # choix d'attribut, critère entropique
#        self.Attribut = self.choixAttributInvEntropie() # choix d'attribut, critère entropique
        if self.Attribut == '':
            self.Classe = self.EnsAppr.classeMajoritaire(self.exemples)
            return
        Nattrs = self.Attributs[0:]
        Nattrs.remove(self.Attribut)
        vals = self.EnsAppr.valeurs(self.Attribut, self.exemples)
        for v in vals:
            self.fils[v] = arbreD(self.EnsAppr.sousEnsemble(self.Attribut, v, self.exemples),
                                  Nattrs,
                                  self.EnsAppr)
            self.fils[v].construire()

    def terminale(self):
        if self.exemples == []:
            return 'vide'
        vals = self.EnsAppr.valeurs(self.EnsAppr.classeTerminale, self.exemples)
        if len(vals) == 1:
            return vals[0]
        return ''
    
    def choixAttributSimple(self):
        if self.Attributs != []:
            return self.Attributs[0]
        else: return ''

    def choixAttributInvEntropie(self):
        I = self.EnsAppr.entropieFils(self.Attributs[0], self.exemples)
        A = self.Attributs[0]
        for attrs in self.Attributs[1:]:
            E = self.EnsAppr.entropieFils(attrs, self.exemples)
            if E >= I:
                A = attrs
                I = E
        return A
    
    def choixAttributEntropie(self):
        I = self.EnsAppr.entropie(self.exemples)
        A = ''
        for attrs in self.Attributs:
            E = self.EnsAppr.entropieFils(attrs, self.exemples)
            if E < I:
                A = attrs
                I = E
        return A
                
            

    def impression(self, i):
        j = 0
        tab = ''
        while j<i:
            tab = tab + '\t'
            j = j + 1
        print(tab + self.Attribut)
        for v in self.fils.keys():
            ch = tab + "    = " + v + "  "
            if self.fils[v].Classe != '':
                print(ch, self.EnsAppr.classeTerminale, ":", self.fils[v].Classe, "  #")
            else:
                print(ch)
                self.fils[v].impression(i+1)

    def classifier(self, Ex):
        if self.Classe != '':
            return self.Classe
        i = self.EnsAppr.Attributs.index(self.Attribut)
        v = Ex[i]
        return self.fils[v].classifier(Ex)

    def tester(self):
        Test = ensembleTest(self.EnsAppr)
        i = Test.Attributs.index(self.EnsAppr.classeTerminale)
        bonClassement = 0
        mauvaisClassement = 0
        for Ex in Test.ensTest.keys():
            res = self.classifier(Test.ensTest[Ex])
            val = Test.ensTest[Ex][i]
            if res == val:
                bonClassement = bonClassement + 1
            else: mauvaisClassement = mauvaisClassement + 1
            print(Test.ensTest[Ex], ' res: ', res, "  ", (res == val))
        tauxClassement = float(bonClassement)/float(bonClassement + mauvaisClassement)
        print("Pourcentage exemples bien classes: ", tauxClassement)
        
                

if __name__ == '__main__':
    ensAppr = ensembleApprentissage()
    attrs = ensAppr.Attributs[0:]
    attrs.remove(ensAppr.classeTerminale)
    a = arbreD(ensAppr.ensApprentissage.keys(), attrs, ensAppr)
    a.construire()
    a.impression(0)
    a.tester()