Dr Watson

# implementer une fonction basique qui demande une phrase et 
# retourne un message positif si la phrase contient 'bien', 
# un message negatif si la phrase contient 'mal', et un message
# "tu n'est pas bavard" si elle est vide

def watson():
    """
    demarre le docteur watson

    parameter
    ---------
    aucun

    return
    ------
    None
    """
    phrase = input("bonjour, à vous: ").lower()

    if "mal" in phrase:
        print("Ohhhh, c'est triste.")
    elif "bien" in phrase:
        print("C'est super.")
    elif not phrase:
        print("Tu n'es pas bavard.")
    else:
        print("je ne comprends pas...")

    print("C'est fini, au revoir !")

if __name__ == "__main__":
    watson()

# ameliore watson4 en ajoutant a 'while True' pour faire une boucle infinie
# bien penser à ajouter une condition de sortie avec des exit_words

def init_watson(config_filename):
    """
    load the config_file_name and returns set of
    sentiment words in a tuple

    parameter
    ---------
    config_file_name: the name of the file to load

    return
    ------
    the tuple of sets (positive_words, negative_words, exit_words)
    """
    positive_words, negative_words, exit_words = set(), set(), set()
    with open(config_filename, "r", encoding="utf8") as f:
        for line in f:
            # we remove the \n char is if it is at the end of the line
            # it might not be the case at the end of the file
            line = line.rstrip()
            if not line:
                continue
            kind, *words = line.split()
            match kind:
                case "POSITIVE":
                    positive_words.update(set(words))
                case "NEGATIVE":
                    negative_words.update(set(words))
                case "EXIT":
                    exit_words.update(set(words))

    return positive_words, negative_words, exit_words


def test_phrase_sentiment(sentence, sentiment):
    """
    take a sentence and return True if any words
    in sentiment is in phrase

    parameter
    ---------
    phrase: a set of str
    sentiment: a set of str containing sentiment words

    return
    ------
    the interection between the words in the sentence and the words
    in the sentiment set
    """
    return sentence.intersection(sentiment)


def watson():
    """
    start doctor watson
    """
    positive_words, negative_words, exit_words = init_watson(
        "watson-config.txt"
    )

    prompt = 'bonjour, à vous: '
    while True:
        phrase = set(input(prompt).lower().split())

        if test_phrase_sentiment(phrase, negative_words):
            prompt = "Ohhhh, c'est triste, mais encore...\n"
        elif test_phrase_sentiment(phrase, positive_words):
            prompt = "C'est super, mais encore...\n"
        elif test_phrase_sentiment(phrase, exit_words):
            break
        elif not phrase:
            prompt = "Tu n'es pas bavard. Que peux-tu me dire...\n"
        else:
            prompt = "je ne comprends pas...\n"

    print("C'est fini, au revoir !")


if __name__ == "__main__":
    watson()

# pylint: disable=missing-module-docstring, missing-class-docstring, missing-function-docstring

# v7: refactored

# for smart argument parsing and integrated help
import argparse

# for type hints
Name = str


# not everything is needed, but just to illustrate dunder methods...
class Sentence:

    def __init__(self, sentence):
        self.sentence = sentence
        self.words = self.sentence.split()

    def __str__(self):
        return str(self.sentence)

    def __contains__(self, word):
        return word in self.sentence

    def __len__(self):
        return len(self.words)

    def __getitem__(self, i):
        return self.words[i]


class Feeling:

    def __init__(self, name, words):
        self.name = name
        self.words = set(words)

    def resonates(self, sentence : Sentence) -> bool:
        """
        returns whether the sentence contains any word in the feeling
        """
        return self.words & {word.lower() for word in sentence.words}

    def outline(self, sentence : str) -> str:
        """
        returns sentence, but with the words in the feeling outlined
        """
        def outline(word):
            return f"*{word}*" if word.lower() in self.words else word
        return " ".join(outline(word) for word in sentence.words)


class Watson:

    # could go in the config as well, but would probably require
    # an alternative format like e.g. yaml
    answers = {
        'POSITIVE': "C'est super, mais encore...",
        'NEGATIVE': "Ohhhh, c'est triste, mais encore...",
        'EXIT': "C'est fini, au revoir !"
    }


    def __init__(self, config_filename):
        self.config_filename = config_filename
        # store in self.feelings a dict NAME -> Feeling
        self.feelings = dict()
        with open(config_filename, "r", encoding="utf8") as f:
            for line in f:
                line = line.rstrip()
                if not line:
                    continue
                name, *words = line.split()
                self.feelings[name] = Feeling(name, words)

    def run(self, debug=False):
        prompt = 'bonjour, à vous: '
        active = True
        while active:
            sentence = Sentence(input(prompt).lower())
            for name, feeling in self.feelings.items():
                if feeling.resonates(sentence):
                    print(self.answers[feeling.name])
                    if debug:
                        print("DEBUG:", feeling.outline(sentence))
                    if name == 'EXIT':
                        active = False
                    break
            else:
                print("je ne comprends pas...")


if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    parser.add_argument(
        "-c", "--config", default="watson-config.txt",
        help="give the config file to load feelings")
    parser.add_argument(
        "-d", "--debug", action="store_true",
        help="print debug information")

    args = parser.parse_args()
    Watson(args.config).run(args.debug)