""" Fonctions utilitaires pour gérer des facteurs de certitude. """

def fc_ou(fc1, fc2):
    """ Calcule le facteur de certitude d'une disjonction de faits. """

    print('à compléter')

def fc_et(fc1, fc2):
    """ Calcule le facteur de certitude d'une conjonction de faits. """

    print('à compléter')

from .facteurs_certitude import fc_et

class RegleAvecVariables_FC:
    """ Représentation d'une règle d'inférence pour le chaînage avec variables. """

    def __init__(self, conditions, conclusion, fc=1.0):
        """ Construit une règle étant donné une liste de conditions,\
            une conclusion et un facteur de certitude associé.

            :param list conditions: une collection de propositions (pouvant\
            contenir des variables) nécessaires à déclencher la règle.
            :param conclusion: la proposition (pouvant contenir des variables)\
            résultant du déclenchement de la règle.
            :param fc: le facteur de certitude associé.
        """

        print('à compléter')

    def depend_de(self, fait, methode):
        """ Vérifie qu'un fait fait partie, sous réserve de substitution,\
            des conditions de la règle.

            :param fait: un fait qui doit faire partie des conditions de\
            déclenchement.
            :param methode: ``Filtre`` ou ``Unificateur``, détermine le type\
             de pattern match à appliquer.
            :return: un dictionnaire qui attribue un environnement à chaque\
            condition qui peut être satisfaite par le fait pasée en paramètre.\
            ``False`` si aucune condition n'est satisfaite par le fait.
        """

        envs = {}

        for condition in self.conditions:
            # Si au moins une des conditions retourne un environnement,
            # nous savons que la proposition satisfait une des conditions.
            env = methode.pattern_match(fait, condition, {})
            if env != methode.echec:
                envs[condition] = env

        return envs

    def satisfaite_par(self, faits, cond, env, env_fc, methode):
        """ Vérifie que des faits suffisent, sous réserve de substitution,\
            à déclencher la règle.

            :param list faits: une liste de faits.
            :param cond: la condition qui a donné lieu à ``env`` par le\
            pattern match.
            :param dict env: un environnement de départ déjà établi par\
            ``depend_de``.
            :param env_fc: le facteur de certitude associé à ``env``.
            :param methode: ``Filtre`` ou ``Unificateur``, détermine le type\
             de pattern match à appliquer.
            :return: une liste d'environnements qui correspondent à toutes les\
            substitutions possibles entre les conditions de la règle et les\
            propositions. On retourne une liste vide si au moins une condition\
            ne peut être satisfaite.
        """

        print('à compléter')

    def __repr__(self):
        """ Représentation d'une règle sous forme de string. """

        return '{} => {}, {}'.format(str(self.conditions),
                                     str(self.conclusion),
                                     str(self.fc))

from .facteurs_certitude import fc_ou
from moteur_avec_variables_fc.regle_avec_variables_fc import RegleAvecVariables_FC

class BaseConnaissances_FC:
    """ Une base de connaissances destinée à contenir les faits et les règles\
        d'un système de chaînage avec facteurs de certitude.
    """

    def __init__(self):
        """ Construit une base de connaissances. """

        self.faits = {}
        self.regles = []

    def ajoute_un_fait(self, fait):
        """ Ajoute un fait dans la base de connaissances.

            Un fait est un tuple composé du fait proprement dit, c'est-à-dire\
            une proposition sans variable, et optionnellement d'un scalaire\
            représentant son facteur de certitude.

            :param fait: un fait.
        """

        print('à compléter')

    def ajoute_faits(self, faits):
        """ Ajoute une liste de faits dans la base de connaissances.

            :param list faits: une liste de faits.
        """

        for fait in faits:
            self.ajoute_un_fait(fait)

    def ajoute_une_regle(self, description):
        """ Ajoute une règle dans la base de connaissances étant donné sa\
            description.

            Une règle est décrite par une liste (ou un tuple) de deux ou trois\
            éléments: une liste de conditions, une conclusion et un facteur de\
            certitude optionnel.

            Les conditions et la conclusion doivent être des propositions.

            :param description: une description de règle.
        """

        print('à compléter')

    def ajoute_regles(self, descriptions):
        """ Ajoute des règles dans la base de connaissance.

            L'argument est une liste de descriptions, chacune composée d'une\
            liste de conditions, d'une conséquence et optionnellement d'un\
            facteur de certitude.

            :param list descriptions: une liste de descriptions de règles.
        """

        for description in descriptions:
            self.ajoute_une_regle(description)

from moteur_sans_variables.chainage import Chainage
from moteur_avec_variables.filtre import Filtre

class ChainageAvantAvecVariables_FC(Chainage):
    """ Un moteur d'inférence à chaînage avant avec variables. """

    def __init__(self, connaissances, methode=None):
        """
            :param methode: ``Filtre`` ou ``Unificateur``, détermine le type de\
            pattern match à appliquer. ``Filtre`` par défaut.
        """

        Chainage.__init__(self, connaissances)

        if methode is None:
            self.methode = Filtre()
        else:
            self.methode = methode

    def instancie_conclusion(self, regle, envs_et_fcs):
        """ Instancie la conclusion d'une règle pour tous les environnements.

            :param regle: la règle dont la conclusion doit être instanciée.
            :param list envs_et_fcs: une liste de paires d'environnements et de\
            facteurs de certitude servant à instancier la conclusion de la règle.
            :return: une liste de propositions correspondant aux différentes\
            instanciations de la conclusion.
        """

        print('à compléter')

    def chaine(self):
        """ Effectue le chaînage avant sur les faits et les règles contenus\
            dans la base de connaissances.
        """

        print('à compléter')

from sys import argv, exit
from moteur_avec_variables_fc.regle_avec_variables_fc import RegleAvecVariables_FC
from moteur_avec_variables_fc.connaissance_fc import BaseConnaissances_FC
from moteur_avec_variables.unificateur import Unificateur
from moteur_avec_variables.filtre import Filtre
from moteur_avec_variables_fc.chainage_avant_avec_variables_fc import ChainageAvantAvecVariables_FC

regles = [
    ([('placentaire', '?x')], ('mammifère', '?x')),
    ([('marsupial', '?x')], ('mammifère', '?x')),
    ([('monotrème', '?x')], ('mammifère', '?x')),
    ([('placentaire-1', '?x')], ('placentaire', '?x')),
    ([('genre-placentaire', '?x')], ('placentaire', '?x')),
    ([('a-des-poils', '?x'), ('a-des-bébés-formes', '?x'),
      ('température-stable', '?x')],
     ('placentaire-1', '?x'), 9.0/10.0),
    ([('a-des-poils', '?x'), ('a-des-bébés-foetaux', '?x'),
      ('température-stable', '?x')],
     ('marsupial', '?x'), 95.0/100.0),
    ([('a-des-oeufs', '?x'), ('a-des-poils', '?x'),
      ('température-stable', '?x')],
     ('monotrème', '?x')),
    ([('singe', '?x')], ('genre-placentaire', '?x')),
    ([('primate', '?x')], ('singe', '?x')),
    ([('lémurien', '?x')], ('singe', '?x')),
    ([('chimpanzé', '?x')], ('primate', '?x')),
    ([('gorille', '?x')], ('primate', '?x')),
    ([('canidé', '?x')], ('genre-placentaire', '?x')),
    ([('chien', '?x')], ('canidé', '?x')),
    ([('loup', '?x')], ('canidé', '?x')),
    ([('lycaon', '?x')], ('canidé', '?x')),
    ([('félin', '?x')], ('genre-placentaire', '?x')),
    ([('chat', '?x')], ('félin', '?x')),
    ([('lion', '?x')], ('félin', '?x')),
    ([('tigre', '?x')], ('félin', '?x')),
    ([('tigre-du-bengale', '?x')], ('tigre', '?x')),
    ([('tigre-de-l-himalaya', '?x')], ('tigre', '?x')),
    ]

if len(argv) < 2 or argv[1].lower() not in ('a', 'b'):
    print('On attend au moins un arguments: A ou B')
    exit(1)

if argv[1].lower() == 'a':
    faits_initiaux = [
        (('a-des-poils', 'blaireau'),),
        (('a-des-bébés-formes', 'blaireau'),),
        (('température-stable', 'blaireau'),),
        (('a-des-poils', 'écureuil'),),
        (('a-des-bébés-formes', 'écureuil'),),
        (('température-stable', 'écureuil'),),
        (('chimpanzé', 'cheetah'),),
        (('gorille', 'bozo'),),
        (('singe', 'babouin'),),
        (('singe', 'paresseux'),),
        (('chien', 'bill'),),
        (('loup', 'loup-1'),),
        (('lycaon', 'lycaon-1'),),
        (('chat', 'mistigri'),),
        (('lion', 'minet'),),
        (('tigre-du-bengale', 'tigre-du-bengale-1'),),
        (('a-des-poils', 'kangourou'),),
        (('a-des-bébés-foetaux', 'kangourou'),),
        (('température-stable', 'kangourou'),),
        (('a-des-oeufs', 'ornythorinque'),),
        (('a-des-oeufs', 'nouveau-spécimen'), 5.0/10.0),
        (('a-des-poils', 'ornythorinque'),),
        (('température-stable', 'nouveau-spécimen'), 9.0/10.0),
        (('température-stable', 'ornythorinque'),),
    ]
elif argv[1].lower() == 'b':
    faits_initiaux = [
        (('a-des-oeufs', 'nouveau-spécimen'), 5.0/10.0),
        (('température-stable', 'nouveau-spécimen'), 9.0/10.0),
        (('a-des-poils', 'nouveau-spécimen'), 9.0/10.0),
        (('a-des-poils', 'écureuil'),),
        (('a-des-bébé-formes', 'écureuil'),),
        (('température-stable', 'écureuil'),),
        (('a-des-poils', 'un-spécimen-qui-ressemble-à-un-écureuil'), 0.9),
        (('a-des-bébé-formes', 'un-spécimen-qui-ressemble-à-un-écureuil'), 0.7),
        (('température-stable', 'un-spécimen-qui-ressemble-à-un-écureuil'), 0.8),
    ]

bc = BaseConnaissances_FC()
bc.ajoute_faits(faits_initiaux)
bc.ajoute_regles(regles)

moteur = ChainageAvantAvecVariables_FC(connaissances=bc, methode=Filtre())
moteur.chaine()

moteur.affiche_solutions()

if len(argv) > 2 and argv[2].lower() == 'trace':
    moteur.affiche_trace()