main.cpp

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <cctype>

std::string normalize(std::string text)
{
    std::string result;
    bool previousSpace = false;

    for (char c : text)
    {
        if (std::ispunct(static_cast<unsigned char>(c)))
            continue;
        c = std::tolower(static_cast<unsigned char>(c));
        if (std::isspace(static_cast<unsigned char>(c)))
        {
            if (!previousSpace)
            {
                result += ' ';
                previousSpace = true;
            }
        }
        else
        {
            result += c;
            previousSpace = false;
        }
    }

    // Deleting space in start
    if (!result.empty() && result.front() == ' ')
        result.erase(result.begin());

    // Deleting space in end
    if (!result.empty() && result.back() == ' ')
        result.pop_back();

    return result;
}

std::string toLower(std::string text)
{
    for (char& c : text)
    {
        c = std::tolower(static_cast<unsigned char>(c));
    }

    return text;
}

struct Knowledge
{
    std::string question;
    std::string answer;
};

std::vector<Knowledge> knowledge;

// Loading knowledge from a file
void loadKnowledge()
{
    std::ifstream file("knowledge.txt");

    if (!file.is_open())
        return;

    std::string line;
    std::string question;
    std::string answer;

    while (std::getline(file, line))
    {
        if (line.rfind("Q: ", 0) == 0)
        {
            question = line.substr(3);
        }
        else if (line.rfind("A: ", 0) == 0)
        {
            answer = line.substr(3);

            knowledge.push_back({ question, answer });

            question.clear();
            answer.clear();
        }
    }

    file.close();
}

// Saving new knowledge
void saveKnowledge(const std::string& question, const std::string& answer)
{
    std::ofstream file("knowledge.txt", std::ios::app);

    if (!file.is_open())
    {
        std::cout << "Error: cant open file!\n";
        return;
    }

    file << "Q: " << question << "\n";
    file << "A: " << answer << "\n\n";

    file.close();
}

// Searching for answer
std::string findAnswer(const std::string& question)
{
    std::string normalizedQuestion = normalize(question);

    for (const auto& item : knowledge)
    {
        if (normalize(item.question) == normalizedQuestion)
        {
            return item.answer;
        }
    }

    return "";
}

int main()
{
    // Loading old knowledge
    loadKnowledge();

    std::cout << "AI launched!\n";
    std::cout << "Enter 'exit' to exit\n";

    while (true)
    {
        std::string request;

        std::cout << "You: ";
        std::getline(std::cin, request);

        if (request == "exit" || request == "Exit")
            break;

        // searching answer
        std::string answer = findAnswer(request);

        if (!answer.empty())
        {
            // if know
            std::cout << "AI: " << answer << "\n\n";
        }
        else
        {
            // if unknow
            std::cout << "AI: I dont know answer\n";
            std::cout << "AI: Please, Teach me!\n";

            std::string newAnswer;

            std::cout << "You: ";
            std::getline(std::cin, newAnswer);

            // Adding new knowledge
            knowledge.push_back({ request, newAnswer });

            // Saving on disk
            saveKnowledge(request, newAnswer);

            std::cout << "AI: good, I remembered!\n\n";
        }
    }

    return 0;
}