#include <cmath>
#include <map>
#include <string>
#include <algorithm>
#include <iostream>
#include <set>
#include <utility>
#include <vector>
#include <numeric>
#include <chrono>
using namespace std;

const int MAX_RESULT_DOCUMENT_COUNT = 5;
enum class DocumentStatus{
    ACTUAL,
    IRRELEVANT,
    BANNED,
    REMOVED
};
vector<string> SplitIntoWords(const string &text){
    vector<string> words;
    string word;

    for(const char &c : text){
        if(c == ' '){
            if(!word.empty()){
                words.push_back(word);
                word.clear();
            }
        } else{
            word += c;
        }
    }
    if(!word.empty()){
        words.push_back(word);
    }
    return words;
}
struct Document{
    int id;
    double relevance;
    int rating;
};
class SearchServer{
public:
    void SetStopWords(const string &text){
        for(const string &word : SplitIntoWords(text)){
            stop_words_.insert(word);
        }
    }
    void AddDocument(const int &document_id, const string &document, DocumentStatus status, const vector<int> &ratings){
        ++document_count_;
        vector<string> ex_doc = SplitIntoWordsNoStop(document);
        double counted = (double)ex_doc.size();
        for(const auto &word : ex_doc){
            word_to_document_freqs_[word].insert({document_id,count(ex_doc.begin(), ex_doc.end(), word) / counted});
        }
        if(!ratings.empty()){
            document_ratings_[document_id].rating = ComputeAverageRating(ratings);
            document_ratings_[document_id].status = status;
        } else{
            document_ratings_[document_id].rating = 0;
            document_ratings_[document_id].status = status;
        }
        //document_ratings_[document_id] = {ComputeAverageRating(ratings),status};
        //document_ratings_.emplace(document_id, Status{ComputeAverageRating(ratings), status});
    }
    template<typename FuncPredict>
    vector<Document> FindTopDocuments(const string &raw_query, FuncPredict predict) const{
        const double EPSILON = 1e-6;
        const Query query_words = ParseQuery(raw_query);
        vector<Document> matched_documents = FindAllDocuments(query_words, predict);

        sort(matched_documents.begin(), matched_documents.end(),

            [EPSILON](const Document &lhs, const Document &rhs){
                if(abs(lhs.relevance - rhs.relevance) < EPSILON){
                    return lhs.rating > rhs.rating;
                } else{
                    return lhs.relevance > rhs.relevance;
                }
            }
        );
        if(matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT){
            matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
        }
        return matched_documents;
    }
    auto FindTopDocuments(const string &raw_query) const{
        return FindTopDocuments(raw_query,
            [](int document_id, DocumentStatus status, int rating){
                return status == DocumentStatus::ACTUAL;
            }
        );
    }
    int GetDocumentCount() const{
        return document_count_;
    };
    tuple<vector<string>, DocumentStatus> MatchDocument(const string &raw_query, int document_id) const{
        vector<string> matched_words;

        for(const string &word : ParseQuery(raw_query).plus_words)
            if(word_to_document_freqs_.count(word))
                if(word_to_document_freqs_.at(word).count(document_id))
                    matched_words.push_back(word);


        for(const string &word : ParseQuery(raw_query).minus_words)
            if(word_to_document_freqs_.count(word))
                if(word_to_document_freqs_.at(word).count(document_id)){
                    matched_words.clear();
                    break;
                }
        return{matched_words, document_ratings_.at(document_id).status};
    };
private:
    struct Query{
        set<string> plus_words;
        set<string> minus_words;
    };
    struct Status{
        int rating;
        DocumentStatus status;
    };
    map<string, map<int, double>> word_to_document_freqs_;
    set<string> stop_words_;
    int document_count_ = 0;
    map<int, Status> document_ratings_;

    vector<string> SplitIntoWordsNoStop(const string &text) const{
        vector<string> words;

        for(const string &word : SplitIntoWords(text)){
            if(!(stop_words_.count(word) > 0)){
                words.push_back(word);
            }
        }
        return words;
    }
    Query ParseQueryWord(const set<string> &text) const{
        Query query;

        for(auto &word : text){
            if(word[0] == '-'){
                query.minus_words.insert(word.substr(1));
            } else{
                query.plus_words.insert(word);
            }
        }
        return query;
    }
    Query ParseQuery(const string &text) const{
        set<string> query_words;

        for(const string &word : SplitIntoWordsNoStop(text)){
            query_words.insert(word);
        }
        return ParseQueryWord(query_words);
    }
    double CalcTFIDF(const string query_word, const double tf) const{
        return log(document_count_ / (double)word_to_document_freqs_.at(query_word).size()) * tf;
    }
    template<typename FuncPredict>
    vector<Document> FindAllDocuments(const Query &query_words, FuncPredict predict)const{
        vector<Document> matched_documents;
        map<int, double> document_to_relevance;

        for(const auto &query_word : query_words.plus_words){
            if(word_to_document_freqs_.count(query_word)){
                for(const auto &[id,tf] : word_to_document_freqs_.at(query_word)){
                    if constexpr(is_same_v<FuncPredict, DocumentStatus>){
                        if(predict(id, document_ratings_.at(id).status, document_ratings_.at(id).rating)){
                            document_to_relevance[id] += CalcTFIDF(query_word, tf);
                        }
                    }else{
                        switch(document_ratings_.at(id).status){
                            case DocumentStatus::BANNED:
                                FindAllDocuments(query_words,
                                    [](int document_id, DocumentStatus status, int rating){
                                        return status == DocumentStatus::BANNED;
                                    }
                                );
                        }
                    }

                }
            }
        }
        for(const auto &query_word : query_words.minus_words){
            if(word_to_document_freqs_.count(query_word)){
                for(const auto &[id, tf] : word_to_document_freqs_.at(query_word)){
                    document_to_relevance.erase(id);
                }
            }
        }
        for(const auto &[document_id, relevance] : document_to_relevance){
            matched_documents.push_back({document_id,relevance,document_ratings_.at(document_id).rating});
        }
        return matched_documents;
    }
    static int ComputeAverageRating(const vector<int> &ratings){
        int sum = 0;
        if(ratings.size() == 0){
            return 0;
        } else{
            for(const int &number : ratings)
                sum += number;
            return sum / (int)ratings.size();
        }
        return 0;
    }
};
void PrintDocument(const Document &document){
    cout << "{ "s
        << "document_id = "s << document.id << ", "s
        << "relevance = "s << document.relevance << ", "s
        << "rating = "s << document.rating
        << " }"s << endl;
}
int main(){
    SearchServer search_server;
    search_server.SetStopWords("и в на"s);
    search_server.AddDocument(0, "белый кот и модный ошейник"s, DocumentStatus::ACTUAL, {8, -3});
    search_server.AddDocument(1, "пушистый кот пушистый хвост"s, DocumentStatus::ACTUAL, {7, 2, 7});
    search_server.AddDocument(2, "ухоженный пёс выразительные глаза"s, DocumentStatus::ACTUAL, {5, -12, 2, 1});
    search_server.AddDocument(3, "ухоженный скворец евгений"s, DocumentStatus::BANNED, {9});
    cout << "ACTUAL by default:"s << endl;
    for(const Document &document : search_server.FindTopDocuments("пушистый ухоженный кот"s)){
        PrintDocument(document);
    }
    cout << "BANNED:"s << endl;
    for(const Document &document : search_server.FindTopDocuments("пушистый ухоженный кот"s, DocumentStatus::BANNED)){
        PrintDocument(document);
    }
    cout << "Even ids:"s << endl;
    for(const Document &document : search_server.FindTopDocuments("пушистый ухоженный кот"s, [](int document_id, DocumentStatus status, int rating){ return document_id % 2 == 0; })){
        PrintDocument(document);
    }
    return 0;
}
/*enum class AnimalSortKey{
    AGE,     // по полю age
    WEIGHT,  // по полю weight
    RELATIVE_WEIGHT  // по weight / age
};
struct Animal{
    string name;
    int age;
    double weight;
};
template <typename Container, typename KeyMapper>
void SortBy(Container &container, KeyMapper key_mapper, bool reverse = false){
    if constexpr(is_same_v<KeyMapper, AnimalSortKey>){
        switch(key_mapper){
            case AnimalSortKey::AGE:
                return SortBy(container, [](const auto &x){ return x.age; }, reverse);
            case AnimalSortKey::WEIGHT:
                return SortBy(container, [](const auto &x){ return x.weight; }, reverse);
            case AnimalSortKey::RELATIVE_WEIGHT:
                return SortBy(container, [](const auto &x){ return x.weight / x.age; }, reverse);
        }
    } else{
        if(reverse){
            sort(container.begin(), container.end(),
                [key_mapper](const auto &lhs, const auto &rhs){
                    return key_mapper(lhs) > key_mapper(rhs);
                }
            );
        } else{
            sort(container.begin(), container.end(),
                [key_mapper](const auto &lhs, const auto &rhs){
                    return key_mapper(lhs) < key_mapper(rhs);
                }
            );
        }
    }
}
void PrintNames(const vector<Animal> &animals){
    for(const Animal &animal : animals){
        cout << animal.name << ' ';
    }
    cout << endl;
}
int main(){
    setlocale(LC_ALL, "");
    vector<Animal> animals = {
        {"Мурка"s,   10, 5},
        {"Белка"s,   5,  1.5},
        {"Георгий"s, 2,  4.5},
        {"Рюрик"s,   12, 3.1},
    };
    PrintNames(animals);
    // Мурка Белка Георгий Рюрик
    SortBy(animals, [](const Animal &animal){ return animal.name; }, true);
    PrintNames(animals);
    // Рюрик Мурка Георгий Белка
    SortBy(animals, AnimalSortKey::RELATIVE_WEIGHT);
    PrintNames(animals);
    // ожидаем вывод: Рюрик Белка Мурка Георгий
}*/